diff options
Diffstat (limited to 'engines')
37 files changed, 1780 insertions, 62 deletions
diff --git a/engines/bladerunner/actor.cpp b/engines/bladerunner/actor.cpp index f483263f76..af9cef7258 100644 --- a/engines/bladerunner/actor.cpp +++ b/engines/bladerunner/actor.cpp @@ -38,7 +38,7 @@ Actor::Actor(BladeRunnerEngine *vm, int actorId) { _bbox = new BoundingBox(); - // TODO: Construct _clues ((actorId && actor != 99) ? 2 : 4) + _clues = new ActorClues(vm, ((actorId && actorId != 99) ? 2 : 4)); // TODO: Construct _movementTrack @@ -69,6 +69,8 @@ void Actor::setup(int actorId) { _isTargetable = false; _isInvisible = false; _isImmuneToObstacles = false; + + _isRetired = false; _width = 0; _height = 0; @@ -105,11 +107,35 @@ void Actor::setup(int actorId) { void Actor::set_at_xyz(Vector3 pos, int facing) { _position = pos; _facing = facing; + + +// this->x = x; +// this->y = y; +// this->z = z; +// actor::set_angle(this, angle, addOrSet); +// if (scene::get_sceneId(Scene) == this->sceneId) +// this->walkboxId = set::findWalkbox(Scene->set, x, z); +// else +// this->walkboxId = -1; +// actor::setBoundingBox(this, x, y, z, retired); +// sceneObjects::removeScreneObject(SceneObjects, this->id); +// scene = this->sceneId; +// if (scene == scene::get_sceneId(Scene)) +// sceneObjects::addActor( +// SceneObjects, +// this->id, +// this->boundingBox, +// &this->screenRect, +// 1, +// a7, +// this->targetable, +// retired); } void Actor::draw() { Vector3 draw_position(_position.x, -_position.z, _position.y + 2.0); float draw_facing = _facing * M_PI / 512.0; + // just for viewing animations _facing = (_facing + 10) % 1024; // float draw_scale = _scale; // TODO: Handle SHORTY mode diff --git a/engines/bladerunner/actor.h b/engines/bladerunner/actor.h index b51bc3fefb..d621d5316a 100644 --- a/engines/bladerunner/actor.h +++ b/engines/bladerunner/actor.h @@ -26,6 +26,11 @@ #include "bladerunner/bladerunner.h" #include "bladerunner/vector.h" +#include "bladerunner/movement_track.h" +#include "bladerunner/actor_clues.h" +#include "bladerunner/actor_walk.h" + +#include "common/rect.h" namespace BladeRunner { @@ -37,7 +42,8 @@ class Actor { private: BoundingBox *_bbox; - // MovementTrack *_movementTrack; + Common::Rect _screenRectangle; + MovementTrack *_movementTrack; int _honesty; int _intelligence; @@ -49,7 +55,7 @@ private: int _currentHP; int _maxHP; - // Clues _clues; + ActorClues* _clues; int _id; int _set; @@ -62,6 +68,8 @@ private: bool _isInvisible; bool _isImmuneToObstacles; + bool _isRetired; + // Animation int _width; int _height; @@ -71,7 +79,7 @@ private: int _animationId; int _animationFrame; - // WalkInfo _walkInfo; + ActorWalk* _walkInfo; int _timersRemain[7]; int _timersBegan[7]; @@ -87,6 +95,12 @@ public: void set_at_xyz(Vector3 pos, int facing); void draw(); + + int getSet() { return _set; } + BoundingBox* getBoundingBox() { return _bbox; } + Common::Rect* getScreenRectangle() { return &_screenRectangle; } + bool isRetired() { return _isRetired; } + bool isTargetable() { return _isTargetable; } }; } // End of namespace BladeRunner diff --git a/engines/bladerunner/actor_clues.cpp b/engines/bladerunner/actor_clues.cpp new file mode 100644 index 0000000000..f99b6b1d61 --- /dev/null +++ b/engines/bladerunner/actor_clues.cpp @@ -0,0 +1,181 @@ +#include "bladerunner/actor_clues.h" + +namespace BladeRunner +{ + + ActorClues::ActorClues(BladeRunnerEngine *vm, int cluesType) + { + _vm = vm; + _count = 0; + _maxCount = 0; + _clues = 0; + switch (cluesType) + { + case 4: + _maxCount = _vm->_gameInfo->getClueCount(); + break; + case 3: + _maxCount = 100; + break; + case 2: + _maxCount = 50; + break; + case 1: + _maxCount = 25; + break; + case 0: + _maxCount = 0; + break; + default: + return; + } + + if (_maxCount > 0) + _clues = new ActorClue[_maxCount]; + else + _clues = NULL; + + if (_clues) + removeAll(); + else + _maxCount = NULL; + } + + ActorClues::~ActorClues() + { + if (_clues) + delete[] _clues; + + _maxCount = 0; + _count = 0; + } + + void ActorClues::acquire(int clueId, char flag2, int fromActorId) + { + int clueIndex = findClueIndex(clueId); + _clues[clueIndex]._flags |= 0x01; + _clues[_count]._flags = _clues[_count]._flags & 0xFD | ((flag2 << 1) & 0x02); + _clues[clueIndex]._fromActorId = fromActorId; + } + + void ActorClues::lose(int clueId) + { + int clueIndex = findClueIndex(clueId); + _clues[clueIndex]._flags = 0; + } + + int ActorClues::isAcquired(int clueId) + { + int clueIndex = findClueIndex(clueId); + if (clueIndex == -1) + return 0; + + return _clues[clueIndex]._flags & 0x01; + } + + int ActorClues::getFromActorId(int clueId) + { + int clueIndex = findClueIndex(clueId); + if (clueIndex == -1) + return -1; + + return _clues[clueIndex]._fromActorId; + } + + int ActorClues::isFlag2(int clueId) + { + int clueIndex = findClueIndex(clueId); + if (clueIndex == -1) + return 0; + + return (_clues[clueIndex]._flags & 0x02) >> 1; + } + + int ActorClues::isFlag3(int clueId) + { + int clueIndex = findClueIndex(clueId); + if (clueIndex == -1) + return 0; + + return (_clues[clueIndex]._flags & 0x04) >> 2; + } + + int ActorClues::isFlag4(int clueId) + { + int clueIndex = findClueIndex(clueId); + if (clueIndex == -1) + return 0; + + return (_clues[clueIndex]._flags & 0x08) >> 3; + } + + int ActorClues::getField1(int clueId) + { + if (!_count) + return 0; + + int clueIndex = findClueIndex(clueId); + if (clueIndex == -1) + return 0; + + return _clues[clueIndex]._field1; + } + + int ActorClues::getCount() + { + return _count; + } + + void ActorClues::removeAll() + { + _count = 0; + for (int i = 0; i < _maxCount; ++i) { + remove(i); + } + } + + int ActorClues::findClueIndex(int clueId) + { + for (int i = 0; i < _count; i++) { + if (clueId == _clues[i]._clueId) { + return i; + } + } + return -1; + } + + void ActorClues::add(int actorId, int clueId, int field1, char acquired, char flag2, int fromActorId) + { + _clues[_count]._clueId = clueId; + _clues[_count]._field1 = field1; + + _clues[_count]._flags = 0; + _clues[_count]._flags = _clues[_count]._flags & 0xFE | (acquired & 0x01); + _clues[_count]._flags = _clues[_count]._flags & 0xFD | ((flag2 << 1) & 0x02); + + _clues[_count]._fromActorId = fromActorId; + ++_count; + } + + void ActorClues::remove(int index) + { + _clues[index]._clueId = -1; + _clues[index]._field1 = 0; + _clues[index]._flags = 0; + _clues[index]._fromActorId = -1; + + _clues[index]._field3 = -1; + _clues[index]._field4 = 0; + _clues[index]._field5 = -1; + _clues[index]._field6 = 0; + _clues[index]._field7 = -1; + _clues[index]._field8 = 0; + } + + int ActorClues::exists(int clueId) + { + return findClueIndex(clueId) != -1; + } + + +}
\ No newline at end of file diff --git a/engines/bladerunner/actor_clues.h b/engines/bladerunner/actor_clues.h new file mode 100644 index 0000000000..02d6bbb1ca --- /dev/null +++ b/engines/bladerunner/actor_clues.h @@ -0,0 +1,82 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_ACTOR_CLUES_H +#define BLADERUNNER_ACTOR_CLUES_H + +#include "bladerunner/bladerunner.h" + +#include "bladerunner/gameinfo.h" + +namespace BladeRunner { + + struct ActorClue + { + int _clueId; + int _field1; + int _fromActorId; + int _field3; + int _field4; + int _field5; + int _field6; + int _field7; + int _field8; + unsigned char _flags; + }; + + class ActorClues + { + BladeRunnerEngine *_vm; + + private: + int _count; + int _maxCount; + ActorClue *_clues; + + public: + ActorClues(BladeRunnerEngine *_vm, int cluesType); + ~ActorClues(); + + void acquire(int clueId, char flag2, int fromActorId); + void lose(int clueId); + int isAcquired(int clueId); + int getFromActorId(int clueId); + int isFlag2(int clueId); + int isFlag3(int clueId); + int isFlag4(int clueId); + int getField1(int clueId); + + int getCount(); + + void removeAll(); + + //savegame + //loadgame + private: + int findClueIndex(int clueId); + void add(int actorId, int clueId, int field1, char acquired, char flag2, int fromActorId); + void remove(int clueIndex); + int exists(int clueId); + }; +} + +#endif diff --git a/engines/bladerunner/actor_walk.cpp b/engines/bladerunner/actor_walk.cpp new file mode 100644 index 0000000000..a4cfad7fde --- /dev/null +++ b/engines/bladerunner/actor_walk.cpp @@ -0,0 +1,8 @@ +#include "bladerunner/actor_walk.h" + +namespace BladeRunner +{ + + + +}
\ No newline at end of file diff --git a/engines/bladerunner/actor_walk.h b/engines/bladerunner/actor_walk.h new file mode 100644 index 0000000000..c44c15bbe4 --- /dev/null +++ b/engines/bladerunner/actor_walk.h @@ -0,0 +1,52 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_ACTOR_WALK_H +#define BLADERUNNER_ACTOR_WALK_H + +#include "bladerunner/vector.h" + +namespace BladeRunner +{ + struct ActorWalkEntry + { + int _actorId; + int _present; + }; + + class ActorWalk + { + int _walking; + int _running; + Vector3 _wanted; + Vector3 _unknown; + Vector3 _start; + Vector3 _end; + int facing; + ActorWalkEntry _actors[20]; + int _actorsCount; + int _field15; + int _status; + }; +} + +#endif diff --git a/engines/bladerunner/audio_player.cpp b/engines/bladerunner/audio_player.cpp index ecfc95aaa7..b8df01cd85 100644 --- a/engines/bladerunner/audio_player.cpp +++ b/engines/bladerunner/audio_player.cpp @@ -165,7 +165,7 @@ void AudioPlayer::fadeAndStopTrack(Track *track, int time) int AudioPlayer::playAud(const Common::String &name, int volume, int panFrom, int panTo, int priority, byte flags) { /* Find first available track or, alternatively, the lowest priority playing track */ - int trackId; + int trackId = -1; Track *track = NULL; int lowestPriority = 100; Track *lowestPriorityTrack = NULL; diff --git a/engines/bladerunner/bladerunner.cpp b/engines/bladerunner/bladerunner.cpp index ca83ac9a19..22199e6fd7 100644 --- a/engines/bladerunner/bladerunner.cpp +++ b/engines/bladerunner/bladerunner.cpp @@ -35,6 +35,7 @@ #include "bladerunner/mouse.h" #include "bladerunner/outtake.h" #include "bladerunner/scene.h" +#include "bladerunner/scene_objects.h" #include "bladerunner/script/init.h" #include "bladerunner/script/script.h" #include "bladerunner/settings.h" @@ -65,6 +66,7 @@ BladeRunnerEngine::BladeRunnerEngine(OSystem *syst) _script = new Script(this); _settings = new Settings(this); + _lights = new Lights(this); } BladeRunnerEngine::~BladeRunnerEngine() { @@ -87,7 +89,7 @@ BladeRunnerEngine::~BladeRunnerEngine() { // delete[] _zBuffer1; // delete[] _zBuffer2; - + delete _lights; delete _settings; delete _script; } @@ -162,9 +164,9 @@ bool BladeRunnerEngine::startup(bool hasSavegames) { // TODO: Sine and cosine lookup tables for intervals of 1.0, 4.0, and 12.0 - // TODO: View + _view = new View(this); - // TODO: Screen Index + _sceneObjects = new SceneObjects(this, _view); _gameFlags = new GameFlags(); _gameFlags->setFlagCount(_gameInfo->getFlagCount()); @@ -401,9 +403,11 @@ void BladeRunnerEngine::shutdown() { delete _gameFlags; _gameFlags = 0; - // TODO: Delete View + delete _view; + _view = 0; - // TODO: Delete Screen Index + delete _sceneObjects; + _sceneObjects = 0; // TODO: Delete sine and cosine lookup tables @@ -517,7 +521,7 @@ void BladeRunnerEngine::gameTick() { // TODO: Tick and draw all actors in current set (drawing works in Replicant) // HACK to draw McCoy - _sliceRenderer->setView(_scene->_view); + //_sliceRenderer->setView(&_scene->_view); _playerActor->draw(); // TODO: Draw items (drawing works in Replicant) diff --git a/engines/bladerunner/bladerunner.h b/engines/bladerunner/bladerunner.h index d0ded00b76..814041d0ed 100644 --- a/engines/bladerunner/bladerunner.h +++ b/engines/bladerunner/bladerunner.h @@ -46,12 +46,16 @@ class GameInfo; class GameFlags; class Mouse; class Scene; +class SceneObjects; class Script; class Settings; class Shape; class SliceAnimations; class SliceRenderer; class TextResource; +class Lights; +class View; + class BladeRunnerEngine : public Engine { public: @@ -67,13 +71,17 @@ public: GameFlags *_gameFlags; GameInfo *_gameInfo; Mouse *_mouse; + View *_view; Scene *_scene; + SceneObjects *_sceneObjects; Script *_script; Settings *_settings; SliceAnimations *_sliceAnimations; SliceRenderer *_sliceRenderer; int *_gameVars; + Lights *_lights; + TextResource *_textActorNames; TextResource *_textCrimes; TextResource *_textCluetype; diff --git a/engines/bladerunner/boundingbox.cpp b/engines/bladerunner/boundingbox.cpp index 10e529b1e3..fb2ae94813 100644 --- a/engines/bladerunner/boundingbox.cpp +++ b/engines/bladerunner/boundingbox.cpp @@ -34,4 +34,23 @@ BoundingBox::BoundingBox(float x0, float y0, float z0, float x1, float y1, float _vertices[1].z = z1; } +void BoundingBox::expand(float x0, float y0, float z0, float x1, float y1, float z1) +{ + _vertices[0].x += x0; + _vertices[0].y += y0; + _vertices[0].z += z0; + + _vertices[1].x += x1; + _vertices[1].y += y1; + _vertices[1].z += z1; +} + + +bool BoundingBox::isXYZInside(float x, float y, float z) +{ + return + x >= _vertices[0].x && x <= _vertices[1].x + && y >= _vertices[0].y && y <= _vertices[1].y + && z >= _vertices[0].z && z <= _vertices[1].z; +} } // End of namespace BladeRunner diff --git a/engines/bladerunner/boundingbox.h b/engines/bladerunner/boundingbox.h index 5dda3f0e3f..1766973f26 100644 --- a/engines/bladerunner/boundingbox.h +++ b/engines/bladerunner/boundingbox.h @@ -28,11 +28,15 @@ namespace BladeRunner { class BoundingBox { +public: Vector3 _vertices[2]; public: BoundingBox() {} BoundingBox(float x0, float y0, float z0, float x1, float y1, float z1); + + void expand(float x0, float y0, float z0, float x1, float y1, float z1); + bool isXYZInside(float x, float y, float z); }; } // End of namespace BladeRunner diff --git a/engines/bladerunner/color.h b/engines/bladerunner/color.h new file mode 100644 index 0000000000..54983b401b --- /dev/null +++ b/engines/bladerunner/color.h @@ -0,0 +1,37 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_COLOR_H +#define BLADERUNNER_COLOR_H + +namespace BladeRunner { + + struct Color + { + float r; + float g; + float b; + }; +} + + +#endif diff --git a/engines/bladerunner/fog.cpp b/engines/bladerunner/fog.cpp new file mode 100644 index 0000000000..5951ba8d1c --- /dev/null +++ b/engines/bladerunner/fog.cpp @@ -0,0 +1,94 @@ +#include "bladerunner/fog.h" + +namespace BladeRunner +{ + Fog::Fog() + { + } + + Fog::~Fog() + { + } + + int Fog::readCommon(Common::ReadStream* stream) + { + int offset = stream->readUint32LE(); + stream->read(_name, 20); + _fogColor.r = stream->readFloatLE(); + _fogColor.g = stream->readFloatLE(); + _fogColor.b = stream->readFloatLE(); + _fogDensity = stream->readFloatLE(); + return offset; + } + + + void Fog::readAnimationData(Common::ReadStream* stream, int size) + { + _animatedParameters = stream->readUint32LE(); + _animationData = new float[size / sizeof(float)]; + stream->read(_animationData, size); + + _m11ptr = _animationData; + _m12ptr = _m11ptr + (_animatedParameters & 0x1 ? _framesCount : 1); + _m13ptr = _m12ptr + (_animatedParameters & 0x2 ? _framesCount : 1); + _m14ptr = _m13ptr + (_animatedParameters & 0x4 ? _framesCount : 1); + _m21ptr = _m14ptr + (_animatedParameters & 0x08 ? _framesCount : 1); + _m22ptr = _m21ptr + (_animatedParameters & 0x10 ? _framesCount : 1); + _m23ptr = _m22ptr + (_animatedParameters & 0x20 ? _framesCount : 1); + _m24ptr = _m23ptr + (_animatedParameters & 0x40 ? _framesCount : 1); + _m31ptr = _m24ptr + (_animatedParameters & 0x80 ? _framesCount : 1); + _m32ptr = _m31ptr + (_animatedParameters & 0x100 ? _framesCount : 1); + _m33ptr = _m32ptr + (_animatedParameters & 0x200 ? _framesCount : 1); + _m34ptr = _m33ptr + (_animatedParameters & 0x400 ? _framesCount : 1); + + setupFrame(0); + } + + void Fog::reset() + { + } + + void Fog::setupFrame(int frame) + { + int offset = frame % _framesCount; + _matrix._m[0][0] = (_animatedParameters & 0x1 ? _m11ptr[offset] : *_m11ptr); + _matrix._m[0][1] = (_animatedParameters & 0x2 ? _m12ptr[offset] : *_m12ptr); + _matrix._m[0][2] = (_animatedParameters & 0x4 ? _m13ptr[offset] : *_m13ptr); + _matrix._m[0][3] = (_animatedParameters & 0x8 ? _m14ptr[offset] : *_m14ptr); + _matrix._m[1][0] = (_animatedParameters & 0x10 ? _m21ptr[offset] : *_m21ptr); + _matrix._m[1][1] = (_animatedParameters & 0x20 ? _m22ptr[offset] : *_m22ptr); + _matrix._m[1][2] = (_animatedParameters & 0x40 ? _m23ptr[offset] : *_m23ptr); + _matrix._m[1][3] = (_animatedParameters & 0x80 ? _m24ptr[offset] : *_m24ptr); + _matrix._m[2][0] = (_animatedParameters & 0x100 ? _m31ptr[offset] : *_m31ptr); + _matrix._m[2][1] = (_animatedParameters & 0x200 ? _m32ptr[offset] : *_m32ptr); + _matrix._m[2][2] = (_animatedParameters & 0x400 ? _m33ptr[offset] : *_m33ptr); + _matrix._m[2][3] = (_animatedParameters & 0x800 ? _m34ptr[offset] : *_m34ptr); + _inverted = invertMatrix(_matrix); + } + + void FogCone::read(Common::ReadStream* stream, int framesCount) + { + _framesCount = framesCount; + int size = readCommon(stream); + _parameter1 = stream->readFloatLE(); + readAnimationData(stream, size - 52); + } + + void FogSphere::read(Common::ReadStream* stream, int framesCount) + { + _framesCount = framesCount; + int size = readCommon(stream); + _parameter1 = stream->readFloatLE(); + readAnimationData(stream, size - 52); + } + + void FogBox::read(Common::ReadStream* stream, int framesCount) + { + _framesCount = framesCount; + int size = readCommon(stream); + _parameter1 = stream->readFloatLE(); + _parameter2 = stream->readFloatLE(); + _parameter3 = stream->readFloatLE(); + readAnimationData(stream, size - 60); + } +}
\ No newline at end of file diff --git a/engines/bladerunner/fog.h b/engines/bladerunner/fog.h new file mode 100644 index 0000000000..627e8f15bd --- /dev/null +++ b/engines/bladerunner/fog.h @@ -0,0 +1,104 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_FOG_H +#define BLADERUNNER_FOG_H + +#include "bladerunner/bladerunner.h" +#include "bladerunner/color.h" +#include "bladerunner/matrix.h" + +#include "common/stream.h" + + +namespace BladeRunner { + + class SetEffects; + + class Fog + { + friend class SetEffects; + + protected: + char _name[20]; + int _framesCount; + int _animatedParameters; + Matrix4x3 _matrix; + Matrix4x3 _inverted; + Color _fogColor; + float _fogDensity; + float *_animationData; + float *_m11ptr; + float *_m12ptr; + float *_m13ptr; + float *_m14ptr; + float *_m21ptr; + float *_m22ptr; + float *_m23ptr; + float *_m24ptr; + float *_m31ptr; + float *_m32ptr; + float *_m33ptr; + float *_m34ptr; + + float _parameter1; + float _parameter2; + float _parameter3; + + Fog *_next; + + public: + Fog(); + ~Fog(); + + virtual void read(Common::ReadStream *stream, int framesCount) = 0; + + void reset(); + + void setupFrame(int frame); + + private: + protected: + int readCommon(Common::ReadStream *stream); + void readAnimationData(Common::ReadStream *stream, int count); + + }; + + class FogCone : public Fog + { + void read(Common::ReadStream *stream, int framesCount); + }; + + class FogSphere : public Fog + { + void read(Common::ReadStream *stream, int framesCount); + }; + + class FogBox : public Fog + { + void read(Common::ReadStream *stream, int framesCount); + }; + + + +} +#endif diff --git a/engines/bladerunner/light.cpp b/engines/bladerunner/light.cpp new file mode 100644 index 0000000000..6bc97f8392 --- /dev/null +++ b/engines/bladerunner/light.cpp @@ -0,0 +1,84 @@ +#include "bladerunner/light.h" + +namespace BladeRunner +{ + Light::Light() + { + } + + Light::~Light() + { + } + + void Light::read(Common::ReadStream* stream, int framesCount, int frame, int animated) + { + _framesCount = framesCount; + _animated = animated; + + int size = stream->readUint32LE(); + size = size - 32; + + stream->read(_name, 20); + + _animatedParameters = stream->readUint32LE(); + + _animationData = new float[size / sizeof(float)]; + stream->read(_animationData, size); + + _m11ptr = _animationData; + _m12ptr = _m11ptr + (_animatedParameters & 0x1 ? framesCount : 1); + _m13ptr = _m12ptr + (_animatedParameters & 0x2 ? framesCount : 1); + _m14ptr = _m13ptr + (_animatedParameters & 0x4 ? framesCount : 1); + _m21ptr = _m14ptr + (_animatedParameters & 0x8 ? framesCount : 1); + _m22ptr = _m21ptr + (_animatedParameters & 0x10 ? framesCount : 1); + _m23ptr = _m22ptr + (_animatedParameters & 0x20 ? framesCount : 1); + _m24ptr = _m23ptr + (_animatedParameters & 0x40 ? framesCount : 1); + _m31ptr = _m24ptr + (_animatedParameters & 0x80 ? framesCount : 1); + _m32ptr = _m31ptr + (_animatedParameters & 0x100 ? framesCount : 1); + _m33ptr = _m32ptr + (_animatedParameters & 0x200 ? framesCount : 1); + _m34ptr = _m33ptr + (_animatedParameters & 0x400 ? framesCount : 1); + _colorRPtr = _m34ptr + (_animatedParameters & 0x800 ? framesCount : 1); + _colorGPtr = _colorRPtr + (_animatedParameters & 0x1000 ? framesCount : 1); + _colorBPtr = _colorGPtr + (_animatedParameters & 0x2000 ? framesCount : 1); + _field16ptr = _colorGPtr + (_animatedParameters & 0x4000 ? framesCount : 1); + _field17ptr = _field16ptr + (_animatedParameters & 0x8000 ? framesCount : 1); + _field18ptr = _field17ptr + (_animatedParameters & 0x10000 ? framesCount : 1); + _field19ptr = _field18ptr + (_animatedParameters & 0x20000 ? framesCount : 1); + + setupFrame(frame); + } + + void Light::readVqa(Common::ReadStream* stream) + { + } + + void Light::setupFrame(int frame) + { + int offset = frame % _framesCount; + _matrix._m[0][0] = (_animatedParameters & 0x1 ? _m11ptr[offset] : *_m11ptr); + _matrix._m[0][1] = (_animatedParameters & 0x2 ? _m12ptr[offset] : *_m12ptr); + _matrix._m[0][2] = (_animatedParameters & 0x4 ? _m13ptr[offset] : *_m13ptr); + _matrix._m[0][3] = (_animatedParameters & 0x8 ? _m14ptr[offset] : *_m14ptr); + _matrix._m[1][0] = (_animatedParameters & 0x10 ? _m21ptr[offset] : *_m21ptr); + _matrix._m[1][1] = (_animatedParameters & 0x20 ? _m22ptr[offset] : *_m22ptr); + _matrix._m[1][2] = (_animatedParameters & 0x40 ? _m23ptr[offset] : *_m23ptr); + _matrix._m[1][3] = (_animatedParameters & 0x80 ? _m24ptr[offset] : *_m24ptr); + _matrix._m[2][0] = (_animatedParameters & 0x100 ? _m31ptr[offset] : *_m31ptr); + _matrix._m[2][1] = (_animatedParameters & 0x200 ? _m32ptr[offset] : *_m32ptr); + _matrix._m[2][2] = (_animatedParameters & 0x400 ? _m33ptr[offset] : *_m33ptr); + _matrix._m[2][3] = (_animatedParameters & 0x800 ? _m34ptr[offset] : *_m34ptr); + _color.r = (_animatedParameters & 0x1000 ? _colorRPtr[offset] : *_colorRPtr); + _color.g = (_animatedParameters & 0x2000 ? _colorGPtr[offset] : *_colorGPtr); + _color.b = (_animatedParameters & 0x4000 ? _colorBPtr[offset] : *_colorBPtr); + _field16 = (_animatedParameters & 0x8000 ? _field16ptr[offset] : *_field16ptr); + _field17 = (_animatedParameters & 0x10000 ? _field17ptr[offset] : *_field17ptr); + _field18 = (_animatedParameters & 0x20000 ? _field18ptr[offset] : *_field18ptr); + _field19 = (_animatedParameters & 0x40000 ? _field19ptr[offset] : *_field19ptr); + + } + + float Light::attenuation(float min, float max, float distance) + { + return 0.0; + } +}
\ No newline at end of file diff --git a/engines/bladerunner/light.h b/engines/bladerunner/light.h new file mode 100644 index 0000000000..f4c142e4ab --- /dev/null +++ b/engines/bladerunner/light.h @@ -0,0 +1,104 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_LIGHT_H +#define BLADERUNNER_LIGHT_H + +#include "bladerunner/matrix.h" +#include "bladerunner/color.h" + +#include "common/stream.h" + +namespace Common{ + class ReadStream; +} + +namespace BladeRunner { + class Lights; + + class Light + { + friend class Lights; + private: + char _name[20]; + int _framesCount; + int _animated; + int _animatedParameters; + Matrix4x3 _matrix; + Color _color; + float _field16; + float _field17; + float _field18; + float _field19; + float *_animationData; + float *_m11ptr; + float *_m12ptr; + float *_m13ptr; + float *_m14ptr; + float *_m21ptr; + float *_m22ptr; + float *_m23ptr; + float *_m24ptr; + float *_m31ptr; + float *_m32ptr; + float *_m33ptr; + float *_m34ptr; + float *_colorRPtr; + float *_colorGPtr; + float *_colorBPtr; + float *_field16ptr; + float *_field17ptr; + float *_field18ptr; + float *_field19ptr; + Light *_next; + public: + Light(); + ~Light(); + void read(Common::ReadStream *stream, int framesCount, int frame, int animated); + void readVqa(Common::ReadStream *stream); + + void setupFrame(int frame); + private: + static float attenuation(float min, float max, float distance); + }; + + class Light1 : public Light { + + }; + + class Light2 : public Light { + + }; + + class Light3 : public Light { + + }; + + class Light4 : public Light { + + }; + + class Light5 : public Light { + + }; +} +#endif diff --git a/engines/bladerunner/lights.cpp b/engines/bladerunner/lights.cpp new file mode 100644 index 0000000000..33ee3d1181 --- /dev/null +++ b/engines/bladerunner/lights.cpp @@ -0,0 +1,100 @@ +#include "bladerunner/lights.h" + +namespace BladeRunner { + Lights::Lights(BladeRunnerEngine *vm) + { + _vm = vm; + + _ambientLightColor.r = 1.0; + _ambientLightColor.g = 0.0; + _ambientLightColor.b = 0.0; + + _lights = NULL; + _frame = 0; + } + + Lights::~Lights() + { + reset(); + } + + void Lights::read(Common::ReadStream* stream, int framesCount) + { + _ambientLightColor.r = stream->readFloatLE(); + _ambientLightColor.g = stream->readFloatLE(); + _ambientLightColor.b = stream->readFloatLE(); + + _lightsCount = stream->readUint32LE(); + int i; + for (i = 0; i < _lightsCount; i++) + { + Light *light; + int type = stream->readUint32LE(); + switch (type) + { + case 1: + light = new Light1(); + break; + case 2: + light = new Light2(); + break; + case 3: + light = new Light3(); + break; + case 4: + light = new Light4(); + break; + case 5: + light = new Light5(); + break; + default: + light = new Light(); + } + + light->read(stream, framesCount, _frame, 0); + light->_next = _lights; + _lights = light; + } + } + + void Lights::readVqa(Common::ReadStream* stream) + { + reset(); + //int framesCount = stream->readUint32LE(); + //int count = stream->readUint32LE(); + + } + + void Lights::setupFrame(int frame) + { + Light *light; + + if (frame == _frame) + return; + + if (!_lights) + return; + + for (light = _lights; light; light = light->_next) + { + light->setupFrame(frame); + } + } + + void Lights::reset() + { + Light *light; + Light *nextLight; + + if (!_lights) + return; + + do + { + light = _lights; + nextLight = light->_next; + delete light; + _lights = nextLight; + } while (nextLight); + } +}
\ No newline at end of file diff --git a/engines/bladerunner/lights.h b/engines/bladerunner/lights.h new file mode 100644 index 0000000000..d6ff7f5261 --- /dev/null +++ b/engines/bladerunner/lights.h @@ -0,0 +1,64 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_LIGHTS_H +#define BLADERUNNER_LIGHTS_H + +#include "bladerunner/bladerunner.h" +#include "bladerunner/color.h" +#include "bladerunner/light.h" + +#include "common/stream.h" + + +namespace BladeRunner { + + class Lights + { + BladeRunnerEngine *_vm; + + private: + Color _ambientLightColor; + + int _lightsCount; + Light *_lights; + + int _frame; + //char gap[28]; + + public: + Lights(BladeRunnerEngine *vm); + ~Lights(); + + void read(Common::ReadStream *stream, int framesCount); + void readVqa(Common::ReadStream *stream); + + void reset(); + + void setupFrame(int frame); + + private: + + }; + +} +#endif diff --git a/engines/bladerunner/movement_track.cpp b/engines/bladerunner/movement_track.cpp new file mode 100644 index 0000000000..fff4508dec --- /dev/null +++ b/engines/bladerunner/movement_track.cpp @@ -0,0 +1,124 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#include "bladerunner/movement_track.h" + +namespace BladeRunner { + MovementTrack::MovementTrack() + { + reset(); + } + + MovementTrack::~MovementTrack() + { + reset(); + } + + void MovementTrack::reset() + { + _currentIndex = -1; + _lastIndex = -1; + _hasNext = 0; + _paused = 0; + for (int i = 0; i < sizeof(this->_entries); i++) + { + _entries[i].waypointId = -1; + _entries[i].delay = -1; + _entries[i].angle = -1; + _entries[i].running = 0; + } + } + + int MovementTrack::append(int waypointId, int delay, int running) + { + return append(waypointId, delay, -1, running); + } + + int MovementTrack::append(int waypointId, int delay, int angle, int running) + { + if (_lastIndex > sizeof(_entries)) + return 0; + _entries[_lastIndex].waypointId = waypointId; + _entries[_lastIndex].delay = delay; + _entries[_lastIndex].angle = angle; + _entries[_lastIndex].running = running; + + _lastIndex++; + _hasNext = 1; + _currentIndex = 0; + return 1; + } + + void MovementTrack::flush() + { + reset(); + } + + void MovementTrack::repeat() + { + _currentIndex = 0; + _hasNext = 1; + } + + int MovementTrack::pause() + { + _paused = 1; + return 1; + } + + int MovementTrack::unpause() + { + _paused = 0; + return 1; + } + + int MovementTrack::isPaused() + { + return _paused; + } + + int MovementTrack::hasNext() + { + return _hasNext; + } + + int MovementTrack::next(int *waypointId, int *delay, int *angle, int *running) + { + if (_currentIndex < _lastIndex && this->_hasNext) + { + *waypointId = _entries[_currentIndex].waypointId; + *delay = _entries[_currentIndex].delay; + *angle = _entries[_currentIndex].angle; + *running = _entries[_currentIndex++].running; + return 1; + } + else + { + *waypointId = -1; + *delay = -1; + *angle = -1; + *running = 0; + _hasNext = 0; + return 0; + } + } +}
\ No newline at end of file diff --git a/engines/bladerunner/movement_track.h b/engines/bladerunner/movement_track.h new file mode 100644 index 0000000000..491de8051a --- /dev/null +++ b/engines/bladerunner/movement_track.h @@ -0,0 +1,70 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_MOVEMENT_TRACK_H +#define BLADERUNNER_MOVEMENT_TRACK_H + +#include "bladerunner/bladerunner.h" + + +namespace BladeRunner { + + class BladeRunnerEngine; + class BoundingBox; + + struct MovementTrackEntry + { + int waypointId; + int delay; + int angle; + int running; + }; + + class MovementTrack { + BladeRunnerEngine *_vm; + + private: + int _currentIndex; + int _lastIndex; + int _hasNext; + int _paused; + MovementTrackEntry _entries[100]; + void reset(); + + public: + MovementTrack(); + ~MovementTrack(); + int append(int waypointId, int delay, int running); + int append(int waypointId, int delay, int angle, int running); + void flush(); + void repeat(); + int pause(); + int unpause(); + int isPaused(); + int hasNext(); + int next(int *waypointId, int *delay, int *angle, int *running); + + //int saveGame(); + }; +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/outtake.cpp b/engines/bladerunner/outtake.cpp index b81b212f52..3ffc964d03 100644 --- a/engines/bladerunner/outtake.cpp +++ b/engines/bladerunner/outtake.cpp @@ -43,7 +43,7 @@ void OuttakePlayer::play(const Common::String &name, bool noLocalization, int co else resName = name + "_E.VQA"; - VQAPlayer vqa_player(_vm); + VQAPlayer vqa_player(_vm, _vm->_view); vqa_player.open(resName); diff --git a/engines/bladerunner/scene.cpp b/engines/bladerunner/scene.cpp index 925c86afba..fc0aa8c20d 100644 --- a/engines/bladerunner/scene.cpp +++ b/engines/bladerunner/scene.cpp @@ -28,6 +28,8 @@ #include "bladerunner/chapters.h" #include "bladerunner/gameinfo.h" #include "bladerunner/script/script.h" +#include "bladerunner/slice_renderer.h" +#include "bladerunner/scene_objects.h" #include "common/str.h" #include "common/stream.h" @@ -38,7 +40,7 @@ bool Scene::open(int setId, int sceneId, bool isLoadingGame) { if (!isLoadingGame) { // flush ADQ } - + // reset mouse button status _setId = setId; _sceneId = sceneId; @@ -48,9 +50,11 @@ bool Scene::open(int setId, int sceneId, bool isLoadingGame) { // TODO: Set up overlays } else { // TODO: Clear regions + // reset aesc // TODO: Destroy all overlays _defaultLoop = 0; _frame = -1; + //_loopStartSpecial = -1; } Common::String vqaName; @@ -75,34 +79,50 @@ bool Scene::open(int setId, int sceneId, bool isLoadingGame) { if (!_set->open(setResourceName)) return false; - // TODO: Set view + _vm->_sliceRenderer->setView(_vm->_view); + if (isLoadingGame) { - if (sceneId >= 73 && sceneId <= 76) - _vm->_script->InitializeScene(); - return true; + // resume() + if (sceneId >= 73 && sceneId <= 76) { + _vm->_script->SceneLoaded(); + return true; + } } // TODO: set VQADecoder parameters // TODO: Set actor position from scene info + //advance frame 0 _vm->_playerActor->set_at_xyz(_actorStartPosition, _actorStartFacing); - // TODO: Set actor set - _vm->_script->SceneLoaded(); -#if 0 + _vm->_sceneObjects->reset(); + // Init click map int actorCount = _vm->_gameInfo->getActorCount(); for (int i = 0; i != actorCount; ++i) { Actor *actor = _vm->_actors[i]; if (actor->getSet() == setId) { - + _vm->_sceneObjects->addActor( + i, + actor->getBoundingBox(), + actor->getScreenRectangle(), + 1, + 0, + actor->isTargetable(), + actor->isRetired()); } } - // TODO: Update click map for set, items -#endif - + + _set->addAllObjectsToScene(_vm->_sceneObjects); + //add all items to scene + //calculate walking obstacles?? + + if (_playerWalkedIn) { + //_vm->_script->PlayerWalkedIn(); + } + return true; } @@ -111,7 +131,6 @@ int Scene::advanceFrame(Graphics::Surface &surface, uint16 *&zBuffer) { if (frame >= 0) { surface.copyFrom(*_vqaPlayer.getSurface()); memcpy(zBuffer, _vqaPlayer.getZBuffer(), 640*480*2); - _view = _vqaPlayer.getView(); } return frame; } diff --git a/engines/bladerunner/scene.h b/engines/bladerunner/scene.h index f0721b39e3..ee286cabb4 100644 --- a/engines/bladerunner/scene.h +++ b/engines/bladerunner/scene.h @@ -26,7 +26,7 @@ #include "bladerunner/bladerunner.h" #include "bladerunner/set.h" -#include "bladerunner/view.h" +//#include "bladerunner/view.h" #include "bladerunner/vqa_player.h" namespace BladeRunner { @@ -48,7 +48,6 @@ public: Vector3 _actorStartPosition; int _actorStartFacing; bool _playerWalkedIn; - View _view; public: Scene(BladeRunnerEngine *vm) @@ -56,7 +55,7 @@ public: _set(new Set(vm)), _setId(-1), _sceneId(-1), - _vqaPlayer(vm), + _vqaPlayer(vm, vm->_view), _defaultLoop(0), _nextSetId(-1), _nextSceneId(-1), diff --git a/engines/bladerunner/scene_objects.cpp b/engines/bladerunner/scene_objects.cpp new file mode 100644 index 0000000000..f54a9b7120 --- /dev/null +++ b/engines/bladerunner/scene_objects.cpp @@ -0,0 +1,188 @@ +#include "bladerunner/scene_objects.h" + +namespace BladeRunner { + + SceneObjects::SceneObjects(BladeRunnerEngine *vm, View *view) { + _vm = vm; + _view = view; + + _count = 0; + _sceneObjects = new SceneObject[SCENE_OBJECTS_COUNT]; + _sceneObjectsSortedByDistance = new int[SCENE_OBJECTS_COUNT]; + + int i; + for (i = 0; i < SCENE_OBJECTS_COUNT; i++) { + _sceneObjectsSortedByDistance[i] = -1; + } + } + + SceneObjects::~SceneObjects() { + _vm = nullptr; + _view = nullptr; + _count = 0; + + delete[] _sceneObjectsSortedByDistance; + delete[] _sceneObjects; + } + + + void SceneObjects::reset() { + int i; + for (i = 0; i < SCENE_OBJECTS_COUNT; i++) { + _sceneObjects[i]._present = 0; + } + } + + bool SceneObjects::addActor(int sceneObjectId, BoundingBox* boundingBox, Common::Rect* screenRectangle, uint8 isClickable, uint8 unknown1, uint8 isCombatTarget, uint8 isRetired) { + return addSceneObject(sceneObjectId, SceneObjectTypeActor, boundingBox, screenRectangle, isClickable, 0, 0, isCombatTarget, unknown1, isRetired); + } + + bool SceneObjects::addObject(int sceneObjectId, BoundingBox* boundingBox, uint8 isClickable, uint8 isObstacle, uint8 unknown1, uint8 isCombatTarget) { + Common::Rect rect(-1, -1, -1, -1); + return addSceneObject(sceneObjectId, SceneObjectTypeObject, boundingBox, &rect, isClickable, isObstacle, unknown1, isCombatTarget, 0, 0); + } + + bool SceneObjects::addItem(int sceneObjectId, BoundingBox* boundingBox, Common::Rect* screenRectangle, uint8 isCombatTarget, uint8 isObstacle) { + return addSceneObject(sceneObjectId, SceneObjectTypeItem, boundingBox, screenRectangle, isObstacle, 0, 0, isCombatTarget, 0, 0); + } + + + bool SceneObjects::remove(int sceneObjectId) + { + int i = findById(sceneObjectId); + if (i == -1 || !_sceneObjects[i]._present) { + return false; + } + int j; + for (j = 0; j < _count; j++) { + if (_sceneObjectsSortedByDistance[j] == i) { + break; + } + } + int k; + for (k = j; k < _count - 1; k++) { + _sceneObjectsSortedByDistance[k] = _sceneObjectsSortedByDistance[k + 1]; + } + + --_count; + return true; + } + + int SceneObjects::findByXYZ(int *isClickable, int *isObstacle, int *isCombatTarget, float x, float y, float z, int firstClickable, int firstObstacle, int firstCombatTarget) { + BoundingBox boundingBox; + *isClickable = 0; + *isObstacle = 0; + *isCombatTarget = 0; + + if (!_count) + return -1; + + int i; + for (i = 0; i < _count; i++) { + //assert(_sceneObjectsSortedByDistance[i] < _count); + SceneObject *sceneObject = &_sceneObjects[_sceneObjectsSortedByDistance[i]]; + if ((firstClickable && sceneObject->_isClickable) + || (firstObstacle && sceneObject->_isObstacle) + || (firstCombatTarget && sceneObject->_isCombatTarget)) { + break; + } + + boundingBox = sceneObject->_boundingBox; + + if (sceneObject->_sceneObjectType == SceneObjectTypeObject || sceneObject->_sceneObjectType == SceneObjectTypeItem) { + boundingBox.expand(-4.0, 0.0, -4.0, 4.0, 0.0, 4.0); + } + + if (boundingBox.isXYZInside(x, y, z)) { + *isClickable = sceneObject->_isClickable; + *isObstacle = sceneObject->_isObstacle; + *isCombatTarget = sceneObject->_isCombatTarget; + return sceneObject->_sceneObjectId; + } + } + + return -1; + } + + int SceneObjects::findById(int sceneObjectId) + { + int i; + for (i = 0; i < _count; i++) { + if (_sceneObjects[i]._present && _sceneObjects[i]._sceneObjectId == sceneObjectId) { + return i; + } + } + return -1; + } + + bool SceneObjects::addSceneObject(int sceneObjectId, SceneObjectType sceneObjectType, BoundingBox* boundingBox, Common::Rect* screenRectangle, uint8 isClickable, uint8 isObstacle, uint8 unknown1, uint8 isCombatTarget, uint unknown2, uint isRetired) { + int index = findEmpty(); + if (_count >= SCENE_OBJECTS_COUNT || index == -1) { + return false; + } + + _sceneObjects[index]._sceneObjectId = sceneObjectId; + _sceneObjects[index]._sceneObjectType = sceneObjectType; + _sceneObjects[index]._present = 1; + _sceneObjects[index]._boundingBox = *boundingBox; + _sceneObjects[index]._screenRectangle = *screenRectangle; + _sceneObjects[index]._isClickable = isClickable; + _sceneObjects[index]._isObstacle = isObstacle; + _sceneObjects[index]._unknown1 = unknown1; + _sceneObjects[index]._isCombatTarget = isCombatTarget; + _sceneObjects[index]._unknown2 = unknown2; + _sceneObjects[index]._isRetired = isRetired; + + float centerZ = (_sceneObjects[index]._boundingBox._vertices[0].z + _sceneObjects[index]._boundingBox._vertices[1].z) / 2.0; + + float distanceToCamera = fabs(_view->_cameraPosition.z - centerZ); + _sceneObjects[index]._distanceToCamera = distanceToCamera; + + // insert according to distance from camera + int i, j; + for (i = 0; i < _count; i++) { + if (distanceToCamera < _sceneObjects[_sceneObjectsSortedByDistance[i]]._distanceToCamera) { + break; + } + } + + for (j = _count - 1; j >= i; j--) { + _sceneObjectsSortedByDistance[j + 1] = _sceneObjectsSortedByDistance[j]; + } + + _sceneObjectsSortedByDistance[i] = index; + ++_count; + return true; + } + + int SceneObjects::findEmpty() + { + int i; + for (i = 0; i < SCENE_OBJECTS_COUNT; i++) + { + if (!_sceneObjects[i]._present) + return i; + } + return -1; + } + + + + SceneObject::SceneObject() + { + _sceneObjectId = -1; + _sceneObjectType = SceneObjectTypeUnknown; + _distanceToCamera = 0; + _present = 0; + _isClickable = 0; + _isObstacle = 0; + _unknown1 = 0; + _isCombatTarget = 0; + _unknown2 = 0; + _isRetired = 0; + } + + SceneObject::~SceneObject() + { + } +} diff --git a/engines/bladerunner/scene_objects.h b/engines/bladerunner/scene_objects.h new file mode 100644 index 0000000000..999d82179f --- /dev/null +++ b/engines/bladerunner/scene_objects.h @@ -0,0 +1,96 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_SCENE_OBJECTS_H +#define BLADERUNNER_SCENE_OBJECTS_H + +#include "bladerunner/bladerunner.h" + +#include "bladerunner/boundingbox.h" +#include "bladerunner/view.h" + +#include "common/rect.h" + +namespace BladeRunner { + class BladeRunnerEngine; + class SceneObject; + + enum SceneObjectType + { + SceneObjectTypeUnknown = -1, + SceneObjectTypeActor = 0, + SceneObjectTypeObject = 1, + SceneObjectTypeItem = 2, + }; + +#define SCENE_OBJECTS_COUNT 115 +#define SCENE_OBJECTS_ACTORS_OFFSET 0 +#define SCENE_OBJECTS_ITEMS_OFFSET 74 +#define SCENE_OBJECTS_OBJECTS_OFFSET 198 + + + + class SceneObjects { + BladeRunnerEngine *_vm; + private: + View *_view; + int _count; + SceneObject *_sceneObjects; + int *_sceneObjectsSortedByDistance; + + public: + SceneObjects(BladeRunnerEngine *vm, View *view); + ~SceneObjects(); + void reset(); + bool addActor(int sceneObjectId, BoundingBox* boundingBox, Common::Rect* screenRectangle, uint8 isClickable, uint8 unknown1, uint8 isCombatTarget, uint8 isRetired); + bool addObject(int sceneObjectId, BoundingBox* boundingBox, uint8 isClickable, uint8 isObstacle, uint8 unknown1, uint8 isCombatTarget); + bool addItem(int sceneObjectId, BoundingBox* boundingBox, Common::Rect* screenRectangle, uint8 isCombatTarget, uint8 isObstacle); + bool remove(int sceneObjectId); + int findByXYZ(int* clickable, int* obstacle, int* targetable, float x, float y, float z, int firstClickable, int firstObstacle, int firstTargetable); + private: + int findById(int sceneObjectId); + bool addSceneObject(int sceneObjectId, SceneObjectType sceneObjectType, BoundingBox* boundingBox, Common::Rect* screenRectangle, uint8 isClickable, uint8 isObstacle, uint8 unknown1, uint8 isCombatTarget, uint unknown2, uint isRetired); + int findEmpty(); + }; + + class SceneObject + { + friend class SceneObjects; + private: + int _sceneObjectId; + SceneObjectType _sceneObjectType; + BoundingBox _boundingBox; + Common::Rect _screenRectangle; + float _distanceToCamera; + int _present; + int _isClickable; + int _isObstacle; + int _unknown1; + int _isCombatTarget; + int _unknown2; + int _isRetired; + public: + SceneObject(); + ~SceneObject(); + }; +} +#endif diff --git a/engines/bladerunner/set.cpp b/engines/bladerunner/set.cpp index c37b31a80e..a2e54107d2 100644 --- a/engines/bladerunner/set.cpp +++ b/engines/bladerunner/set.cpp @@ -23,12 +23,14 @@ #include "bladerunner/set.h" #include "bladerunner/bladerunner.h" +#include "bladerunner/slice_renderer.h" #include "common/debug.h" #include "common/ptr.h" #include "common/str.h" #include "common/stream.h" + namespace BladeRunner { #define kSet0 0x53657430 @@ -38,9 +40,12 @@ Set::Set(BladeRunnerEngine *vm) : _vm(vm) { _walkboxCount = 0; _objects = new Object[85]; _walkboxes = new Walkbox[95]; + _footstepSoundOverride = -1; + _effects = new SetEffects(vm); } Set::~Set() { + delete _effects; delete[] _objects; delete[] _walkboxes; } @@ -52,7 +57,7 @@ bool Set::open(const Common::String &name) { if (sig != kSet0) return false; - s->skip(4); // TODO: LITE length + int framesCount = s->readUint32LE(); _objectCount = s->readUint32LE(); assert(_objectCount <= 85); @@ -101,9 +106,24 @@ bool Set::open(const Common::String &name) { // debug("WALKBOX: %s", _walkboxes[i]._name); } - // TODO: Read LITE + _vm->_lights->reset(); + _vm->_lights->read(s.get(), framesCount); + _vm->_sliceRenderer->setLights(_vm->_lights); + _effects->reset(); + _effects->read(s.get(), framesCount); + _vm->_sliceRenderer->setSetEffects(_effects); return true; } + +void Set::addAllObjectsToScene(SceneObjects* sceneObjects) +{ + uint32 i; + for (i = 0; i < _objectCount; i++) + { + sceneObjects->addObject(i + SCENE_OBJECTS_OBJECTS_OFFSET, &_objects[i]._bbox, _objects[i]._isClickable, _objects[i]._isObstacle, _objects[i]._unknown1, _objects[i]._isCombatTarget); + } +} + } // End of namespace BladeRunner diff --git a/engines/bladerunner/set.h b/engines/bladerunner/set.h index e7358fdb2a..fba2d2a3ab 100644 --- a/engines/bladerunner/set.h +++ b/engines/bladerunner/set.h @@ -24,6 +24,10 @@ #define BLADERUNNER_SET_H #include "bladerunner/boundingbox.h" +#include "bladerunner/set_effects.h" +#include "bladerunner/lights.h" +#include "bladerunner/scene_objects.h" + #include "common/scummsys.h" #include "common/str.h" @@ -41,6 +45,7 @@ struct Object { uint8 _isClickable; uint8 _isHotMouse; uint8 _isCombatTarget; + uint8 _unknown1; }; struct Walkbox { @@ -53,19 +58,24 @@ struct Walkbox { class Set { BladeRunnerEngine *_vm; - uint32 _objectCount; - uint32 _walkboxCount; - Object *_objects; - Walkbox *_walkboxes; - int _walkboxStepSound[85]; - int _footstepSoundOverride; - float _unknown[10]; + uint32 _objectCount; + uint32 _walkboxCount; + Object *_objects; + Walkbox *_walkboxes; + int _walkboxStepSound[85]; + int _footstepSoundOverride; + SetEffects *_effects; +public: + public: Set(BladeRunnerEngine *vm); ~Set(); bool open(const Common::String &name); + void addAllObjectsToScene(SceneObjects *sceneObjects); + + }; } // End of namespace BladeRunner diff --git a/engines/bladerunner/set_effects.cpp b/engines/bladerunner/set_effects.cpp new file mode 100644 index 0000000000..f524820033 --- /dev/null +++ b/engines/bladerunner/set_effects.cpp @@ -0,0 +1,83 @@ +#include "bladerunner/set_effects.h" + +namespace BladeRunner +{ + SetEffects::SetEffects(BladeRunnerEngine* vm) + { + _vm = vm; + + _distanceColor.r = 1.0f; + _distanceColor.g = 1.0f; + _distanceColor.b = 1.0f; + _distanceCoeficient = 0.1f; + + _fadeColor.r = 0.0f; + _fadeColor.g = 0.0f; + _fadeColor.b = 0.0f; + _fadeDensity = 0.0f; + + _fogsCount = 0; + _fogs = NULL; + } + + SetEffects::~SetEffects() + { + reset(); + } + + void SetEffects::read(Common::ReadStream* stream, int framesCount) + { + _distanceCoeficient = stream->readFloatLE(); + _distanceColor.r = stream->readFloatLE(); + _distanceColor.g = stream->readFloatLE(); + _distanceColor.b = stream->readFloatLE(); + + _fogsCount = stream->readUint32LE(); + int i; + for (i = 0; i < _fogsCount; i++) + { + int type = stream->readUint32LE(); + Fog* fog = NULL; + switch(type) + { + case 0: + fog = new FogCone(); + break; + case 1: + fog = new FogSphere(); + break; + case 2: + fog = new FogBox(); + break; + } + if(!fog) + { + //TODO exception, unknown fog type + } + fog->read(stream, framesCount); + fog->_next = _fogs; + _fogs = fog; + } + } + + void SetEffects::reset() + { + Fog* fog, *nextFog; + + if (!_fogs) + return; + + do + { + fog = _fogs; + nextFog = fog->_next; + delete fog; + fog = nextFog; + } while (nextFog); + + } + + void SetEffects::setupFrame(int frame) + { + } +}
\ No newline at end of file diff --git a/engines/bladerunner/set_effects.h b/engines/bladerunner/set_effects.h new file mode 100644 index 0000000000..5165cfba94 --- /dev/null +++ b/engines/bladerunner/set_effects.h @@ -0,0 +1,62 @@ +/* ScummVM - Graphic Adventure Engine +* +* ScummVM is the legal property of its developers, whose names +* are too numerous to list here. Please refer to the COPYRIGHT +* file distributed with this source distribution. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +*/ + +#ifndef BLADERUNNER_SET_EFFECTS_H +#define BLADERUNNER_SET_EFFECTS_H + +#include "bladerunner/bladerunner.h" +#include "bladerunner/color.h" +#include "bladerunner/fog.h" + +#include "common/stream.h" + + +namespace BladeRunner { + + class SetEffects + { + BladeRunnerEngine *_vm; + + private: + Color _distanceColor; + float _distanceCoeficient; + Color _fadeColor; + float _fadeDensity; + int _fogsCount; + Fog *_fogs; + + public: + SetEffects(BladeRunnerEngine *vm); + ~SetEffects(); + + void read(Common::ReadStream *stream, int framesCount); + + void reset(); + + void setupFrame(int frame); + + private: + + }; + +} +#endif diff --git a/engines/bladerunner/slice_renderer.cpp b/engines/bladerunner/slice_renderer.cpp index 4e2300ec7f..a1e8497dc9 100644 --- a/engines/bladerunner/slice_renderer.cpp +++ b/engines/bladerunner/slice_renderer.cpp @@ -24,6 +24,9 @@ #include "bladerunner/bladerunner.h" #include "bladerunner/slice_animations.h" +#include "bladerunner/lights.h" +#include "bladerunner/scene.h" +#include "bladerunner/set.h" #include "common/debug.h" #include "common/memstream.h" @@ -54,7 +57,7 @@ void dump(const char *str, Matrix4x3 m) { SliceRenderer::~SliceRenderer() { } -void SliceRenderer::setView(const View &view) { +void SliceRenderer::setView(View *view) { _view = view; } @@ -84,7 +87,7 @@ void SliceRenderer::setupFrame(int animation, int frame, Vector3 position, float Matrix3x2 SliceRenderer::calculateFacingRotationMatrix() { assert(_sliceFramePtr); - Matrix4x3 viewMatrix = _view._sliceViewMatrix; + Matrix4x3 viewMatrix = _view->_sliceViewMatrix; Vector3 viewPos = viewMatrix * _position; float dir = atan2f(viewPos.x, viewPos.z) + _facing; float s = sinf(dir); @@ -107,7 +110,7 @@ void SliceRenderer::calculateBoundingRect() { _minY = 0.0f; _maxY = 0.0f; - Matrix4x3 viewMatrix = _view._sliceViewMatrix; + Matrix4x3 viewMatrix = _view->_sliceViewMatrix; Vector3 frameBottom = Vector3(0.0f, 0.0f, _frameBottomZ); Vector3 frameTop = Vector3(0.0f, 0.0f, _frameBottomZ + _frameSliceCount * _frameSliceHeight); @@ -122,7 +125,7 @@ void SliceRenderer::calculateBoundingRect() { Matrix3x2 facingRotation = calculateFacingRotationMatrix(); - Matrix3x2 m4(_view._viewportDistance / bottom.z, 0.0f, 0.0f, + Matrix3x2 m4(_view->_viewportDistance / bottom.z, 0.0f, 0.0f, 0.0f, 25.5f, 0.0f); Matrix3x2 m2(_frameFront.x, 0.0f, _framePos.x, @@ -130,13 +133,13 @@ void SliceRenderer::calculateBoundingRect() { _field_109E = m4 * (facingRotation * m2); - Vector4 B6(_view._viewportHalfWidth + top.x / top.z * _view._viewportDistance, - _view._viewportHalfHeight + top.y / top.z * _view._viewportDistance, + Vector4 B6(_view->_viewportHalfWidth + top.x / top.z * _view->_viewportDistance, + _view->_viewportHalfHeight + top.y / top.z * _view->_viewportDistance, 1.0f / top.z, _frameSliceCount * (1.0f / top.z)); - Vector4 C2(_view._viewportHalfWidth + bottom.x / bottom.z * _view._viewportDistance, - _view._viewportHalfHeight + bottom.y / bottom.z * _view._viewportDistance, + Vector4 C2(_view->_viewportHalfWidth + bottom.x / bottom.z * _view->_viewportDistance, + _view->_viewportHalfHeight + bottom.y / bottom.z * _view->_viewportDistance, 1.0f / bottom.z, 0.0f); @@ -324,6 +327,9 @@ void setupLookupTable(int t[256], int inc) { void SliceRenderer::drawFrame(Graphics::Surface &surface, uint16 *zbuffer) { assert(_sliceFramePtr); + assert(_lights); + assert(_setEffects); + assert(_view); SliceLineIterator sliceLineIterator; sliceLineIterator.setup( @@ -333,6 +339,9 @@ void SliceRenderer::drawFrame(Graphics::Surface &surface, uint16 *zbuffer) { _field_109E // 3x2 matrix ); + _lights->setupFrame(_view->_frame); + _setEffects->setupFrame(_view->_frame); + setupLookupTable(_t1, sliceLineIterator._field_00[0][0]); setupLookupTable(_t2, sliceLineIterator._field_00[0][1]); setupLookupTable(_t4, sliceLineIterator._field_00[1][0]); @@ -407,4 +416,13 @@ void SliceRenderer::drawSlice(int slice, uint16 *frameLinePtr, uint16 *zbufLineP } } +void SliceRenderer::setLights(Lights* lights) +{ + _lights = lights; +} + +void SliceRenderer::setSetEffects(SetEffects* setEffects) +{ + _setEffects = setEffects; +} } // End of namespace BladeRunner diff --git a/engines/bladerunner/slice_renderer.h b/engines/bladerunner/slice_renderer.h index 79ebdd8951..c04560a35e 100644 --- a/engines/bladerunner/slice_renderer.h +++ b/engines/bladerunner/slice_renderer.h @@ -26,6 +26,8 @@ #include "bladerunner/vector.h" #include "bladerunner/view.h" #include "bladerunner/matrix.h" +#include "bladerunner/lights.h" +#include "bladerunner/set_effects.h" #include "graphics/surface.h" @@ -34,8 +36,9 @@ namespace Common { } namespace BladeRunner { + class SetEffects; -class BladeRunnerEngine; + class BladeRunnerEngine; class SliceRenderer { BladeRunnerEngine *_vm; @@ -46,7 +49,9 @@ class SliceRenderer { float _facing; float _scale; - View _view; + View *_view; + Lights *_lights; + SetEffects *_setEffects; void *_sliceFramePtr; @@ -75,6 +80,8 @@ class SliceRenderer { int _t5[256]; int _c6; + + Matrix3x2 calculateFacingRotationMatrix(); void drawSlice(int slice, uint16 *frameLinePtr, uint16 *zbufLinePtr); @@ -84,11 +91,16 @@ public: {} ~SliceRenderer(); - void setView(const View &view); + void setView(View *view); + void setLights(Lights *lights); + void setSetEffects(SetEffects *setEffects); + void setupFrame(int animation, int frame, Vector3 position, float facing, float scale = 1.0f); void calculateBoundingRect(); void drawFrame(Graphics::Surface &surface, uint16 *zbuffer); + + }; } // End of namespace BladeRunner diff --git a/engines/bladerunner/view.cpp b/engines/bladerunner/view.cpp index b3b6ad8ad2..029f829c0d 100644 --- a/engines/bladerunner/view.cpp +++ b/engines/bladerunner/view.cpp @@ -27,6 +27,11 @@ namespace BladeRunner { +View::View(BladeRunnerEngine* vm) +{ + _vm = vm; +} + bool View::read(Common::ReadStream *stream) { uint32 frame; frame = stream->readUint32LE(); diff --git a/engines/bladerunner/view.h b/engines/bladerunner/view.h index 511ea66d1b..3e3a0e86b1 100644 --- a/engines/bladerunner/view.h +++ b/engines/bladerunner/view.h @@ -23,6 +23,8 @@ #ifndef BLADERUNNER_VIEW_H #define BLADERUNNER_VIEW_H +#include "bladerunner/bladerunner.h" + #include "matrix.h" namespace Common { @@ -32,6 +34,7 @@ namespace Common { namespace BladeRunner { class View { + BladeRunnerEngine *_vm; public: float _fovX; Matrix4x3 _frameViewMatrix; @@ -44,8 +47,12 @@ public: float _viewportHalfHeight; float _viewportDistance; + View(BladeRunnerEngine *vm); + bool read(Common::ReadStream *stream); + + private: void setFovX(float fovX); void calculateSliceViewMatrix(); diff --git a/engines/bladerunner/vqa_decoder.cpp b/engines/bladerunner/vqa_decoder.cpp index d1e56a98d6..63378dc5e9 100644 --- a/engines/bladerunner/vqa_decoder.cpp +++ b/engines/bladerunner/vqa_decoder.cpp @@ -30,6 +30,7 @@ #include "common/array.h" #include "common/util.h" +#include "common/memstream.h" namespace BladeRunner { @@ -524,7 +525,12 @@ bool VQADecoder::readMFCI(Common::SeekableReadStream *s, uint32 size) { return true; } -VQADecoder::VQAVideoTrack::VQAVideoTrack(VQADecoder *vqaDecoder) { +void VQADecoder::decodeView(View* view) +{ + _videoTrack->decodeView(view); +} + + VQADecoder::VQAVideoTrack::VQAVideoTrack(VQADecoder *vqaDecoder) { VQADecoder::Header *header = &vqaDecoder->_header; _surface = nullptr; @@ -560,6 +566,8 @@ VQADecoder::VQAVideoTrack::VQAVideoTrack(VQADecoder *vqaDecoder) { _surface = new Graphics::Surface(); _surface->create(_width, _height, createRGB555()); + + _viewData = new uint8[56]; } VQADecoder::VQAVideoTrack::~VQAVideoTrack() { @@ -567,6 +575,7 @@ VQADecoder::VQAVideoTrack::~VQAVideoTrack() { delete[] _cbfz; delete[] _zbufChunk; delete[] _vpointer; + delete[] _viewData; if (_surface) _surface->free(); @@ -743,18 +752,29 @@ const uint16 *VQADecoder::VQAVideoTrack::decodeZBuffer() return _zbuffer; } -bool VQADecoder::VQAVideoTrack::readVIEW(Common::SeekableReadStream *s, uint32 size) + +void VQADecoder::VQAVideoTrack::decodeView(View* view) +{ + assert(_viewData); + assert(view); + + Common::MemoryReadStream s(_viewData, 56); + view->read(&s); +} + + bool VQADecoder::VQAVideoTrack::readVIEW(Common::SeekableReadStream *s, uint32 size) { if (size != 56) return false; - _view.read(s); + s->read(_viewData, 56); return true; } bool VQADecoder::VQAVideoTrack::readAESC(Common::SeekableReadStream *s, uint32 size) { + // some screen (2d not 3d) effects for transparency s->skip(roundup(size)); return true; } diff --git a/engines/bladerunner/vqa_decoder.h b/engines/bladerunner/vqa_decoder.h index 3f8c968b9e..c57372081d 100644 --- a/engines/bladerunner/vqa_decoder.h +++ b/engines/bladerunner/vqa_decoder.h @@ -52,8 +52,8 @@ public: const Graphics::Surface *decodeVideoFrame(); const uint16 *decodeZBuffer(); Audio::SeekableAudioStream *decodeAudioFrame(); - - const View &getView() { return _videoTrack->getView(); } + void decodeView(View *view); + //const View &getView() { return _videoTrack->getView(); } uint16 numFrames() const { return _header.numFrames; } uint8 frameRate() const { return _header.frameRate; } @@ -163,7 +163,7 @@ private: int getFrameCount() const; const Graphics::Surface *decodeVideoFrame(); const uint16 *decodeZBuffer(); - const View &getView() { return _view; } + void decodeView(View *view); bool readVQFR(Common::SeekableReadStream *s, uint32 size); bool readVPTR(Common::SeekableReadStream *s, uint32 size); @@ -207,7 +207,7 @@ private: int _curFrame; - View _view; + uint8 *_viewData; void VPTRWriteBlock(uint16 *frame, unsigned int dstBlock, unsigned int srcBlock, int count, bool alpha = false); bool decodeFrame(uint16 *frame); diff --git a/engines/bladerunner/vqa_player.cpp b/engines/bladerunner/vqa_player.cpp index 8146c1abf9..0a04d1b786 100644 --- a/engines/bladerunner/vqa_player.cpp +++ b/engines/bladerunner/vqa_player.cpp @@ -65,7 +65,7 @@ int VQAPlayer::update() { queueAudioFrame(_decoder.decodeAudioFrame()); _surface = _decoder.decodeVideoFrame(); _zBuffer = _decoder.decodeZBuffer(); - _view = _decoder.getView(); + _decoder.decodeView(_view); } _decodedFrame = calcNextFrame(_curFrame); @@ -89,7 +89,7 @@ int VQAPlayer::update() { if (_curFrame >= 0) { _surface = _decoder.decodeVideoFrame(); _zBuffer = _decoder.decodeZBuffer(); - _view = _decoder.getView(); + _decoder.decodeView(_view); } _decodedFrame = calcNextFrame(_curFrame); diff --git a/engines/bladerunner/vqa_player.h b/engines/bladerunner/vqa_player.h index 80ebf19d2f..98f1fcf51b 100644 --- a/engines/bladerunner/vqa_player.h +++ b/engines/bladerunner/vqa_player.h @@ -42,14 +42,14 @@ class VQAPlayer { const uint16 *_zBuffer; Audio::QueuingAudioStream *_audioStream; + View *_view; + int _curFrame; int _decodedFrame; int _curLoop; int _loopSpecial; int _loopDefault; - View _view; - uint32 _nextFrameTime; bool _hasAudio; bool _audioStarted; @@ -57,7 +57,7 @@ class VQAPlayer { public: - VQAPlayer(BladeRunnerEngine *vm) + VQAPlayer(BladeRunnerEngine *vm, View *view) : _vm(vm), _s(nullptr), _surface(nullptr), @@ -69,7 +69,8 @@ public: _loopDefault(-1), _nextFrameTime(0), _hasAudio(false), - _audioStarted(false) + _audioStarted(false), + _view(view) {} ~VQAPlayer() { @@ -82,7 +83,6 @@ public: int update(); const Graphics::Surface *getSurface() const; const uint16 *getZBuffer() const; - const View &getView() const { return _view; } void setLoopSpecial(int loop, bool wait); void setLoopDefault(int loop); |