thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

MATH: Move the math classes to their own math/ dir and Math namespace.

Browse source
This commit is contained in:
Giulio Camuffo 2011-09-10 17:46:07 +02:00
parent e9267cfec5
commit 0083c8619c
42 changed files with 353 additions and 346 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Makefile.common
View file

@ -26,6 +26,7 @@ MODULES += \
video \ video \
graphics \ graphics \
audio \ audio \
math \
common \ common \
po po

108
engines/grim/actor.cpp
View file

@ -27,8 +27,8 @@
#define FORBIDDEN_SYMBOL_EXCEPTION_mkdir #define FORBIDDEN_SYMBOL_EXCEPTION_mkdir
#define FORBIDDEN_SYMBOL_EXCEPTION_unlink #define FORBIDDEN_SYMBOL_EXCEPTION_unlink
#include "graphics/line3d.h" #include "math/line3d.h"
#include "graphics/rect2d.h" #include "math/rect2d.h"
#include "engines/grim/debug.h" #include "engines/grim/debug.h"
#include "engines/grim/actor.h" #include "engines/grim/actor.h"
@ -268,7 +268,7 @@ void Actor::saveState(SaveGame *savedState) const {
savedState->writeLESint32(_winY2); savedState->writeLESint32(_winY2);
savedState->writeLESint32(_path.size()); savedState->writeLESint32(_path.size());
for (Common::List<Graphics::Vector3d>::const_iterator i = _path.begin(); i != _path.end(); ++i) { for (Common::List<Math::Vector3d>::const_iterator i = _path.begin(); i != _path.end(); ++i) {
savedState->writeVector3d(*i); savedState->writeVector3d(*i);
} }
} }
@ -458,7 +458,7 @@ void Actor::setRot(float pitchParam, float yawParam, float rollParam) {
_turning = false; _turning = false;
} }
void Actor::setPos(Graphics::Vector3d position) { void Actor::setPos(Math::Vector3d position) {
_walking = false; _walking = false;
_pos = position; _pos = position;
@ -480,7 +480,7 @@ void Actor::turnTo(float pitchParam, float yawParam, float rollParam) {
_turning = false; _turning = false;
} }
void Actor::walkTo(const Graphics::Vector3d &p) { void Actor::walkTo(const Math::Vector3d &p) {
if (p == _pos) if (p == _pos)
_walking = false; _walking = false;
else { else {
@ -557,17 +557,17 @@ void Actor::walkTo(const Graphics::Vector3d &p) {
if (inClosed) if (inClosed)
continue; continue;
Common::List<Graphics::Line3d> bridges = sector->getBridgesTo(s); Common::List<Math::Line3d> bridges = sector->getBridgesTo(s);
if (bridges.empty()) if (bridges.empty())
continue; // The sectors are not adjacent. continue; // The sectors are not adjacent.
Graphics::Vector3d closestPoint = s->getClosestPoint(_destPos); Math::Vector3d closestPoint = s->getClosestPoint(_destPos);
Graphics::Vector3d best; Math::Vector3d best;
float bestDist = 1e6f; float bestDist = 1e6f;
Graphics::Line3d l(node->pos, closestPoint); Math::Line3d l(node->pos, closestPoint);
while (!bridges.empty()) { while (!bridges.empty()) {
Graphics::Line3d bridge = bridges.back(); Math::Line3d bridge = bridges.back();
Graphics::Vector3d pos; Math::Vector3d pos;
if (!bridge.intersectLine2d(l, &pos)) { if (!bridge.intersectLine2d(l, &pos)) {
pos = bridge.middle(); pos = bridge.middle();
} }
@ -632,14 +632,14 @@ bool Actor::isTurning() const {
return false; return false;
} }
void Actor::moveTo(const Graphics::Vector3d &pos) { void Actor::moveTo(const Math::Vector3d &pos) {
// This is necessary for collisions in set hl to work, since // This is necessary for collisions in set hl to work, since
// Manny's collision mode isn't set. // Manny's collision mode isn't set.
if (_collisionMode == CollisionOff) { if (_collisionMode == CollisionOff) {
_collisionMode = CollisionSphere; _collisionMode = CollisionSphere;
} }
Graphics::Vector3d v = pos - _pos; Math::Vector3d v = pos - _pos;
for (Actor::Pool::Iterator i = getPool()->getBegin(); i != getPool()->getEnd(); ++i) { for (Actor::Pool::Iterator i = getPool()->getBegin(); i != getPool()->getEnd(); ++i) {
Actor *a = i->_value; Actor *a = i->_value;
if (a != this && a->isInSet(_setName) && a->isVisible()) { if (a != this && a->isInSet(_setName) && a->isVisible()) {
@ -655,7 +655,7 @@ void Actor::walkForward() {
float yaw_rad = _yaw * (LOCAL_PI / 180.f), pitch_rad = _pitch * (LOCAL_PI / 180.f); float yaw_rad = _yaw * (LOCAL_PI / 180.f), pitch_rad = _pitch * (LOCAL_PI / 180.f);
//float yaw; //float yaw;
Graphics::Vector3d forwardVec(-sin(yaw_rad) * cos(pitch_rad), Math::Vector3d forwardVec(-sin(yaw_rad) * cos(pitch_rad),
cos(yaw_rad) * cos(pitch_rad), sin(pitch_rad)); cos(yaw_rad) * cos(pitch_rad), sin(pitch_rad));
if (! _constrain) { if (! _constrain) {
@ -681,7 +681,7 @@ void Actor::walkForward() {
while (currSector) { while (currSector) {
prevSector = currSector; prevSector = currSector;
Graphics::Vector3d puckVec = currSector->getProjectionToPuckVector(forwardVec); Math::Vector3d puckVec = currSector->getProjectionToPuckVector(forwardVec);
puckVec /= puckVec.magnitude(); puckVec /= puckVec.magnitude();
currSector->getExitInfo(_pos, puckVec, &ei); currSector->getExitInfo(_pos, puckVec, &ei);
float exitDist = (ei.exitPoint - _pos).magnitude(); float exitDist = (ei.exitPoint - _pos).magnitude();
@ -719,9 +719,9 @@ void Actor::walkForward() {
setYaw(_yaw + turnAmt * turnDir); setYaw(_yaw + turnAmt * turnDir);
} }
Graphics::Vector3d Actor::getPuckVector() const { Math::Vector3d Actor::getPuckVector() const {
float yaw_rad = _yaw * (LOCAL_PI / 180.f); float yaw_rad = _yaw * (LOCAL_PI / 180.f);
Graphics::Vector3d forwardVec(-sin(yaw_rad), cos(yaw_rad), 0); Math::Vector3d forwardVec(-sin(yaw_rad), cos(yaw_rad), 0);
Sector *sector = g_grim->getCurrScene()->findPointSector(_pos, Sector::WalkType); Sector *sector = g_grim->getCurrScene()->findPointSector(_pos, Sector::WalkType);
if (!sector) if (!sector)
@ -812,15 +812,15 @@ void Actor::turn(int dir) {
float Actor::getYawTo(const Actor &a) const { float Actor::getYawTo(const Actor &a) const {
float yaw_rad = _yaw * (LOCAL_PI / 180.f); float yaw_rad = _yaw * (LOCAL_PI / 180.f);
Graphics::Vector3d forwardVec(-sin(yaw_rad), cos(yaw_rad), 0); Math::Vector3d forwardVec(-sin(yaw_rad), cos(yaw_rad), 0);
Graphics::Vector3d delta = a.getPos() - _pos; Math::Vector3d delta = a.getPos() - _pos;
delta.z() = 0; delta.z() = 0;
return angle(forwardVec, delta) * (180.f / LOCAL_PI); return angle(forwardVec, delta) * (180.f / LOCAL_PI);
} }
float Actor::getYawTo(Graphics::Vector3d p) const { float Actor::getYawTo(Math::Vector3d p) const {
Graphics::Vector3d dpos = p - _pos; Math::Vector3d dpos = p - _pos;
if (dpos.x() == 0 && dpos.y() == 0) if (dpos.x() == 0 && dpos.y() == 0)
return 0; return 0;
@ -1042,14 +1042,14 @@ void Actor::updateWalk() {
return; return;
} }
Graphics::Vector3d destPos = _path.back(); Math::Vector3d destPos = _path.back();
float y = getYawTo(destPos); float y = getYawTo(destPos);
if (y < 0.f) { if (y < 0.f) {
y += 360.f; y += 360.f;
} }
turnTo(_pitch, y, _roll); turnTo(_pitch, y, _roll);
Graphics::Vector3d dir = destPos - _pos; Math::Vector3d dir = destPos - _pos;
float dist = dir.magnitude(); float dist = dir.magnitude();
if (dist > 0) if (dist > 0)
@ -1358,8 +1358,8 @@ bool Actor::shouldDrawShadow(int shadowId) {
// Don't draw a shadow if the actor is behind the shadow plane. // Don't draw a shadow if the actor is behind the shadow plane.
Sector *sector = shadow->planeList.front().sector; Sector *sector = shadow->planeList.front().sector;
Graphics::Vector3d n = sector->getNormal(); Math::Vector3d n = sector->getNormal();
Graphics::Vector3d p = sector->getVertices()[0]; Math::Vector3d p = sector->getVertices()[0];
float d = -(n.x() * p.x() + n.y() * p.y() + n.z() * p.z()); float d = -(n.x() * p.x() + n.y() * p.y() + n.z() * p.z());
p = getPos(); p = getPos();
@ -1393,7 +1393,7 @@ void Actor::setActivateShadow(int shadowId, bool state) {
_shadowArray[shadowId].active = state; _shadowArray[shadowId].active = state;
} }
void Actor::setShadowPoint(Graphics::Vector3d p) { void Actor::setShadowPoint(Math::Vector3d p) {
assert(_activeShadowSlot != -1); assert(_activeShadowSlot != -1);
_shadowArray[_activeShadowSlot].pos = p; _shadowArray[_activeShadowSlot].pos = p;
@ -1456,7 +1456,7 @@ void Actor::setCollisionScale(float scale) {
_collisionScale = scale; _collisionScale = scale;
} }
bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const { bool Actor::collidesWith(Actor *actor, Math::Vector3d *vec) const {
if (actor->_collisionMode == CollisionOff) { if (actor->_collisionMode == CollisionOff) {
return false; return false;
} }
@ -1464,8 +1464,8 @@ bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const {
Model *model1 = getCurrentCostume()->getModel(); Model *model1 = getCurrentCostume()->getModel();
Model *model2 = actor->getCurrentCostume()->getModel(); Model *model2 = actor->getCurrentCostume()->getModel();
Graphics::Vector3d p1 = _pos + model1->_insertOffset; Math::Vector3d p1 = _pos + model1->_insertOffset;
Graphics::Vector3d p2 = actor->_pos + model2->_insertOffset; Math::Vector3d p2 = actor->_pos + model2->_insertOffset;
float size1 = model1->_radius * _collisionScale; float size1 = model1->_radius * _collisionScale;
float size2 = model2->_radius * actor->_collisionScale; float size2 = model2->_radius * actor->_collisionScale;
@ -1474,12 +1474,12 @@ bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const {
CollisionMode mode2 = actor->_collisionMode; CollisionMode mode2 = actor->_collisionMode;
if (mode1 == CollisionSphere && mode2 == CollisionSphere) { if (mode1 == CollisionSphere && mode2 == CollisionSphere) {
Graphics::Vector3d pos = p1 + *vec; Math::Vector3d pos = p1 + *vec;
float distance = (pos - p2).magnitude(); float distance = (pos - p2).magnitude();
if (distance < size1 + size2) { if (distance < size1 + size2) {
// Move the destination point so that its distance from the // Move the destination point so that its distance from the
// center of the circle is size1+size2. // center of the circle is size1+size2.
Graphics::Vector3d v = pos - p2; Math::Vector3d v = pos - p2;
v.normalize(); v.normalize();
v *= size1 + size2; v *= size1 + size2;
*vec = v + p2 - p1; *vec = v + p2 - p1;
@ -1491,15 +1491,15 @@ bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const {
warning("Collision between box and box not implemented!"); warning("Collision between box and box not implemented!");
return false; return false;
} else { } else {
Graphics::Rect2d rect; Math::Rect2d rect;
Graphics::Vector3d bboxPos; Math::Vector3d bboxPos;
Graphics::Vector3d size; Math::Vector3d size;
Graphics::Vector3d pos; Math::Vector3d pos;
Graphics::Vector3d circlePos; Math::Vector3d circlePos;
float yaw; float yaw;
Graphics::Vector2d circle; Math::Vector2d circle;
float radius; float radius;
if (mode1 == CollisionBox) { if (mode1 == CollisionBox) {
@ -1524,35 +1524,35 @@ bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const {
radius = size1; radius = size1;
} }
rect._topLeft = Graphics::Vector2d(bboxPos.x(), bboxPos.y() + size.y()); rect._topLeft = Math::Vector2d(bboxPos.x(), bboxPos.y() + size.y());
rect._topRight = Graphics::Vector2d(bboxPos.x() + size.x(), bboxPos.y() + size.y()); rect._topRight = Math::Vector2d(bboxPos.x() + size.x(), bboxPos.y() + size.y());
rect._bottomLeft = Graphics::Vector2d(bboxPos.x(), bboxPos.y()); rect._bottomLeft = Math::Vector2d(bboxPos.x(), bboxPos.y());
rect._bottomRight = Graphics::Vector2d(bboxPos.x() + size.x(), bboxPos.y()); rect._bottomRight = Math::Vector2d(bboxPos.x() + size.x(), bboxPos.y());
rect.rotateAround(Graphics::Vector2d(pos.x(), pos.y()), yaw); rect.rotateAround(Math::Vector2d(pos.x(), pos.y()), yaw);
if (rect.intersectsCircle(circle, radius)) { if (rect.intersectsCircle(circle, radius)) {
Graphics::Vector2d center = rect.getCenter(); Math::Vector2d center = rect.getCenter();
// Draw a line from the center of the rect to the place the character // Draw a line from the center of the rect to the place the character
// would go to. // would go to.
Graphics::Vector2d v = circle - center; Math::Vector2d v = circle - center;
v.normalize(); v.normalize();
Graphics::Segment2d edge; Math::Segment2d edge;
// That line intersects (usually) an edge // That line intersects (usually) an edge
rect.getIntersection(center, v, &edge); rect.getIntersection(center, v, &edge);
// Take the perpendicular of that edge // Take the perpendicular of that edge
Graphics::Line2d perpendicular = edge.getPerpendicular(circle); Math::Line2d perpendicular = edge.getPerpendicular(circle);
Graphics::Vector3d point; Math::Vector3d point;
Graphics::Vector2d p; Math::Vector2d p;
// If that perpendicular intersects the edge // If that perpendicular intersects the edge
if (edge.intersectsLine(perpendicular, &p)) { if (edge.intersectsLine(perpendicular, &p)) {
Graphics::Vector2d direction = perpendicular.getDirection(); Math::Vector2d direction = perpendicular.getDirection();
direction.normalize(); direction.normalize();
// Move from the intersection until we are at a safe distance // Move from the intersection until we are at a safe distance
Graphics::Vector2d point1(p - direction * radius); Math::Vector2d point1(p - direction * radius);
Graphics::Vector2d point2(p + direction * radius); Math::Vector2d point2(p + direction * radius);
if (center.getDistanceTo(point1) < center.getDistanceTo(point2)) { if (center.getDistanceTo(point1) < center.getDistanceTo(point2)) {
point = point2.toVector3d(); point = point2.toVector3d();
@ -1561,10 +1561,10 @@ bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const {
} }
} else { //if not we're around a corner } else { //if not we're around a corner
// Find the nearest vertex of the rect // Find the nearest vertex of the rect
Graphics::Vector2d vertex = rect.getTopLeft(); Math::Vector2d vertex = rect.getTopLeft();
float distance = vertex.getDistanceTo(circle); float distance = vertex.getDistanceTo(circle);
Graphics::Vector2d other = rect.getTopRight(); Math::Vector2d other = rect.getTopRight();
float otherDist = other.getDistanceTo(circle); float otherDist = other.getDistanceTo(circle);
if (otherDist < distance) { if (otherDist < distance) {
distance = otherDist; distance = otherDist;
@ -1584,7 +1584,7 @@ bool Actor::collidesWith(Actor *actor, Graphics::Vector3d *vec) const {
} }
// and move on a circle around it // and move on a circle around it
Graphics::Vector2d dst = circle - vertex; Math::Vector2d dst = circle - vertex;
dst.normalize(); dst.normalize();
dst = dst * radius; dst = dst * radius;
point = (vertex + dst).toVector3d(); point = (vertex + dst).toVector3d();

34
engines/grim/actor.h
View file

@ -25,7 +25,7 @@
#include "engines/grim/pool.h" #include "engines/grim/pool.h"
#include "engines/grim/object.h" #include "engines/grim/object.h"
#include "graphics/vector3d.h" #include "math/vector3d.h"
namespace Grim { namespace Grim {
@ -46,7 +46,7 @@ typedef Common::List<Plane> SectorListType;
struct Shadow { struct Shadow {
Common::String name; Common::String name;
Graphics::Vector3d pos; Math::Vector3d pos;
SectorListType planeList; SectorListType planeList;
byte *shadowMask; byte *shadowMask;
int shadowMaskSize; int shadowMaskSize;
@ -121,13 +121,13 @@ public:
* @param position The position. * @param position The position.
* @see getPos * @see getPos
*/ */
void setPos(Graphics::Vector3d position); void setPos(Math::Vector3d position);
/** /**
* Returns the position of the actor on the 3D scene. * Returns the position of the actor on the 3D scene.
* *
* @see setPos * @see setPos
*/ */
Graphics::Vector3d getPos() const { return _pos; } Math::Vector3d getPos() const { return _pos; }
/** /**
* Tells the actor to go to the wanted position. * Tells the actor to go to the wanted position.
@ -138,7 +138,7 @@ public:
* @see stopWalking * @see stopWalking
* @see isWalking * @see isWalking
*/ */
void walkTo(const Graphics::Vector3d &position); void walkTo(const Math::Vector3d &position);
/** /**
* Stops immediately the actor's walk. * Stops immediately the actor's walk.
* *
@ -251,7 +251,7 @@ public:
* *
* @param actor The point to look at. * @param actor The point to look at.
*/ */
float getYawTo(Graphics::Vector3d p) const; float getYawTo(Math::Vector3d p) const;
/** /**
* Sets the actor visibility. * Sets the actor visibility.
@ -341,7 +341,7 @@ public:
* @see walkTo * @see walkTo
*/ */
void walkForward(); void walkForward();
void moveTo(const Graphics::Vector3d &pos); void moveTo(const Math::Vector3d &pos);
/** /**
* Used to tell the actor if it is running or not. * Used to tell the actor if it is running or not.
* *
@ -353,7 +353,7 @@ public:
* Returns a vector representing the direction the actor * Returns a vector representing the direction the actor
* is facing. * is facing.
*/ */
Graphics::Vector3d getPuckVector() const; Math::Vector3d getPuckVector() const;
/** /**
* Makes the actor say the given line. * Makes the actor say the given line.
@ -410,7 +410,7 @@ public:
} }
void setActiveShadow(int shadowId); void setActiveShadow(int shadowId);
void setShadowPoint(Graphics::Vector3d pos); void setShadowPoint(Math::Vector3d pos);
void setShadowPlane(const char *name); void setShadowPlane(const char *name);
void addShadowPlane(const char *name); void addShadowPlane(const char *name);
void clearShadowPlanes(); void clearShadowPlanes();
@ -430,10 +430,10 @@ public:
void setLookAtVectorZero() { void setLookAtVectorZero() {
_lookAtVector.set(0.f, 0.f, 0.f); _lookAtVector.set(0.f, 0.f, 0.f);
} }
void setLookAtVector(Graphics::Vector3d vector) { void setLookAtVector(Math::Vector3d vector) {
_lookAtVector = vector; _lookAtVector = vector;
} }
Graphics::Vector3d getLookAtVector() { Math::Vector3d getLookAtVector() {
return _lookAtVector; return _lookAtVector;
} }
void setLookAtRate(float rate) { void setLookAtRate(float rate) {
@ -447,7 +447,7 @@ public:
void setCollisionMode(CollisionMode mode); void setCollisionMode(CollisionMode mode);
void setCollisionScale(float scale); void setCollisionScale(float scale);
bool collidesWith(Actor *actor, Graphics::Vector3d *vec) const; bool collidesWith(Actor *actor, Math::Vector3d *vec) const;
bool _toClean; bool _toClean;
@ -464,7 +464,7 @@ private:
Common::String _setName; // The actual current set Common::String _setName; // The actual current set
PoolColor *_talkColor; PoolColor *_talkColor;
Graphics::Vector3d _pos; Math::Vector3d _pos;
float _pitch, _yaw, _roll; float _pitch, _yaw, _roll;
float _walkRate, _turnRate; float _walkRate, _turnRate;
@ -484,7 +484,7 @@ private:
// Variables for walking to a point // Variables for walking to a point
bool _walking; bool _walking;
Graphics::Vector3d _destPos; Math::Vector3d _destPos;
// chores // chores
Costume *_restCostume; Costume *_restCostume;
@ -523,7 +523,7 @@ private:
void freeCostumeChore(Costume *toFree, Costume *&cost, int &chore); void freeCostumeChore(Costume *toFree, Costume *&cost, int &chore);
// lookAt // lookAt
Graphics::Vector3d _lookAtVector; Math::Vector3d _lookAtVector;
float _lookAtRate; float _lookAtRate;
int _winX1, _winY1, _winX2, _winY2; int _winX1, _winY1, _winX2, _winY2;
@ -532,11 +532,11 @@ private:
struct PathNode { struct PathNode {
Sector *sect; Sector *sect;
PathNode *parent; PathNode *parent;
Graphics::Vector3d pos; Math::Vector3d pos;
float dist; float dist;
float cost; float cost;
}; };
Common::List<Graphics::Vector3d> _path; Common::List<Math::Vector3d> _path;
CollisionMode _collisionMode; CollisionMode _collisionMode;
float _collisionScale; float _collisionScale;

2
engines/grim/animation.cpp
View file

@ -241,7 +241,7 @@ void AnimManager::removeAnimation(Animation *anim) {
void AnimManager::animate(ModelNode *hier, int numNodes) { void AnimManager::animate(ModelNode *hier, int numNodes) {
// Apply animation to each hierarchy node separately. // Apply animation to each hierarchy node separately.
for (int i = 0; i < numNodes; i++) { for (int i = 0; i < numNodes; i++) {
Graphics::Vector3d tempPos; Math::Vector3d tempPos;
float tempYaw = 0.0f, tempPitch = 0.0f, tempRoll = 0.0f; float tempYaw = 0.0f, tempPitch = 0.0f, tempRoll = 0.0f;
float totalWeight = 0.0f; float totalWeight = 0.0f;
float remainingWeight = 1.0f; float remainingWeight = 1.0f;

20
engines/grim/costume.cpp
View file

@ -146,7 +146,7 @@ public:
void animate(); void animate();
void reset(); void reset();
void resetColormap(); void resetColormap();
void setMatrix(Graphics::Matrix4 matrix) { _matrix = matrix; }; void setMatrix(Math::Matrix4 matrix) { _matrix = matrix; };
void restoreState(SaveGame *state); void restoreState(SaveGame *state);
AnimManager *getAnimManager() const; AnimManager *getAnimManager() const;
~ModelComponent(); ~ModelComponent();
@ -160,7 +160,7 @@ protected:
Common::String _filename; Common::String _filename;
ObjectPtr<Model> _obj; ObjectPtr<Model> _obj;
ModelNode *_hier; ModelNode *_hier;
Graphics::Matrix4 _matrix; Math::Matrix4 _matrix;
AnimManager *_animation; AnimManager *_animation;
Component *_prevComp; Component *_prevComp;
}; };
@ -198,7 +198,7 @@ public:
void restoreState(SaveGame *state); void restoreState(SaveGame *state);
~MeshComponent() { } ~MeshComponent() { }
void setMatrix(Graphics::Matrix4 matrix) { _matrix = matrix; }; void setMatrix(Math::Matrix4 matrix) { _matrix = matrix; };
ModelNode *getNode() { return _node; } ModelNode *getNode() { return _node; }
Model *getModel() { return _model; } Model *getModel() { return _model; }
@ -208,7 +208,7 @@ private:
int _num; int _num;
Model *_model; Model *_model;
ModelNode *_node; ModelNode *_node;
Graphics::Matrix4 _matrix; Math::Matrix4 _matrix;
}; };
BitmapComponent::BitmapComponent(Costume::Component *p, int parentID, const char *filename, tag32 t) : BitmapComponent::BitmapComponent(Costume::Component *p, int parentID, const char *filename, tag32 t) :
@ -450,7 +450,7 @@ void translateObject(ModelNode *node, bool reset) {
if (reset) { if (reset) {
g_driver->translateViewpointFinish(); g_driver->translateViewpointFinish();
} else { } else {
Graphics::Vector3d animPos = node->_pos + node->_animPos; Math::Vector3d animPos = node->_pos + node->_animPos;
float animPitch = node->_pitch + node->_animPitch; float animPitch = node->_pitch + node->_animPitch;
float animYaw = node->_yaw + node->_animYaw; float animYaw = node->_yaw + node->_animYaw;
float animRoll = node->_roll + node->_animRoll; float animRoll = node->_roll + node->_animRoll;
@ -847,7 +847,7 @@ void SoundComponent::setKey(int val) {
// then it will just use the existing handle // then it will just use the existing handle
g_imuse->startSfx(_soundName.c_str()); g_imuse->startSfx(_soundName.c_str());
if (g_grim->getCurrScene()) { if (g_grim->getCurrScene()) {
Graphics::Vector3d pos = _cost->getMatrix().getPosition(); Math::Vector3d pos = _cost->getMatrix().getPosition();
g_grim->getCurrScene()->setSoundPosition(_soundName.c_str(), pos); g_grim->getCurrScene()->setSoundPosition(_soundName.c_str(), pos);
} }
break; break;
@ -1555,7 +1555,7 @@ void Costume::animate() {
} }
} }
void Costume::moveHead(bool lookingMode, const Graphics::Vector3d &lookAt, float rate) { void Costume::moveHead(bool lookingMode, const Math::Vector3d &lookAt, float rate) {
if (_joint1Node) { if (_joint1Node) {
float step = g_grim->getPerSecond(rate); float step = g_grim->getPerSecond(rate);
float yawStep = step; float yawStep = step;
@ -1598,7 +1598,7 @@ void Costume::moveHead(bool lookingMode, const Graphics::Vector3d &lookAt, float
p->setMatrix(_matrix); p->setMatrix(_matrix);
p->update(); p->update();
Graphics::Vector3d v = lookAt - _joint3Node->_matrix.getPosition(); Math::Vector3d v = lookAt - _joint3Node->_matrix.getPosition();
if (v.isZero()) { if (v.isZero()) {
return; return;
} }
@ -1708,12 +1708,12 @@ void Costume::setHead(int joint1, int joint2, int joint3, float maxRoll, float m
} }
} }
void Costume::setPosRotate(Graphics::Vector3d pos, float pitch, float yaw, float roll) { void Costume::setPosRotate(Math::Vector3d pos, float pitch, float yaw, float roll) {
_matrix.setPosition(pos); _matrix.setPosition(pos);
_matrix.buildFromPitchYawRoll(pitch, yaw, roll); _matrix.buildFromPitchYawRoll(pitch, yaw, roll);
} }
Graphics::Matrix4 Costume::getMatrix() const { Math::Matrix4 Costume::getMatrix() const {
return _matrix; return _matrix;
} }

14
engines/grim/costume.h
View file

@ -25,7 +25,7 @@
#include "common/memstream.h" #include "common/memstream.h"
#include "graphics/matrix4.h" #include "math/matrix4.h"
#include "engines/grim/object.h" #include "engines/grim/object.h"
@ -70,15 +70,15 @@ public:
int getNumChores() const { return _numChores; } int getNumChores() const { return _numChores; }
void setHead(int joint1, int joint2, int joint3, float maxRoll, float maxPitch, float maxYaw); void setHead(int joint1, int joint2, int joint3, float maxRoll, float maxPitch, float maxYaw);
void moveHead(bool lookingMode, const Graphics::Vector3d &lookAt, float rate); void moveHead(bool lookingMode, const Math::Vector3d &lookAt, float rate);
int update(float frameTime); int update(float frameTime);
void animate(); void animate();
void setupTextures(); void setupTextures();
void draw(); void draw();
void draw(int *x1, int *y1, int *x2, int *y2); void draw(int *x1, int *y1, int *x2, int *y2);
void setPosRotate(Graphics::Vector3d pos, float pitch, float yaw, float roll); void setPosRotate(Math::Vector3d pos, float pitch, float yaw, float roll);
Graphics::Matrix4 getMatrix() const; Math::Matrix4 getMatrix() const;
Costume *getPreviousCostume() const; Costume *getPreviousCostume() const;
@ -94,7 +94,7 @@ public:
virtual void setColormap(CMap *c); virtual void setColormap(CMap *c);
bool isVisible(); bool isVisible();
Component *getParent() { return _parent; } Component *getParent() { return _parent; }
virtual void setMatrix(Graphics::Matrix4) { }; virtual void setMatrix(Math::Matrix4) { };
virtual void init() { } virtual void init() { }
virtual void setKey(int) { } virtual void setKey(int) { }
virtual void setMapName(char *) { } virtual void setMapName(char *) { }
@ -114,7 +114,7 @@ public:
int _parentID; int _parentID;
bool _visible; bool _visible;
Component *_parent, *_child, *_sibling; Component *_parent, *_child, *_sibling;
Graphics::Matrix4 _matrix; Math::Matrix4 _matrix;
Costume *_cost; Costume *_cost;
void setCostume(Costume *cost) { _cost = cost; } void setCostume(Costume *cost) { _cost = cost; }
void setParent(Component *newParent); void setParent(Component *newParent);
@ -189,7 +189,7 @@ private:
int _numChores; int _numChores;
Chore *_chores; Chore *_chores;
Common::List<Chore*> _playingChores; Common::List<Chore*> _playingChores;
Graphics::Matrix4 _matrix; Math::Matrix4 _matrix;
ModelNode *_joint1Node; ModelNode *_joint1Node;
ModelNode *_joint2Node; ModelNode *_joint2Node;
ModelNode *_joint3Node; ModelNode *_joint3Node;

8
engines/grim/gfx_base.h
View file

@ -23,7 +23,7 @@
#ifndef GRIM_GFX_BASE_H #ifndef GRIM_GFX_BASE_H
#define GRIM_GFX_BASE_H #define GRIM_GFX_BASE_H
#include "graphics/vector3d.h" #include "math/vector3d.h"
namespace Grim { namespace Grim {
@ -74,7 +74,7 @@ public:
virtual bool isHardwareAccelerated() = 0; virtual bool isHardwareAccelerated() = 0;
virtual void setupCamera(float fov, float nclip, float fclip, float roll) = 0; virtual void setupCamera(float fov, float nclip, float fclip, float roll) = 0;
virtual void positionCamera(Graphics::Vector3d pos, Graphics::Vector3d interest) = 0; virtual void positionCamera(Math::Vector3d pos, Math::Vector3d interest) = 0;
virtual void clearScreen() = 0; virtual void clearScreen() = 0;
@ -84,7 +84,7 @@ public:
virtual void flipBuffer() = 0; virtual void flipBuffer() = 0;
virtual void getBoundingBoxPos(const Mesh *mesh, int *x1, int *y1, int *x2, int *y2) = 0; virtual void getBoundingBoxPos(const Mesh *mesh, int *x1, int *y1, int *x2, int *y2) = 0;
virtual void startActorDraw(Graphics::Vector3d pos, float scale, float yaw, float pitch, float roll) = 0; virtual void startActorDraw(Math::Vector3d pos, float scale, float yaw, float pitch, float roll) = 0;
virtual void finishActorDraw() = 0; virtual void finishActorDraw() = 0;
virtual void setShadow(Shadow *shadow) = 0; virtual void setShadow(Shadow *shadow) = 0;
virtual void drawShadowPlanes() = 0; virtual void drawShadowPlanes() = 0;
@ -95,7 +95,7 @@ public:
virtual void set3DMode() = 0; virtual void set3DMode() = 0;
virtual void translateViewpointStart(Graphics::Vector3d pos, float pitch, float yaw, float roll) = 0; virtual void translateViewpointStart(Math::Vector3d pos, float pitch, float yaw, float roll) = 0;
virtual void translateViewpointFinish() = 0; virtual void translateViewpointFinish() = 0;
virtual void drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2) = 0; virtual void drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2) = 0;

16
engines/grim/gfx_opengl.cpp
View file

@ -174,11 +174,11 @@ void GfxOpenGL::setupCamera(float fov, float nclip, float fclip, float roll) {
glRotatef(roll, 0, 0, -1); glRotatef(roll, 0, 0, -1);
} }
void GfxOpenGL::positionCamera(Graphics::Vector3d pos, Graphics::Vector3d interest) { void GfxOpenGL::positionCamera(Math::Vector3d pos, Math::Vector3d interest) {
Graphics::Vector3d up_vec(0, 0, 1); Math::Vector3d up_vec(0, 0, 1);
if (pos.x() == interest.x() && pos.y() == interest.y()) if (pos.x() == interest.x() && pos.y() == interest.y())
up_vec = Graphics::Vector3d(0, 1, 0); up_vec = Math::Vector3d(0, 1, 0);
gluLookAt(pos.x(), pos.y(), pos.z(), interest.x(), interest.y(), interest.z(), up_vec.x(), up_vec.y(), up_vec.z()); gluLookAt(pos.x(), pos.y(), pos.z(), interest.x(), interest.y(), interest.z(), up_vec.x(), up_vec.y(), up_vec.z());
} }
@ -195,7 +195,7 @@ bool GfxOpenGL::isHardwareAccelerated() {
return true; return true;
} }
static void glShadowProjection(Graphics::Vector3d light, Graphics::Vector3d plane, Graphics::Vector3d normal, bool dontNegate) { static void glShadowProjection(Math::Vector3d light, Math::Vector3d plane, Math::Vector3d normal, bool dontNegate) {
// Based on GPL shadow projection example by // Based on GPL shadow projection example by
// (c) 2002-2003 Phaetos <phaetos@gaffga.de> // (c) 2002-2003 Phaetos <phaetos@gaffga.de>
float d, c; float d, c;
@ -260,7 +260,7 @@ void GfxOpenGL::getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2,
GLdouble winX, winY, winZ; GLdouble winX, winY, winZ;
for (int i = 0; i < model->_numFaces; i++) { for (int i = 0; i < model->_numFaces; i++) {
Graphics::Vector3d v; Math::Vector3d v;
float* pVertices; float* pVertices;
for (int j = 0; j < model->_faces[i]._numVertices; j++) { for (int j = 0; j < model->_faces[i]._numVertices; j++) {
@ -315,7 +315,7 @@ void GfxOpenGL::getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2,
*y2 = (int)bottom; *y2 = (int)bottom;
} }
void GfxOpenGL::startActorDraw(Graphics::Vector3d pos, float scale, float yaw, float pitch, float roll) { void GfxOpenGL::startActorDraw(Math::Vector3d pos, float scale, float yaw, float pitch, float roll) {
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glPushMatrix(); glPushMatrix();
@ -480,7 +480,7 @@ void GfxOpenGL::drawSprite(const Sprite *sprite) {
glPopMatrix(); glPopMatrix();
} }
void GfxOpenGL::translateViewpointStart(Graphics::Vector3d pos, float pitch, float yaw, float roll) { void GfxOpenGL::translateViewpointStart(Math::Vector3d pos, float pitch, float yaw, float roll) {
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glPushMatrix(); glPushMatrix();
@ -495,7 +495,7 @@ void GfxOpenGL::translateViewpointFinish() {
} }
void GfxOpenGL::drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2) { void GfxOpenGL::drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2) {
Graphics::Vector3d animPos = node->_pos + node->_animPos; Math::Vector3d animPos = node->_pos + node->_animPos;
float animPitch = node->_pitch + node->_animPitch; float animPitch = node->_pitch + node->_animPitch;
float animYaw = node->_yaw + node->_animYaw; float animYaw = node->_yaw + node->_animYaw;
float animRoll = node->_roll + node->_animRoll; float animRoll = node->_roll + node->_animRoll;

6
engines/grim/gfx_opengl.h
View file

@ -52,7 +52,7 @@ public:
const char *getVideoDeviceName(); const char *getVideoDeviceName();
void setupCamera(float fov, float nclip, float fclip, float roll); void setupCamera(float fov, float nclip, float fclip, float roll);
void positionCamera(Graphics::Vector3d pos, Graphics::Vector3d interest); void positionCamera(Math::Vector3d pos, Math::Vector3d interest);
void clearScreen(); void clearScreen();
void flipBuffer(); void flipBuffer();
@ -61,7 +61,7 @@ public:
void getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2, int *y2); void getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2, int *y2);
void startActorDraw(Graphics::Vector3d pos, float scale, float yaw, float pitch, float roll); void startActorDraw(Math::Vector3d pos, float scale, float yaw, float pitch, float roll);
void finishActorDraw(); void finishActorDraw();
void setShadow(Shadow *shadow); void setShadow(Shadow *shadow);
void drawShadowPlanes(); void drawShadowPlanes();
@ -72,7 +72,7 @@ public:
void set3DMode(); void set3DMode();
void translateViewpointStart(Graphics::Vector3d pos, float pitch, float yaw, float roll); void translateViewpointStart(Math::Vector3d pos, float pitch, float yaw, float roll);
void translateViewpointFinish(); void translateViewpointFinish();
void drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2); void drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2);

16
engines/grim/gfx_tinygl.cpp
View file

@ -198,11 +198,11 @@ void GfxTinyGL::setupCamera(float fov, float nclip, float fclip, float roll) {
tglRotatef(roll, 0, 0, -1); tglRotatef(roll, 0, 0, -1);
} }
void GfxTinyGL::positionCamera(Graphics::Vector3d pos, Graphics::Vector3d interest) { void GfxTinyGL::positionCamera(Math::Vector3d pos, Math::Vector3d interest) {
Graphics::Vector3d up_vec(0, 0, 1); Math::Vector3d up_vec(0, 0, 1);
if (pos.x() == interest.x() && pos.y() == interest.y()) if (pos.x() == interest.x() && pos.y() == interest.y())
up_vec = Graphics::Vector3d(0, 1, 0); up_vec = Math::Vector3d(0, 1, 0);
lookAt(pos.x(), pos.y(), pos.z(), interest.x(), interest.y(), interest.z(), up_vec.x(), up_vec.y(), up_vec.z()); lookAt(pos.x(), pos.y(), pos.z(), interest.x(), interest.y(), interest.z(), up_vec.x(), up_vec.y(), up_vec.z());
} }
@ -221,7 +221,7 @@ bool GfxTinyGL::isHardwareAccelerated() {
return false; return false;
} }
static void tglShadowProjection(Graphics::Vector3d light, Graphics::Vector3d plane, Graphics::Vector3d normal, bool dontNegate) { static void tglShadowProjection(Math::Vector3d light, Math::Vector3d plane, Math::Vector3d normal, bool dontNegate) {
// Based on GPL shadow projection example by // Based on GPL shadow projection example by
// (c) 2002-2003 Phaetos <phaetos@gaffga.de> // (c) 2002-2003 Phaetos <phaetos@gaffga.de>
float d, c; float d, c;
@ -286,7 +286,7 @@ void GfxTinyGL::getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2,
TGLfloat winX, winY, winZ; TGLfloat winX, winY, winZ;
for (int i = 0; i < model->_numFaces; i++) { for (int i = 0; i < model->_numFaces; i++) {
Graphics::Vector3d v; Math::Vector3d v;
float* pVertices; float* pVertices;
for (int j = 0; j < model->_faces[i]._numVertices; j++) { for (int j = 0; j < model->_faces[i]._numVertices; j++) {
@ -356,7 +356,7 @@ void GfxTinyGL::getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2,
}*/ }*/
} }
void GfxTinyGL::startActorDraw(Graphics::Vector3d pos, float scale, float yaw, float pitch, float roll) { void GfxTinyGL::startActorDraw(Math::Vector3d pos, float scale, float yaw, float pitch, float roll) {
tglEnable(TGL_TEXTURE_2D); tglEnable(TGL_TEXTURE_2D);
tglMatrixMode(TGL_MODELVIEW); tglMatrixMode(TGL_MODELVIEW);
tglPushMatrix(); tglPushMatrix();
@ -516,7 +516,7 @@ void GfxTinyGL::drawSprite(const Sprite *sprite) {
tglPopMatrix(); tglPopMatrix();
} }
void GfxTinyGL::translateViewpointStart(Graphics::Vector3d pos, float pitch, float yaw, float roll) { void GfxTinyGL::translateViewpointStart(Math::Vector3d pos, float pitch, float yaw, float roll) {
tglPushMatrix(); tglPushMatrix();
tglTranslatef(pos.x(), pos.y(), pos.z()); tglTranslatef(pos.x(), pos.y(), pos.z());
@ -530,7 +530,7 @@ void GfxTinyGL::translateViewpointFinish() {
} }
void GfxTinyGL::drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2) { void GfxTinyGL::drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2) {
Graphics::Vector3d animPos = node->_pos + node->_animPos; Math::Vector3d animPos = node->_pos + node->_animPos;
float animPitch = node->_pitch + node->_animPitch; float animPitch = node->_pitch + node->_animPitch;
float animYaw = node->_yaw + node->_animYaw; float animYaw = node->_yaw + node->_animYaw;
float animRoll = node->_roll + node->_animRoll; float animRoll = node->_roll + node->_animRoll;

6
engines/grim/gfx_tinygl.h
View file

@ -43,7 +43,7 @@ public:
const char *getVideoDeviceName(); const char *getVideoDeviceName();
void setupCamera(float fov, float nclip, float fclip, float roll); void setupCamera(float fov, float nclip, float fclip, float roll);
void positionCamera(Graphics::Vector3d pos, Graphics::Vector3d interest); void positionCamera(Math::Vector3d pos, Math::Vector3d interest);
void clearScreen(); void clearScreen();
void flipBuffer(); void flipBuffer();
@ -52,7 +52,7 @@ public:
void getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2, int *y2); void getBoundingBoxPos(const Mesh *model, int *x1, int *y1, int *x2, int *y2);
void startActorDraw(Graphics::Vector3d pos, float scale, float yaw, float pitch, float roll); void startActorDraw(Math::Vector3d pos, float scale, float yaw, float pitch, float roll);
void finishActorDraw(); void finishActorDraw();
void setShadow(Shadow *shadow); void setShadow(Shadow *shadow);
void drawShadowPlanes(); void drawShadowPlanes();
@ -63,7 +63,7 @@ public:
void set3DMode(); void set3DMode();
void translateViewpointStart(Graphics::Vector3d pos, float pitch, float yaw, float roll); void translateViewpointStart(Math::Vector3d pos, float pitch, float yaw, float roll);
void translateViewpointFinish(); void translateViewpointFinish();
void drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2); void drawHierachyNode(const ModelNode *node, int *x1, int *y1, int *x2, int *y2);

10
engines/grim/keyframe.cpp
View file

@ -191,11 +191,11 @@ int KeyframeAnim::getMarker(float startTime, float stopTime) const {
void KeyframeAnim::KeyframeEntry::loadBinary(const char *&data) { void KeyframeAnim::KeyframeEntry::loadBinary(const char *&data) {
_frame = get_float(data); _frame = get_float(data);
_flags = READ_LE_UINT32(data + 4); _flags = READ_LE_UINT32(data + 4);
_pos = Graphics::get_vector3d(data + 8); _pos = Math::get_vector3d(data + 8);
_pitch = get_float(data + 20); _pitch = get_float(data + 20);
_yaw = get_float(data + 24); _yaw = get_float(data + 24);
_roll = get_float(data + 28); _roll = get_float(data + 28);
_dpos = Graphics::get_vector3d(data + 32); _dpos = Math::get_vector3d(data + 32);
_dpitch = get_float(data + 44); _dpitch = get_float(data + 44);
_dyaw = get_float(data + 48); _dyaw = get_float(data + 48);
_droll = get_float(data + 52); _droll = get_float(data + 52);
@ -228,8 +228,8 @@ void KeyframeAnim::KeyframeNode::loadText(TextSplitter &ts) {
ts.scanString(" %f %f %f %f %f %f", 6, &dx, &dy, &dz, &dp, &dyaw, &dr); ts.scanString(" %f %f %f %f %f %f", 6, &dx, &dy, &dz, &dp, &dyaw, &dr);
_entries[which]._frame = frame; _entries[which]._frame = frame;
_entries[which]._flags = (int)flags; _entries[which]._flags = (int)flags;
_entries[which]._pos = Graphics::Vector3d(x, y, z); _entries[which]._pos = Math::Vector3d(x, y, z);
_entries[which]._dpos = Graphics::Vector3d(dx, dy, dz); _entries[which]._dpos = Math::Vector3d(dx, dy, dz);
_entries[which]._pitch = p; _entries[which]._pitch = p;
_entries[which]._yaw = yaw; _entries[which]._yaw = yaw;
_entries[which]._roll = r; _entries[which]._roll = r;
@ -259,7 +259,7 @@ bool KeyframeAnim::KeyframeNode::animate(ModelNode &node, float frame, float fad
} }
float dt = frame - _entries[low]._frame; float dt = frame - _entries[low]._frame;
Graphics::Vector3d pos = _entries[low]._pos; Math::Vector3d pos = _entries[low]._pos;
float pitch = _entries[low]._pitch; float pitch = _entries[low]._pitch;
float yaw = _entries[low]._yaw; float yaw = _entries[low]._yaw;
float roll = _entries[low]._roll; float roll = _entries[low]._roll;

4
engines/grim/keyframe.h
View file

@ -23,7 +23,7 @@
#ifndef GRIM_KEYFRAME_H #ifndef GRIM_KEYFRAME_H
#define GRIM_KEYFRAME_H #define GRIM_KEYFRAME_H
#include "graphics/vector3d.h" #include "math/vector3d.h"
#include "engines/grim/object.h" #include "engines/grim/object.h"
@ -63,7 +63,7 @@ private:
float _frame; float _frame;
int _flags; int _flags;
Graphics::Vector3d _pos, _dpos; Math::Vector3d _pos, _dpos;
float _pitch, _yaw, _roll, _dpitch, _dyaw, _droll; float _pitch, _yaw, _roll, _dpitch, _dyaw, _droll;
}; };

24
engines/grim/lua_v1.cpp
View file

@ -337,8 +337,8 @@ void L1_GetAngleBetweenVectors() {
table = lua_gettable(); table = lua_gettable();
float z2 = lua_getnumber(table); float z2 = lua_getnumber(table);
Graphics::Vector3d vec1(x1, y1, z1); Math::Vector3d vec1(x1, y1, z1);
Graphics::Vector3d vec2(x2, y2, z2); Math::Vector3d vec2(x2, y2, z2);
vec1.normalize(); vec1.normalize();
vec2.normalize(); vec2.normalize();
@ -412,7 +412,7 @@ void L1_RotateVector() {
lua_Object vecObj = lua_getparam(1); lua_Object vecObj = lua_getparam(1);
lua_Object rotObj = lua_getparam(2); lua_Object rotObj = lua_getparam(2);
lua_Object resObj; lua_Object resObj;
Graphics::Vector3d vec, rot, resVec; Math::Vector3d vec, rot, resVec;
float x, y, z; float x, y, z;
if (!lua_istable(vecObj) || !lua_istable(rotObj)) { if (!lua_istable(vecObj) || !lua_istable(rotObj)) {
@ -442,7 +442,7 @@ void L1_RotateVector() {
z = lua_getnumber(lua_gettable()); z = lua_getnumber(lua_gettable());
rot.set(x, y, z); rot.set(x, y, z);
Graphics::Matrix3 mat; Math::Matrix3 mat;
mat.buildFromPitchYawRoll(x, y, z); mat.buildFromPitchYawRoll(x, y, z);
mat.transform(&vec); mat.transform(&vec);
@ -487,7 +487,7 @@ void L1_GetPointSector() {
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
Graphics::Vector3d point(x, y, z); Math::Vector3d point(x, y, z);
Sector *result = g_grim->getCurrScene()->findPointSector(point, sectorType); Sector *result = g_grim->getCurrScene()->findPointSector(point, sectorType);
if (result) { if (result) {
lua_pushnumber(result->getSectorId()); lua_pushnumber(result->getSectorId());
@ -509,7 +509,7 @@ void L1_GetActorSector() {
Actor *actor = getactor(actorObj); Actor *actor = getactor(actorObj);
Sector::SectorType sectorType = (Sector::SectorType)(int)lua_getnumber(typeObj); Sector::SectorType sectorType = (Sector::SectorType)(int)lua_getnumber(typeObj);
Graphics::Vector3d pos = actor->getPos(); Math::Vector3d pos = actor->getPos();
Sector *result = g_grim->getCurrScene()->findPointSector(pos, sectorType); Sector *result = g_grim->getCurrScene()->findPointSector(pos, sectorType);
if (result) { if (result) {
lua_pushnumber(result->getSectorId()); lua_pushnumber(result->getSectorId());
@ -563,7 +563,7 @@ void L1_IsPointInSector() {
float x = lua_getnumber(xObj); float x = lua_getnumber(xObj);
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
Graphics::Vector3d pos(x, y, z); Math::Vector3d pos(x, y, z);
int numSectors = g_grim->getCurrScene()->getSectorCount(); int numSectors = g_grim->getCurrScene()->getSectorCount();
for (int i = 0; i < numSectors; i++) { for (int i = 0; i < numSectors; i++) {
@ -601,7 +601,7 @@ void L1_GetSectorOppositeEdge() {
if (strmatch(sector->getName(), name)) { if (strmatch(sector->getName(), name)) {
if (sector->getNumVertices() != 4) if (sector->getNumVertices() != 4)
warning("GetSectorOppositeEdge(): cheat box with %d (!= 4) edges!", sector->getNumVertices()); warning("GetSectorOppositeEdge(): cheat box with %d (!= 4) edges!", sector->getNumVertices());
Graphics::Vector3d* vertices = sector->getVertices(); Math::Vector3d* vertices = sector->getVertices();
Sector::ExitInfo e; Sector::ExitInfo e;
sector->getExitInfo(actor->getPos(), -actor->getPuckVector(), &e); sector->getExitInfo(actor->getPos(), -actor->getPuckVector(), &e);
@ -609,8 +609,8 @@ void L1_GetSectorOppositeEdge() {
e.edgeVertex -= 2; e.edgeVertex -= 2;
if (e.edgeVertex < 0) if (e.edgeVertex < 0)
e.edgeVertex += sector->getNumVertices(); e.edgeVertex += sector->getNumVertices();
Graphics::Vector3d edge = vertices[e.edgeVertex + 1] - vertices[e.edgeVertex]; Math::Vector3d edge = vertices[e.edgeVertex + 1] - vertices[e.edgeVertex];
Graphics::Vector3d p = vertices[e.edgeVertex] + edge * frac; Math::Vector3d p = vertices[e.edgeVertex] + edge * frac;
lua_pushnumber(p.x()); lua_pushnumber(p.x());
lua_pushnumber(p.y()); lua_pushnumber(p.y());
lua_pushnumber(p.z()); lua_pushnumber(p.z());
@ -761,7 +761,7 @@ void L1_GetShrinkPos() {
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
float r = lua_getnumber(rObj); float r = lua_getnumber(rObj);
Graphics::Vector3d pos; Math::Vector3d pos;
pos.set(x, y, z); pos.set(x, y, z);
Sector* sector; Sector* sector;
@ -1143,7 +1143,7 @@ void L1_SetLightPosition() {
float x = lua_getnumber(xObj); float x = lua_getnumber(xObj);
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
Graphics::Vector3d vec(x, y, z); Math::Vector3d vec(x, y, z);
if (lua_isnumber(lightObj)) { if (lua_isnumber(lightObj)) {
int light = (int)lua_getnumber(lightObj); int light = (int)lua_getnumber(lightObj);

42
engines/grim/lua_v1_actor.cpp
View file

@ -316,7 +316,7 @@ void L1_PutActorAt() {
float x = lua_getnumber(xObj); float x = lua_getnumber(xObj);
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
actor->setPos(Graphics::Vector3d(x, y, z)); actor->setPos(Math::Vector3d(x, y, z));
} }
void L1_GetActorPos() { void L1_GetActorPos() {
@ -326,7 +326,7 @@ void L1_GetActorPos() {
return; return;
Actor *actor = getactor(actorObj); Actor *actor = getactor(actorObj);
Graphics::Vector3d pos = actor->getPos(); Math::Vector3d pos = actor->getPos();
lua_pushnumber(pos.x()); lua_pushnumber(pos.x());
lua_pushnumber(pos.y()); lua_pushnumber(pos.y());
lua_pushnumber(pos.z()); lua_pushnumber(pos.z());
@ -395,8 +395,8 @@ void L1_GetAngleBetweenActors() {
return; return;
} }
Graphics::Vector3d vec1 = actor1->getPuckVector(); Math::Vector3d vec1 = actor1->getPuckVector();
Graphics::Vector3d vec2 = actor2->getPos(); Math::Vector3d vec2 = actor2->getPos();
vec2 -= actor1->getPos(); vec2 -= actor1->getPos();
vec1.z() = 0; vec1.z() = 0;
vec2.z() = 0; vec2.z() = 0;
@ -439,7 +439,7 @@ void L1_GetActorYawToPoint() {
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
Graphics::Vector3d yawVector(x, y, z); Math::Vector3d yawVector(x, y, z);
lua_pushnumber(actor->getYawTo(yawVector)); lua_pushnumber(actor->getYawTo(yawVector));
} }
@ -556,7 +556,7 @@ void L1_GetActorPuckVector() {
return; return;
} }
Graphics::Vector3d result = actor->getPuckVector(); Math::Vector3d result = actor->getPuckVector();
if (!lua_isnil(addObj)) if (!lua_isnil(addObj))
result += actor->getPos(); result += actor->getPos();
@ -578,7 +578,7 @@ void L1_WalkActorTo() {
if (!lua_isuserdata(actorObj) || lua_tag(actorObj) != MKTAG('A','C','T','R')) if (!lua_isuserdata(actorObj) || lua_tag(actorObj) != MKTAG('A','C','T','R'))
return; return;
Graphics::Vector3d destVec; Math::Vector3d destVec;
Actor *actor = getactor(actorObj); Actor *actor = getactor(actorObj);
if (!lua_isnumber(xObj)) { if (!lua_isnumber(xObj)) {
if (!lua_isuserdata(xObj) || lua_tag(xObj) != MKTAG('A','C','T','R')) if (!lua_isuserdata(xObj) || lua_tag(xObj) != MKTAG('A','C','T','R'))
@ -596,7 +596,7 @@ void L1_WalkActorTo() {
float tx = lua_getnumber(txObj); float tx = lua_getnumber(txObj);
float ty = lua_getnumber(tyObj); float ty = lua_getnumber(tyObj);
float tz = lua_getnumber(tzObj); float tz = lua_getnumber(tzObj);
Graphics::Vector3d tVec(tx, ty, tz); Math::Vector3d tVec(tx, ty, tz);
actor->walkTo(destVec); actor->walkTo(destVec);
} }
@ -667,13 +667,13 @@ void L1_GetActorNodeLocation() {
root = root->_parent; root = root->_parent;
} }
Graphics::Matrix4 matrix; Math::Matrix4 matrix;
matrix.setPosition(actor->getPos()); matrix.setPosition(actor->getPos());
matrix.buildFromPitchYawRoll(actor->getPitch(), actor->getYaw(), actor->getRoll()); matrix.buildFromPitchYawRoll(actor->getPitch(), actor->getYaw(), actor->getRoll());
root->setMatrix(matrix); root->setMatrix(matrix);
root->update(); root->update();
Graphics::Vector3d pos(node->_pivotMatrix.getPosition()); Math::Vector3d pos(node->_pivotMatrix.getPosition());
lua_pushnumber(pos.x()); lua_pushnumber(pos.x());
lua_pushnumber(pos.y()); lua_pushnumber(pos.y());
lua_pushnumber(pos.z()); lua_pushnumber(pos.z());
@ -1114,7 +1114,7 @@ void L1_ActorLookAt() {
else else
fZ = 0.0f; fZ = 0.0f;
Graphics::Vector3d vector; Math::Vector3d vector;
vector.set(fX, fY, fZ); vector.set(fX, fY, fZ);
actor->setLookAtVector(vector); actor->setLookAtVector(vector);
@ -1167,8 +1167,8 @@ void L1_TurnActorTo() {
// TODO turning stuff below is not complete // TODO turning stuff below is not complete
// Find the vector pointing from the actor to the desired location // Find the vector pointing from the actor to the desired location
Graphics::Vector3d turnToVector(x, y, z); Math::Vector3d turnToVector(x, y, z);
Graphics::Vector3d lookVector = turnToVector - actor->getPos(); Math::Vector3d lookVector = turnToVector - actor->getPos();
// find the angle the requested position is around the unit circle // find the angle the requested position is around the unit circle
float yaw = lookVector.unitCircleAngle(); float yaw = lookVector.unitCircleAngle();
// yaw is offset from forward by 90 degrees // yaw is offset from forward by 90 degrees
@ -1211,8 +1211,8 @@ void L1_PointActorAt() {
// TODO turning stuff below is not complete // TODO turning stuff below is not complete
// Find the vector pointing from the actor to the desired location // Find the vector pointing from the actor to the desired location
Graphics::Vector3d turnToVector(x, y, z); Math::Vector3d turnToVector(x, y, z);
Graphics::Vector3d lookVector = turnToVector - actor->getPos(); Math::Vector3d lookVector = turnToVector - actor->getPos();
// find the angle the requested position is around the unit circle // find the angle the requested position is around the unit circle
float yaw = lookVector.unitCircleAngle(); float yaw = lookVector.unitCircleAngle();
// yaw is offset from forward by 90 degrees // yaw is offset from forward by 90 degrees
@ -1247,12 +1247,12 @@ void L1_WalkActorVector() {
moveVert = luaL_check_number(4); moveVert = luaL_check_number(4);
// Get the direction the camera is pointing // Get the direction the camera is pointing
Graphics::Vector3d cameraVector = g_grim->getCurrScene()->getCurrSetup()->_interest - g_grim->getCurrScene()->getCurrSetup()->_pos; Math::Vector3d cameraVector = g_grim->getCurrScene()->getCurrSetup()->_interest - g_grim->getCurrScene()->getCurrSetup()->_pos;
// find the angle the camera direction is around the unit circle // find the angle the camera direction is around the unit circle
float cameraYaw = cameraVector.unitCircleAngle(); float cameraYaw = cameraVector.unitCircleAngle();
// Handle the turning // Handle the turning
Graphics::Vector3d adjustVector(moveHoriz, moveVert, 0); Math::Vector3d adjustVector(moveHoriz, moveVert, 0);
// find the angle the adjust vector is around the unit circle // find the angle the adjust vector is around the unit circle
float adjustYaw = adjustVector.unitCircleAngle(); float adjustYaw = adjustVector.unitCircleAngle();
@ -1357,8 +1357,8 @@ void L1_PutActorAtInterest() {
if (!scene) if (!scene)
return; return;
Graphics::Vector3d p = scene->getCurrSetup()->_interest; Math::Vector3d p = scene->getCurrSetup()->_interest;
Graphics::Vector3d resultPt = p; Math::Vector3d resultPt = p;
float minDist = -1.f; float minDist = -1.f;
for (int i = 0; i < scene->getSectorCount(); ++i) { for (int i = 0; i < scene->getSectorCount(); ++i) {
@ -1366,7 +1366,7 @@ void L1_PutActorAtInterest() {
if (sector->getType() != Sector::WalkType || !sector->isVisible()) if (sector->getType() != Sector::WalkType || !sector->isVisible())
continue; continue;
Graphics::Vector3d closestPt = sector->getClosestPoint(p); Math::Vector3d closestPt = sector->getClosestPoint(p);
if (scene->findPointSector(closestPt, Sector::HotType)) if (scene->findPointSector(closestPt, Sector::HotType))
continue; continue;
float thisDist = (closestPt - p).magnitude(); float thisDist = (closestPt - p).magnitude();
@ -1490,7 +1490,7 @@ void L1_SetActorShadowPoint() {
float y = lua_getnumber(yObj); float y = lua_getnumber(yObj);
float z = lua_getnumber(zObj); float z = lua_getnumber(zObj);
actor->setShadowPoint(Graphics::Vector3d(x, y, z)); actor->setShadowPoint(Math::Vector3d(x, y, z));
} }
void L1_SetActorShadowPlane() { void L1_SetActorShadowPlane() {

2
engines/grim/lua_v1_sound.cpp
View file

@ -250,7 +250,7 @@ void L1_RestoreIMuse() {
} }
void L1_SetSoundPosition() { void L1_SetSoundPosition() {
Graphics::Vector3d pos; Math::Vector3d pos;
int minVolume = 10; int minVolume = 10;
int maxVolume = 127; int maxVolume = 127;
float someParam = 0; float someParam = 0;

22
engines/grim/model.cpp
View file

@ -57,7 +57,7 @@ Model::Model(const Common::String &filename, const char *data, int len, CMap *cm
loadText(&ts, cmap); loadText(&ts, cmap);
} }
Graphics::Vector3d max; Math::Vector3d max;
_rootHierNode->update(); _rootHierNode->update();
bool first = true; bool first = true;
@ -70,7 +70,7 @@ Model::Model(const Common::String &filename, const char *data, int len, CMap *cm
// bone wagon when approaching it from behind in set sg. // bone wagon when approaching it from behind in set sg.
// Using the node position looks instead more realistic, but, on the // Using the node position looks instead more realistic, but, on the
// other hand, it may not work right in all cases. // other hand, it may not work right in all cases.
Graphics::Vector3d p = node._matrix.getPosition(); Math::Vector3d p = node._matrix.getPosition();
float x = p.x(); float x = p.x();
float y = p.y(); float y = p.y();
float z = p.z(); float z = p.z();
@ -163,7 +163,7 @@ void Model::loadBinary(const char *&data, CMap *cmap) {
_rootHierNode[i].loadBinary(data, _rootHierNode, &_geosets[0]); _rootHierNode[i].loadBinary(data, _rootHierNode, &_geosets[0]);
} }
_radius = get_float(data); _radius = get_float(data);
_insertOffset = Graphics::get_vector3d(data + 40); _insertOffset = Math::get_vector3d(data + 40);
} }
void Model::loadText(TextSplitter *ts, CMap *cmap) { void Model::loadText(TextSplitter *ts, CMap *cmap) {
@ -231,11 +231,11 @@ void Model::loadText(TextSplitter *ts, CMap *cmap) {
_rootHierNode[num]._sibling = NULL; _rootHierNode[num]._sibling = NULL;
_rootHierNode[num]._numChildren = numChildren; _rootHierNode[num]._numChildren = numChildren;
_rootHierNode[num]._pos = Graphics::Vector3d(x, y, z); _rootHierNode[num]._pos = Math::Vector3d(x, y, z);
_rootHierNode[num]._pitch = pitch; _rootHierNode[num]._pitch = pitch;
_rootHierNode[num]._yaw = yaw; _rootHierNode[num]._yaw = yaw;
_rootHierNode[num]._roll = roll; _rootHierNode[num]._roll = roll;
_rootHierNode[num]._pivot = Graphics::Vector3d(pivotx, pivoty, pivotz); _rootHierNode[num]._pivot = Math::Vector3d(pivotx, pivoty, pivotz);
_rootHierNode[num]._meshVisible = true; _rootHierNode[num]._meshVisible = true;
_rootHierNode[num]._hierVisible = true; _rootHierNode[num]._hierVisible = true;
_rootHierNode[num]._sprite = NULL; _rootHierNode[num]._sprite = NULL;
@ -358,7 +358,7 @@ int MeshFace::loadBinary(const char *&data, Material *materials[]) {
int texPtr = READ_LE_UINT32(data + 28); int texPtr = READ_LE_UINT32(data + 28);
int materialPtr = READ_LE_UINT32(data + 32); int materialPtr = READ_LE_UINT32(data + 32);
_extraLight = get_float(data + 48); _extraLight = get_float(data + 48);
_normal = Graphics::get_vector3d(data + 64); _normal = Math::get_vector3d(data + 64);
data += 76; data += 76;
_vertices = new int[_numVertices]; _vertices = new int[_numVertices];
@ -536,7 +536,7 @@ void Mesh::loadText(TextSplitter *ts, Material* materials[]) {
int num; int num;
float x, y, z; float x, y, z;
ts->scanString(" %d: %f %f %f", 4, &num, &x, &y, &z); ts->scanString(" %d: %f %f %f", 4, &num, &x, &y, &z);
_faces[num]._normal = Graphics::Vector3d(x, y, z); _faces[num]._normal = Math::Vector3d(x, y, z);
} }
} }
@ -595,8 +595,8 @@ void ModelNode::loadBinary(const char *&data, ModelNode *hierNodes, const Model:
_numChildren = READ_LE_UINT32(data + 88); _numChildren = READ_LE_UINT32(data + 88);
int childPtr = READ_LE_UINT32(data + 92); int childPtr = READ_LE_UINT32(data + 92);
int siblingPtr = READ_LE_UINT32(data + 96); int siblingPtr = READ_LE_UINT32(data + 96);
_pivot = Graphics::get_vector3d(data + 100); _pivot = Math::get_vector3d(data + 100);
_pos = Graphics::get_vector3d(data + 112); _pos = Math::get_vector3d(data + 112);
_pitch = get_float(data + 124); _pitch = get_float(data + 124);
_yaw = get_float(data + 128); _yaw = get_float(data + 128);
_roll = get_float(data + 132); _roll = get_float(data + 132);
@ -651,7 +651,7 @@ void ModelNode::removeChild(ModelNode *child) {
} }
} }
void ModelNode::setMatrix(Graphics::Matrix4 matrix) { void ModelNode::setMatrix(Math::Matrix4 matrix) {
_matrix = matrix; _matrix = matrix;
} }
@ -659,7 +659,7 @@ void ModelNode::update() {
if (!_initialized) if (!_initialized)
return; return;
Graphics::Vector3d animPos = _pos + _animPos; Math::Vector3d animPos = _pos + _animPos;
float animPitch = _pitch + _animPitch; float animPitch = _pitch + _animPitch;
float animYaw = _yaw + _animYaw; float animYaw = _yaw + _animYaw;
float animRoll = _roll + _animRoll; float animRoll = _roll + _animRoll;

26
engines/grim/model.h
View file

@ -25,7 +25,7 @@
#include "common/memstream.h" #include "common/memstream.h"
#include "engines/grim/object.h" #include "engines/grim/object.h"
#include "graphics/matrix4.h" #include "math/matrix4.h"
namespace Grim { namespace Grim {
@ -38,7 +38,7 @@ class CMap;
struct Sprite { struct Sprite {
void draw() const; void draw() const;
Graphics::Vector3d _pos; Math::Vector3d _pos;
float _width; float _width;
float _height; float _height;
bool _visible; bool _visible;
@ -84,14 +84,14 @@ public:
char (*_materialNames)[32]; char (*_materialNames)[32];
Material **_materials; Material **_materials;
bool *_materialsShared; bool *_materialsShared;
Graphics::Vector3d _insertOffset; Math::Vector3d _insertOffset;
int _numGeosets; int _numGeosets;
Geoset *_geosets; Geoset *_geosets;
float _radius; float _radius;
int _numHierNodes; int _numHierNodes;
ModelNode *_rootHierNode; ModelNode *_rootHierNode;
Graphics::Vector3d _bboxPos; Math::Vector3d _bboxPos;
Graphics::Vector3d _bboxSize; Math::Vector3d _bboxSize;
}; };
class MeshFace { class MeshFace {
@ -106,7 +106,7 @@ public:
float _extraLight; float _extraLight;
int _numVertices; int _numVertices;
int *_vertices, *_texVertices; int *_vertices, *_texVertices;
Graphics::Vector3d _normal; Math::Vector3d _normal;
}; };
class Mesh { class Mesh {
@ -134,7 +134,7 @@ public:
int _numFaces; int _numFaces;
MeshFace *_faces; MeshFace *_faces;
Graphics::Matrix4 _matrix; Math::Matrix4 _matrix;
}; };
class ModelNode { class ModelNode {
@ -145,7 +145,7 @@ public:
void draw(int *x1, int *y1, int *x2, int *y2) const; void draw(int *x1, int *y1, int *x2, int *y2) const;
void addChild(ModelNode *child); void addChild(ModelNode *child);
void removeChild(ModelNode *child); void removeChild(ModelNode *child);
void setMatrix(Graphics::Matrix4 matrix); void setMatrix(Math::Matrix4 matrix);
void update(); void update();
void addSprite(Sprite *sprite); void addSprite(Sprite *sprite);
void removeSprite(Sprite *sprite); void removeSprite(Sprite *sprite);
@ -155,15 +155,15 @@ public:
int _flags, _type; int _flags, _type;
int _depth, _numChildren; int _depth, _numChildren;
ModelNode *_parent, *_child, *_sibling; ModelNode *_parent, *_child, *_sibling;
Graphics::Vector3d _pos, _pivot; Math::Vector3d _pos, _pivot;
float _pitch, _yaw, _roll; float _pitch, _yaw, _roll;
Graphics::Vector3d _animPos; Math::Vector3d _animPos;
float _animPitch, _animYaw, _animRoll; float _animPitch, _animYaw, _animRoll;
bool _meshVisible, _hierVisible; bool _meshVisible, _hierVisible;
bool _initialized; bool _initialized;
Graphics::Matrix4 _matrix; Math::Matrix4 _matrix;
Graphics::Matrix4 _localMatrix; Math::Matrix4 _localMatrix;
Graphics::Matrix4 _pivotMatrix; Math::Matrix4 _pivotMatrix;
Sprite* _sprite; Sprite* _sprite;
}; };

8
engines/grim/savegame.cpp
View file

@ -23,7 +23,7 @@
#include "common/endian.h" #include "common/endian.h"
#include "common/system.h" #include "common/system.h"
#include "graphics/vector3d.h" #include "math/vector3d.h"
#include "engines/grim/savegame.h" #include "engines/grim/savegame.h"
#include "engines/grim/color.h" #include "engines/grim/color.h"
@ -286,7 +286,7 @@ void SaveGame::writeByte(byte data) {
_sectionSize++; _sectionSize++;
} }
void SaveGame::writeVector3d(const Graphics::Vector3d &vec) { void SaveGame::writeVector3d(const Math::Vector3d &vec) {
writeFloat(vec.x()); writeFloat(vec.x());
writeFloat(vec.y()); writeFloat(vec.y());
writeFloat(vec.z()); writeFloat(vec.z());
@ -310,11 +310,11 @@ void SaveGame::writeString(const Common::String &string) {
write(string.c_str(), len); write(string.c_str(), len);
} }
Graphics::Vector3d SaveGame::readVector3d() { Math::Vector3d SaveGame::readVector3d() {
float x = readFloat(); float x = readFloat();
float y = readFloat(); float y = readFloat();
float z = readFloat(); float z = readFloat();
return Graphics::Vector3d(x, y, z); return Math::Vector3d(x, y, z);
} }
Grim::Color SaveGame::readColor() { Grim::Color SaveGame::readColor() {

6
engines/grim/savegame.h
View file

@ -25,7 +25,7 @@
#include "common/savefile.h" #include "common/savefile.h"
namespace Graphics { namespace Math {
class Vector3d; class Vector3d;
} }
@ -59,10 +59,10 @@ public:
void writeByte(byte data); void writeByte(byte data);
void writeString(const Common::String &string); void writeString(const Common::String &string);
void writeVector3d(const Graphics::Vector3d &vec); void writeVector3d(const Math::Vector3d &vec);
void writeColor(const Grim::Color &color); void writeColor(const Grim::Color &color);
void writeFloat(float data); void writeFloat(float data);
Graphics::Vector3d readVector3d(); Math::Vector3d readVector3d();
Grim::Color readColor(); Grim::Color readColor();
float readFloat(); float readFloat();
Common::String readString(); Common::String readString();

34
engines/grim/scene.cpp
View file

@ -523,7 +523,7 @@ void Scene::drawBitmaps(ObjectState::Position stage) {
} }
} }
Sector *Scene::findPointSector(const Graphics::Vector3d &p, Sector::SectorType type) { Sector *Scene::findPointSector(const Math::Vector3d &p, Sector::SectorType type) {
for (int i = 0; i < _numSectors; i++) { for (int i = 0; i < _numSectors; i++) {
Sector *sector = _sectors[i]; Sector *sector = _sectors[i];
if (sector && (sector->getType() & type) && sector->isVisible() && sector->isPointInSector(p)) if (sector && (sector->getType() & type) && sector->isVisible() && sector->isPointInSector(p))
@ -532,16 +532,16 @@ Sector *Scene::findPointSector(const Graphics::Vector3d &p, Sector::SectorType t
return NULL; return NULL;
} }
void Scene::findClosestSector(const Graphics::Vector3d &p, Sector **sect, Graphics::Vector3d *closestPoint) { void Scene::findClosestSector(const Math::Vector3d &p, Sector **sect, Math::Vector3d *closestPoint) {
Sector *resultSect = NULL; Sector *resultSect = NULL;
Graphics::Vector3d resultPt = p; Math::Vector3d resultPt = p;
float minDist = 0.0; float minDist = 0.0;
for (int i = 0; i < _numSectors; i++) { for (int i = 0; i < _numSectors; i++) {
Sector *sector = _sectors[i]; Sector *sector = _sectors[i];
if ((sector->getType() & Sector::WalkType) == 0 || !sector->isVisible()) if ((sector->getType() & Sector::WalkType) == 0 || !sector->isVisible())
continue; continue;
Graphics::Vector3d closestPt = sector->getClosestPoint(p); Math::Vector3d closestPt = sector->getClosestPoint(p);
float thisDist = (closestPt - p).magnitude(); float thisDist = (closestPt - p).magnitude();
if (!resultSect || thisDist < minDist) { if (!resultSect || thisDist < minDist) {
resultSect = sector; resultSect = sector;
@ -625,7 +625,7 @@ void Scene::setLightEnabled(int light, bool enabled) {
_lightsConfigured = false; _lightsConfigured = false;
} }
void Scene::setLightPosition(const char *light, const Graphics::Vector3d &pos) { void Scene::setLightPosition(const char *light, const Math::Vector3d &pos) {
for (int i = 0; i < _numLights; ++i) { for (int i = 0; i < _numLights; ++i) {
Light &l = _lights[i]; Light &l = _lights[i];
if (l._name == light) { if (l._name == light) {
@ -636,20 +636,20 @@ void Scene::setLightPosition(const char *light, const Graphics::Vector3d &pos) {
} }
} }
void Scene::setLightPosition(int light, const Graphics::Vector3d &pos) { void Scene::setLightPosition(int light, const Math::Vector3d &pos) {
Light &l = _lights[light]; Light &l = _lights[light];
l._pos = pos; l._pos = pos;
_lightsConfigured = false; _lightsConfigured = false;
} }
void Scene::setSoundPosition(const char *soundName, Graphics::Vector3d pos) { void Scene::setSoundPosition(const char *soundName, Math::Vector3d pos) {
setSoundPosition(soundName, pos, _minVolume, _maxVolume); setSoundPosition(soundName, pos, _minVolume, _maxVolume);
} }
void Scene::setSoundPosition(const char *soundName, Graphics::Vector3d pos, int minVol, int maxVol) { void Scene::setSoundPosition(const char *soundName, Math::Vector3d pos, int minVol, int maxVol) {
// TODO: The volume and pan needs to be updated when the setup changes. // TODO: The volume and pan needs to be updated when the setup changes.
Graphics::Vector3d cameraPos = _currSetup->_pos; Math::Vector3d cameraPos = _currSetup->_pos;
Graphics::Vector3d vector = pos - cameraPos; Math::Vector3d vector = pos - cameraPos;
float distance = vector.magnitude(); float distance = vector.magnitude();
float diffVolume = maxVol - minVol; float diffVolume = maxVol - minVol;
//This 8.f is a guess, so it may need some adjusting //This 8.f is a guess, so it may need some adjusting
@ -659,18 +659,18 @@ void Scene::setSoundPosition(const char *soundName, Graphics::Vector3d pos, int
newVolume = _maxVolume; newVolume = _maxVolume;
g_imuse->setVolume(soundName, newVolume); g_imuse->setVolume(soundName, newVolume);
Graphics::Vector3d cameraVector =_currSetup->_interest - _currSetup->_pos; Math::Vector3d cameraVector =_currSetup->_interest - _currSetup->_pos;
Graphics::Vector3d up(0,0,1); Math::Vector3d up(0,0,1);
Graphics::Vector3d right; Math::Vector3d right;
cameraVector.normalize(); cameraVector.normalize();
float roll = -_currSetup->_roll * LOCAL_PI / 180.f; float roll = -_currSetup->_roll * LOCAL_PI / 180.f;
float cosr = cos(roll); float cosr = cos(roll);
// Rotate the up vector by roll. // Rotate the up vector by roll.
up = up * cosr + Graphics::cross(cameraVector, up) * sin(roll) + up = up * cosr + Math::cross(cameraVector, up) * sin(roll) +
cameraVector * Graphics::dot(cameraVector, up) * (1 - cosr); cameraVector * Math::dot(cameraVector, up) * (1 - cosr);
right = Graphics::cross(cameraVector, up); right = Math::cross(cameraVector, up);
right.normalize(); right.normalize();
float angle = atan2(Graphics::dot(vector, right), Graphics::dot(vector, cameraVector)); float angle = atan2(Math::dot(vector, right), Math::dot(vector, cameraVector));
float pan = sin(angle); float pan = sin(angle);
g_imuse->setPan(soundName, (int)((pan + 1.f) / 2.f * 127.f + 0.5f)); g_imuse->setPan(soundName, (int)((pan + 1.f) / 2.f * 127.f + 0.5f));
} }

16
engines/grim/scene.h
View file

@ -61,8 +61,8 @@ public:
void setupLights(); void setupLights();
void setSoundPosition(const char *soundName, Graphics::Vector3d pos); void setSoundPosition(const char *soundName, Math::Vector3d pos);
void setSoundPosition(const char *soundName, Graphics::Vector3d pos, int minVol, int maxVol); void setSoundPosition(const char *soundName, Math::Vector3d pos, int minVol, int maxVol);
void setSoundParameters(int minVolume, int maxVolume); void setSoundParameters(int minVolume, int maxVolume);
void getSoundParameters(int *minVolume, int *maxVolume); void getSoundParameters(int *minVolume, int *maxVolume);
@ -75,8 +75,8 @@ public:
void setLightsDirty(); void setLightsDirty();
void setLightIntensity(const char *light, float intensity); void setLightIntensity(const char *light, float intensity);
void setLightIntensity(int light, float intensity); void setLightIntensity(int light, float intensity);
void setLightPosition(const char *light, const Graphics::Vector3d &pos); void setLightPosition(const char *light, const Math::Vector3d &pos);
void setLightPosition(int light, const Graphics::Vector3d &pos); void setLightPosition(int light, const Math::Vector3d &pos);
void setLightEnabled(const char *light, bool enabled); void setLightEnabled(const char *light, bool enabled);
void setLightEnabled(int light, bool enabled); void setLightEnabled(int light, bool enabled);
@ -88,8 +88,8 @@ public:
Sector *getSectorBase(int id); Sector *getSectorBase(int id);
Sector *findPointSector(const Graphics::Vector3d &p, Sector::SectorType type); Sector *findPointSector(const Math::Vector3d &p, Sector::SectorType type);
void findClosestSector(const Graphics::Vector3d &p, Sector **sect, Graphics::Vector3d *closestPt); void findClosestSector(const Math::Vector3d &p, Sector **sect, Math::Vector3d *closestPt);
void shrinkBoxes(float radius); void shrinkBoxes(float radius);
void unshrinkBoxes(); void unshrinkBoxes();
@ -109,7 +109,7 @@ public:
void setupCamera() const; void setupCamera() const;
Common::String _name; Common::String _name;
Bitmap *_bkgndBm, *_bkgndZBm; Bitmap *_bkgndBm, *_bkgndZBm;
Graphics::Vector3d _pos, _interest; Math::Vector3d _pos, _interest;
float _roll, _fov, _nclip, _fclip; float _roll, _fov, _nclip, _fclip;
}; };
@ -149,7 +149,7 @@ public:
void loadBinary(Common::MemoryReadStream *ms); void loadBinary(Common::MemoryReadStream *ms);
Common::String _name; Common::String _name;
Common::String _type; Common::String _type;
Graphics::Vector3d _pos, _dir; Math::Vector3d _pos, _dir;
Color _color; Color _color;
float _intensity, _umbraangle, _penumbraangle; float _intensity, _umbraangle, _penumbraangle;
bool _enabled; bool _enabled;

84
engines/grim/sector.cpp
View file

@ -77,7 +77,7 @@ bool Sector::restoreState(SaveGame *savedState) {
_name = savedState->readString(); _name = savedState->readString();
_vertices = new Graphics::Vector3d[_numVertices + 1]; _vertices = new Math::Vector3d[_numVertices + 1];
for (int i = 0; i < _numVertices + 1; ++i) { for (int i = 0; i < _numVertices + 1; ++i) {
_vertices[i] = savedState->readVector3d(); _vertices[i] = savedState->readVector3d();
} }
@ -87,7 +87,7 @@ bool Sector::restoreState(SaveGame *savedState) {
_shrinkRadius = savedState->readFloat(); _shrinkRadius = savedState->readFloat();
_invalid = savedState->readLESint32(); _invalid = savedState->readLESint32();
if (_shrinkRadius != 0.f && !_invalid) { if (_shrinkRadius != 0.f && !_invalid) {
_origVertices = new Graphics::Vector3d[_numVertices + 1]; _origVertices = new Math::Vector3d[_numVertices + 1];
for (int i = 0; i < _numVertices + 1; ++i) { for (int i = 0; i < _numVertices + 1; ++i) {
_origVertices[i] = savedState->readVector3d(); _origVertices[i] = savedState->readVector3d();
} }
@ -101,7 +101,7 @@ bool Sector::restoreState(SaveGame *savedState) {
void Sector::load(TextSplitter &ts) { void Sector::load(TextSplitter &ts) {
char buf[256]; char buf[256];
int ident = 0, i = 0; int ident = 0, i = 0;
Graphics::Vector3d tempVert; Math::Vector3d tempVert;
// Sector NAMES can be null, but ts isn't flexible enough // Sector NAMES can be null, but ts isn't flexible enough
if (strlen(ts.getCurrentLine()) > strlen(" sector")) if (strlen(ts.getCurrentLine()) > strlen(" sector"))
@ -140,7 +140,7 @@ void Sector::load(TextSplitter &ts) {
error("Invalid visibility spec: %s", buf); error("Invalid visibility spec: %s", buf);
ts.scanString(" height %f", 1, &_height); ts.scanString(" height %f", 1, &_height);
ts.scanString(" numvertices %d", 1, &_numVertices); ts.scanString(" numvertices %d", 1, &_numVertices);
_vertices = new Graphics::Vector3d[_numVertices + 1]; _vertices = new Math::Vector3d[_numVertices + 1];
ts.scanString(" vertices: %f %f %f", 3, &_vertices[0].x(), &_vertices[0].y(), &_vertices[0].z()); ts.scanString(" vertices: %f %f %f", 3, &_vertices[0].x(), &_vertices[0].y(), &_vertices[0].z());
for (i = 1; i < _numVertices; i++) for (i = 1; i < _numVertices; i++)
@ -157,7 +157,7 @@ void Sector::load(TextSplitter &ts) {
void Sector::loadBinary(Common::MemoryReadStream *ms) { void Sector::loadBinary(Common::MemoryReadStream *ms) {
_numVertices = ms->readUint32LE(); _numVertices = ms->readUint32LE();
_vertices = new Graphics::Vector3d[_numVertices]; _vertices = new Math::Vector3d[_numVertices];
for(int i = 0; i < _numVertices; i++) { for(int i = 0; i < _numVertices; i++) {
ms->read(_vertices[i]._coords, 12); ms->read(_vertices[i]._coords, 12);
} }
@ -191,12 +191,12 @@ void Sector::shrink(float radius) {
_shrinkRadius = radius; _shrinkRadius = radius;
if (!_origVertices) { if (!_origVertices) {
_origVertices = _vertices; _origVertices = _vertices;
_vertices = new Graphics::Vector3d[_numVertices + 1]; _vertices = new Math::Vector3d[_numVertices + 1];
} }
// Move each vertex inwards by the given amount. // Move each vertex inwards by the given amount.
for (int j = 0; j < _numVertices; j++) { for (int j = 0; j < _numVertices; j++) {
Graphics::Vector3d shrinkDir; Math::Vector3d shrinkDir;
for (int k = 0; k < g_grim->getCurrScene()->getSectorCount(); k++) { for (int k = 0; k < g_grim->getCurrScene()->getSectorCount(); k++) {
Sector *other = g_grim->getCurrScene()->getSectorBase(k); Sector *other = g_grim->getCurrScene()->getSectorBase(k);
@ -204,19 +204,19 @@ void Sector::shrink(float radius) {
continue; continue;
for (int l = 0; l < other->_numVertices; l++) { for (int l = 0; l < other->_numVertices; l++) {
Graphics::Vector3d* otherVerts = other->_vertices; Math::Vector3d* otherVerts = other->_vertices;
if (other->_origVertices) if (other->_origVertices)
otherVerts = other->_origVertices; otherVerts = other->_origVertices;
if ((otherVerts[l] - _origVertices[j]).magnitude() < 0.01f) { if ((otherVerts[l] - _origVertices[j]).magnitude() < 0.01f) {
Graphics::Vector3d e1 = otherVerts[l + 1] - otherVerts[l]; Math::Vector3d e1 = otherVerts[l + 1] - otherVerts[l];
Graphics::Vector3d e2; Math::Vector3d e2;
if (l - 1 >= 0) if (l - 1 >= 0)
e2 = otherVerts[l] - otherVerts[l - 1]; e2 = otherVerts[l] - otherVerts[l - 1];
else else
e2 = otherVerts[l] - otherVerts[other->_numVertices - 1]; e2 = otherVerts[l] - otherVerts[other->_numVertices - 1];
e1.normalize(); e1.normalize();
e2.normalize(); e2.normalize();
Graphics::Vector3d bisector = (e1 - e2); Math::Vector3d bisector = (e1 - e2);
bisector.normalize(); bisector.normalize();
shrinkDir += bisector; shrinkDir += bisector;
} }
@ -235,8 +235,8 @@ void Sector::shrink(float radius) {
// Make sure the sector is still convex. // Make sure the sector is still convex.
for (int j = 0; j < _numVertices; j++) { for (int j = 0; j < _numVertices; j++) {
Graphics::Vector3d e1 = _vertices[j + 1] - _vertices[j]; Math::Vector3d e1 = _vertices[j + 1] - _vertices[j];
Graphics::Vector3d e2; Math::Vector3d e2;
if (j - 1 >= 0) if (j - 1 >= 0)
e2 = _vertices[j] - _vertices[j - 1]; e2 = _vertices[j] - _vertices[j - 1];
else else
@ -265,7 +265,7 @@ void Sector::unshrink() {
} }
} }
bool Sector::isPointInSector(const Graphics::Vector3d &point) const { bool Sector::isPointInSector(const Math::Vector3d &point) const {
// The algorithm: for each edge A->B, check whether the z-component // The algorithm: for each edge A->B, check whether the z-component
// of (B-A) x (P-A) is >= 0. Then the point is at least in the // of (B-A) x (P-A) is >= 0. Then the point is at least in the
// cylinder above&below the polygon. (This works because the polygons' // cylinder above&below the polygon. (This works because the polygons'
@ -306,15 +306,15 @@ bool Sector::isPointInSector(const Graphics::Vector3d &point) const {
} }
for (int i = 0; i < _numVertices; i++) { for (int i = 0; i < _numVertices; i++) {
Graphics::Vector3d edge = _vertices[i + 1] - _vertices[i]; Math::Vector3d edge = _vertices[i + 1] - _vertices[i];
Graphics::Vector3d delta = point - _vertices[i]; Math::Vector3d delta = point - _vertices[i];
if (edge.x() * delta.y() < edge.y() * delta.x()) if (edge.x() * delta.y() < edge.y() * delta.x())
return false; return false;
} }
return true; return true;
} }
Common::List<Graphics::Line3d> Sector::getBridgesTo(Sector *sector) const { Common::List<Math::Line3d> Sector::getBridgesTo(Sector *sector) const {
// This returns a list of "bridges", which are edges that can be travelled // This returns a list of "bridges", which are edges that can be travelled
// through to get to another sector. 0 bridges mean the sectors aren't // through to get to another sector. 0 bridges mean the sectors aren't
// connected. // connected.
@ -324,20 +324,20 @@ Common::List<Graphics::Line3d> Sector::getBridgesTo(Sector *sector) const {
// sector B, so we end up with a list of lines which are at the border // sector B, so we end up with a list of lines which are at the border
// of sector A and inside sector B. // of sector A and inside sector B.
Common::List<Graphics::Line3d> bridges; Common::List<Math::Line3d> bridges;
Common::List<Graphics::Line3d>::iterator it; Common::List<Math::Line3d>::iterator it;
for (int i = 0; i < _numVertices; i++){ for (int i = 0; i < _numVertices; i++){
bridges.push_back(Graphics::Line3d(_vertices[i], _vertices[i+1])); bridges.push_back(Math::Line3d(_vertices[i], _vertices[i+1]));
} }
Graphics::Vector3d* sectorVertices = sector->getVertices(); Math::Vector3d* sectorVertices = sector->getVertices();
for (int i = 0; i < sector->getNumVertices(); i++) { for (int i = 0; i < sector->getNumVertices(); i++) {
Graphics::Vector3d pos, edge, delta_b1, delta_b2; Math::Vector3d pos, edge, delta_b1, delta_b2;
Graphics::Line3d line(sectorVertices[i], sectorVertices[i+1]); Math::Line3d line(sectorVertices[i], sectorVertices[i+1]);
it = bridges.begin(); it = bridges.begin();
while (it != bridges.end()) { while (it != bridges.end()) {
Graphics::Line3d& bridge = (*it); Math::Line3d& bridge = (*it);
edge = line.end() - line.begin(); edge = line.end() - line.begin();
delta_b1 = bridge.begin() - line.begin(); delta_b1 = bridge.begin() - line.begin();
delta_b2 = bridge.end() - line.begin(); delta_b2 = bridge.end() - line.begin();
@ -350,11 +350,11 @@ Common::List<Graphics::Line3d> Sector::getBridgesTo(Sector *sector) const {
continue; continue;
} else if (b1_out) { } else if (b1_out) {
if (bridge.intersectLine2d(line, &pos)) { if (bridge.intersectLine2d(line, &pos)) {
bridge = Graphics::Line3d(pos, bridge.end()); bridge = Math::Line3d(pos, bridge.end());
} }
} else if (b2_out) { } else if (b2_out) {
if (bridge.intersectLine2d(line, &pos)) { if (bridge.intersectLine2d(line, &pos)) {
bridge = Graphics::Line3d(bridge.begin(), pos); bridge = Math::Line3d(bridge.begin(), pos);
} }
} }
@ -378,37 +378,37 @@ Common::List<Graphics::Line3d> Sector::getBridgesTo(Sector *sector) const {
return bridges; return bridges;
} }
Graphics::Vector3d Sector::getProjectionToPlane(const Graphics::Vector3d &point) const { Math::Vector3d Sector::getProjectionToPlane(const Math::Vector3d &point) const {
if (_normal.z() == 0) if (_normal.z() == 0)
error("Trying to walk along vertical plane"); error("Trying to walk along vertical plane");
// Formula: return p - (n . (p - v_0))/(n . k) k // Formula: return p - (n . (p - v_0))/(n . k) k
Graphics::Vector3d result = point; Math::Vector3d result = point;
result.z() -= dot(_normal, point - _vertices[0]) / _normal.z(); result.z() -= dot(_normal, point - _vertices[0]) / _normal.z();
return result; return result;
} }
Graphics::Vector3d Sector::getProjectionToPuckVector(const Graphics::Vector3d &v) const { Math::Vector3d Sector::getProjectionToPuckVector(const Math::Vector3d &v) const {
if (_normal.z() == 0) if (_normal.z() == 0)
error("Trying to walk along vertical plane"); error("Trying to walk along vertical plane");
Graphics::Vector3d result = v; Math::Vector3d result = v;
result.z() -= dot(_normal, v) / _normal.z(); result.z() -= dot(_normal, v) / _normal.z();
return result; return result;
} }
// Find the closest point on the walkplane to the given point // Find the closest point on the walkplane to the given point
Graphics::Vector3d Sector::getClosestPoint(const Graphics::Vector3d &point) const { Math::Vector3d Sector::getClosestPoint(const Math::Vector3d &point) const {
// First try to project to the plane // First try to project to the plane
Graphics::Vector3d p2 = point; Math::Vector3d p2 = point;
p2 -= (dot(_normal, p2 - _vertices[0])) * _normal; p2 -= (dot(_normal, p2 - _vertices[0])) * _normal;
if (isPointInSector(p2)) if (isPointInSector(p2))
return p2; return p2;
// Now try to project to some edge // Now try to project to some edge
for (int i = 0; i < _numVertices; i++) { for (int i = 0; i < _numVertices; i++) {
Graphics::Vector3d edge = _vertices[i + 1] - _vertices[i]; Math::Vector3d edge = _vertices[i + 1] - _vertices[i];
Graphics::Vector3d delta = point - _vertices[i]; Math::Vector3d delta = point - _vertices[i];
float scalar = dot(delta, edge) / dot(edge, edge); float scalar = dot(delta, edge) / dot(edge, edge);
if (scalar >= 0 && scalar <= 1 && delta.x() * edge.y() > delta.y() * edge.x()) if (scalar >= 0 && scalar <= 1 && delta.x() * edge.y() > delta.y() * edge.x())
// That last test is just whether the z-component // That last test is just whether the z-component
@ -430,9 +430,9 @@ Graphics::Vector3d Sector::getClosestPoint(const Graphics::Vector3d &point) cons
return _vertices[index]; return _vertices[index];
} }
void Sector::getExitInfo(const Graphics::Vector3d &s, const Graphics::Vector3d &dirVec, struct ExitInfo *result) const { void Sector::getExitInfo(const Math::Vector3d &s, const Math::Vector3d &dirVec, struct ExitInfo *result) const {
Graphics::Vector3d start = getProjectionToPlane(s); Math::Vector3d start = getProjectionToPlane(s);
Graphics::Vector3d dir = getProjectionToPuckVector(dirVec); Math::Vector3d dir = getProjectionToPuckVector(dirVec);
// First find the edge the ray exits through: this is where // First find the edge the ray exits through: this is where
// the z-component of (v_i - start) x dir changes sign from // the z-component of (v_i - start) x dir changes sign from
@ -442,7 +442,7 @@ void Sector::getExitInfo(const Graphics::Vector3d &s, const Graphics::Vector3d &
// positive z-component. // positive z-component.
int i; int i;
for (i = 0; i < _numVertices; i++) { for (i = 0; i < _numVertices; i++) {
Graphics::Vector3d delta = _vertices[i] - start; Math::Vector3d delta = _vertices[i] - start;
if (delta.x() * dir.y() > delta.y() * dir.x()) if (delta.x() * dir.y() > delta.y() * dir.x())
break; break;
} }
@ -451,7 +451,7 @@ void Sector::getExitInfo(const Graphics::Vector3d &s, const Graphics::Vector3d &
// z-component. // z-component.
while (i < _numVertices) { while (i < _numVertices) {
i++; i++;
Graphics::Vector3d delta = _vertices[i] - start; Math::Vector3d delta = _vertices[i] - start;
if (delta.x() * dir.y() <= delta.y() * dir.x()) if (delta.x() * dir.y() <= delta.y() * dir.x())
break; break;
} }
@ -460,7 +460,7 @@ void Sector::getExitInfo(const Graphics::Vector3d &s, const Graphics::Vector3d &
result->angleWithEdge = angle(dir, result->edgeDir); result->angleWithEdge = angle(dir, result->edgeDir);
result->edgeVertex = i - 1; result->edgeVertex = i - 1;
Graphics::Vector3d edgeNormal(result->edgeDir.y(), -result->edgeDir.x(), 0); Math::Vector3d edgeNormal(result->edgeDir.y(), -result->edgeDir.x(), 0);
float d = dot(dir, edgeNormal); float d = dot(dir, edgeNormal);
// This is 0 for the albinizod monster in the at set // This is 0 for the albinizod monster in the at set
if (!d) if (!d)
@ -474,12 +474,12 @@ Sector &Sector::operator=(const Sector &other) {
_name = other._name; _name = other._name;
_type = other._type; _type = other._type;
_visible = other._visible; _visible = other._visible;
_vertices = new Graphics::Vector3d[_numVertices + 1]; _vertices = new Math::Vector3d[_numVertices + 1];
for (int i = 0; i < _numVertices + 1; ++i) { for (int i = 0; i < _numVertices + 1; ++i) {
_vertices[i] = other._vertices[i]; _vertices[i] = other._vertices[i];
} }
if (other._origVertices) { if (other._origVertices) {
_origVertices = new Graphics::Vector3d[_numVertices + 1]; _origVertices = new Math::Vector3d[_numVertices + 1];
for (int i = 0; i < _numVertices + 1; ++i) { for (int i = 0; i < _numVertices + 1; ++i) {
_origVertices[i] = other._origVertices[i]; _origVertices[i] = other._origVertices[i];
} }

30
engines/grim/sector.h
View file

@ -26,8 +26,8 @@
#include "common/str.h" #include "common/str.h"
#include "common/list.h" #include "common/list.h"
#include "graphics/vector3d.h" #include "math/vector3d.h"
#include "graphics/line3d.h" #include "math/line3d.h"
namespace Common { namespace Common {
class MemoryReadStream; class MemoryReadStream;
@ -66,26 +66,26 @@ public:
int getSectorId() const { return _id; } int getSectorId() const { return _id; }
SectorType getType() const { return _type; } // FIXME: Implement type de-masking SectorType getType() const { return _type; } // FIXME: Implement type de-masking
bool isVisible() const { return _visible && !_invalid; } bool isVisible() const { return _visible && !_invalid; }
bool isPointInSector(const Graphics::Vector3d &point) const; bool isPointInSector(const Math::Vector3d &point) const;
Common::List<Graphics::Line3d> getBridgesTo(Sector *sector) const; Common::List<Math::Line3d> getBridgesTo(Sector *sector) const;
Graphics::Vector3d getProjectionToPlane(const Graphics::Vector3d &point) const; Math::Vector3d getProjectionToPlane(const Math::Vector3d &point) const;
Graphics::Vector3d getProjectionToPuckVector(const Graphics::Vector3d &v) const; Math::Vector3d getProjectionToPuckVector(const Math::Vector3d &v) const;
Graphics::Vector3d getClosestPoint(const Graphics::Vector3d &point) const; Math::Vector3d getClosestPoint(const Math::Vector3d &point) const;
// Interface to trace a ray to its exit from the polygon // Interface to trace a ray to its exit from the polygon
struct ExitInfo { struct ExitInfo {
Graphics::Vector3d exitPoint; Math::Vector3d exitPoint;
float angleWithEdge; float angleWithEdge;
Graphics::Vector3d edgeDir; Math::Vector3d edgeDir;
int edgeVertex; int edgeVertex;
}; };
void getExitInfo(const Graphics::Vector3d &start, const Graphics::Vector3d &dir, struct ExitInfo *result) const; void getExitInfo(const Math::Vector3d &start, const Math::Vector3d &dir, struct ExitInfo *result) const;
int getNumVertices() { return _numVertices; } int getNumVertices() { return _numVertices; }
Graphics::Vector3d *getVertices() { return _vertices; } Math::Vector3d *getVertices() { return _vertices; }
Graphics::Vector3d getNormal() { return _normal; } Math::Vector3d getNormal() { return _normal; }
Sector &operator=(const Sector &other); Sector &operator=(const Sector &other);
bool operator==(const Sector &other) const; bool operator==(const Sector &other) const;
@ -97,12 +97,12 @@ private:
SectorType _type; SectorType _type;
bool _visible; bool _visible;
bool _invalid; bool _invalid;
Graphics::Vector3d *_vertices; Math::Vector3d *_vertices;
Graphics::Vector3d *_origVertices; Math::Vector3d *_origVertices;
float _height; float _height;
float _shrinkRadius; float _shrinkRadius;
Graphics::Vector3d _normal; Math::Vector3d _normal;
}; };
} // end of namespace Grim } // end of namespace Grim

7
graphics/module.mk
View file

@ -15,13 +15,6 @@ MODULE_OBJS := \
VectorRenderer.o \ VectorRenderer.o \
VectorRendererSpec.o \ VectorRendererSpec.o \
yuv_to_rgb.o \ yuv_to_rgb.o \
matrix3.o \
matrix4.o \
line3d.o \
line2d.o \
rect2d.o \
vector2d.o \
vector3d.o \
tinygl/api.o \ tinygl/api.o \
tinygl/arrays.o \ tinygl/arrays.o \
tinygl/clear.o \ tinygl/clear.o \

6
graphics/line2d.cpp → math/line2d.cpp
View file

@ -22,10 +22,10 @@
* $Id$ * $Id$
*/ */
#include "graphics/line2d.h" #include "math/line2d.h"
#include "graphics/rect2d.h" #include "math/rect2d.h"
namespace Graphics { namespace Math {
Line2d::Line2d() : Line2d::Line2d() :
_a(0), _b(0), _c(0) { _a(0), _b(0), _c(0) {

10
graphics/line2d.h → math/line2d.h
View file

@ -22,12 +22,12 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_LINE2D_H #ifndef MATH_LINE2D_H
#define GRAPHICS_LINE2D_H #define MATH_LINE2D_H
#include "graphics/vector2d.h" #include "math/vector2d.h"
namespace Graphics { namespace Math {
class Line2d { class Line2d {
public: public:
@ -67,7 +67,7 @@ public:
void operator=(const Segment2d &other); void operator=(const Segment2d &other);
private: private:
Graphics::Vector2d _begin, _end; Math::Vector2d _begin, _end;
}; };

12
graphics/line3d.cpp → math/line3d.cpp
View file

@ -22,9 +22,9 @@
* $Id$ * $Id$
*/ */
#include "graphics/line3d.h" #include "math/line3d.h"
namespace Graphics { namespace Math {
Line3d::Line3d() { Line3d::Line3d() {
@ -39,19 +39,19 @@ Line3d::Line3d(const Line3d &other) {
*this = other; *this = other;
} }
Graphics::Vector3d Line3d::begin() const { Math::Vector3d Line3d::begin() const {
return _begin; return _begin;
} }
Graphics::Vector3d Line3d::end() const { Math::Vector3d Line3d::end() const {
return _end; return _end;
} }
Graphics::Vector3d Line3d::middle() const { Math::Vector3d Line3d::middle() const {
return (_begin + _end) / 2.f; return (_begin + _end) / 2.f;
} }
bool Line3d::intersectLine2d(const Line3d &other, Graphics::Vector3d *pos) { bool Line3d::intersectLine2d(const Line3d &other, Math::Vector3d *pos) {
float denom = ((other._end.y() - other._begin.y()) * (_end.x() - _begin.x())) - float denom = ((other._end.y() - other._begin.y()) * (_end.x() - _begin.x())) -
((other._end.x() - other._begin.x()) * (_end.y() - _begin.y())); ((other._end.x() - other._begin.x()) * (_end.y() - _begin.y()));

20
graphics/line3d.h → math/line3d.h
View file

@ -22,15 +22,15 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_LINE3D_H #ifndef MATH_LINE3D_H
#define GRAPHICS_LINE3D_H #define MATH_LINE3D_H
#include "common/scummsys.h" #include "common/scummsys.h"
#include "common/endian.h" #include "common/endian.h"
#include "graphics/vector3d.h" #include "math/vector3d.h"
namespace Graphics { namespace Math {
class Line3d { class Line3d {
public: public:
@ -38,19 +38,19 @@ public:
Line3d(const Vector3d &begin, const Vector3d &end); Line3d(const Vector3d &begin, const Vector3d &end);
Line3d(const Line3d &other); Line3d(const Line3d &other);
Graphics::Vector3d begin() const; Math::Vector3d begin() const;
Graphics::Vector3d end() const; Math::Vector3d end() const;
Graphics::Vector3d middle() const; Math::Vector3d middle() const;
bool intersectLine2d(const Line3d &other, Graphics::Vector3d *pos); bool intersectLine2d(const Line3d &other, Math::Vector3d *pos);
void operator=(const Line3d &other); void operator=(const Line3d &other);
private: private:
Graphics::Vector3d _begin, _end; Math::Vector3d _begin, _end;
}; };
} // end of namespace Graphics } // end of namespace Math
#endif #endif

6
graphics/matrix.h → math/matrix.h
View file

@ -22,12 +22,12 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_MATRIX_H #ifndef MATH_MATRIX_H
#define GRAPHICS_MATRIX_H #define MATH_MATRIX_H
#include <assert.h> #include <assert.h>
namespace Graphics { namespace Math {
template<int rows, int cols> template<int rows, int cols>
class Matrix { class Matrix {

6
graphics/matrix3.cpp → math/matrix3.cpp
View file

@ -22,9 +22,9 @@
* $Id$ * $Id$
*/ */
#include "graphics/matrix3.h" #include "math/matrix3.h"
namespace Graphics { namespace Math {
Matrix3x3::Matrix3x3() : Matrix3x3::Matrix3x3() :
Matrix(), Rotation3D(this) { Matrix(), Rotation3D(this) {
@ -54,4 +54,4 @@ float DegreeToRadian(float degrees) {
return (float)DEGTORAD(degrees); return (float)DEGTORAD(degrees);
} }
} // end of namespace Graphics } // end of namespace Math

14
graphics/matrix3.h → math/matrix3.h
View file

@ -22,14 +22,14 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_MATRIX3_H #ifndef MATH_MATRIX3_H
#define GRAPHICS_MATRIX3_H #define MATH_MATRIX3_H
#include "graphics/matrix.h" #include "math/matrix.h"
#include "graphics/transform.h" #include "math/transform.h"
#include "graphics/vector3d.h" #include "math/vector3d.h"
namespace Graphics { namespace Math {
template<class T> template<class T>
class Rotation3D : public Transform<T> { class Rotation3D : public Transform<T> {
@ -167,7 +167,7 @@ float Rotation3D<T>::getRoll() const {
} }
} // end of namespace Graphics } // end of namespace Math
#endif #endif

6
graphics/matrix4.cpp → math/matrix4.cpp
View file

@ -22,9 +22,9 @@
* $Id$ * $Id$
*/ */
#include "graphics/matrix4.h" #include "math/matrix4.h"
namespace Graphics { namespace Math {
Matrix4::Matrix4() : Matrix4::Matrix4() :
Matrix(), Rotation3D(this) { Matrix(), Rotation3D(this) {
@ -62,5 +62,5 @@ void Matrix4::translate(const Vector3d &vec) {
operator()(3, 2) += v.z(); operator()(3, 2) += v.z();
} }
} // end of namespace Graphics } // end of namespace Math

10
graphics/matrix4.h → math/matrix4.h
View file

@ -22,12 +22,12 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_MATRIX4_H #ifndef MATH_MATRIX4_H
#define GRAPHICS_MATRIX4_H #define MATH_MATRIX4_H
#include "graphics/matrix3.h" #include "math/matrix3.h"
namespace Graphics { namespace Math {
// matrix 4 is a rotation matrix + position // matrix 4 is a rotation matrix + position
class Matrix4 : public Matrix<4, 4>, public Rotation3D<Matrix4> { class Matrix4 : public Matrix<4, 4>, public Rotation3D<Matrix4> {
@ -43,6 +43,6 @@ public:
}; };
} // end of namespace Graphics } // end of namespace Math
#endif #endif

13
math/module.mk Normal file
View file

@ -0,0 +1,13 @@
MODULE := math
MODULE_OBJS := \
matrix3.o \
matrix4.o \
line3d.o \
line2d.o \
rect2d.o \
vector2d.o \
vector3d.o
# Include common rules
include $(srcdir)/rules.mk

4
graphics/rect2d.cpp → math/rect2d.cpp
View file

@ -24,9 +24,9 @@
#include "common/scummsys.h" #include "common/scummsys.h"
#include "graphics/rect2d.h" #include "math/rect2d.h"
namespace Graphics { namespace Math {
Rect2d::Rect2d() { Rect2d::Rect2d() {

10
graphics/rect2d.h → math/rect2d.h
View file

@ -22,13 +22,13 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_RECT2D_H #ifndef MATH_RECT2D_H
#define GRAPHICS_RECT2D_H #define MATH_RECT2D_H
#include "graphics/vector2d.h" #include "math/vector2d.h"
#include "graphics/line2d.h" #include "math/line2d.h"
namespace Graphics { namespace Math {
class Segment2d; class Segment2d;

6
graphics/transform.h → math/transform.h
View file

@ -22,10 +22,10 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_TRANSFORM_H #ifndef MATH_TRANSFORM_H
#define GRAPHICS_TRANSFORM_H #define MATH_TRANSFORM_H
namespace Graphics { namespace Math {
template<class T> template<class T>
class Transform { class Transform {

6
graphics/vector2d.cpp → math/vector2d.cpp
View file

@ -22,11 +22,11 @@
* $Id$ * $Id$
*/ */
#include "graphics/vector2d.h" #include "math/vector2d.h"
#include "common/streamdebug.h" #include "common/streamdebug.h"
namespace Graphics { namespace Math {
Vector2d::Vector2d() : Vector2d::Vector2d() :
_x(0), _y(0) { _x(0), _y(0) {
@ -121,7 +121,7 @@ Vector3d Vector2d::toVector3d() const {
} }
Common::Debug &operator<<(Common::Debug dbg, const Graphics::Vector2d &v) { Common::Debug &operator<<(Common::Debug dbg, const Math::Vector2d &v) {
dbg.nospace() << "Vector2d(" << v.getX() << "," << v.getY() << ")"; dbg.nospace() << "Vector2d(" << v.getX() << "," << v.getY() << ")";
return dbg.space(); return dbg.space();

10
graphics/vector2d.h → math/vector2d.h
View file

@ -22,12 +22,12 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_VECTOR2D_H #ifndef MATH_VECTOR2D_H
#define GRAPHICS_VECTOR2D_H #define MATH_VECTOR2D_H
#include "graphics/vector3d.h" #include "math/vector3d.h"
namespace Graphics { namespace Math {
class Vector2d { class Vector2d {
public: public:
@ -88,6 +88,6 @@ namespace Common {
class Debug; class Debug;
} }
Common::Debug &operator<<(Common::Debug dbg, const Graphics::Vector2d &v); Common::Debug &operator<<(Common::Debug dbg, const Math::Vector2d &v);
#endif #endif

4
graphics/vector3d.cpp → math/vector3d.cpp
View file

@ -24,9 +24,9 @@
#include "common/streamdebug.h" #include "common/streamdebug.h"
#include "graphics/vector3d.h" #include "math/vector3d.h"
Common::Debug &operator<<(Common::Debug dbg, const Graphics::Vector3d &v) { Common::Debug &operator<<(Common::Debug dbg, const Math::Vector3d &v) {
dbg.nospace() << "Vector3d(" << v.x() << "," << v.y() << "," << v.z() << ")"; dbg.nospace() << "Vector3d(" << v.x() << "," << v.y() << "," << v.z() << ")";
return dbg.space(); return dbg.space();

10
graphics/vector3d.h → math/vector3d.h
View file

@ -22,13 +22,13 @@
* $Id$ * $Id$
*/ */
#ifndef GRAPHICS_VECTOR3D_H #ifndef MATH_VECTOR3D_H
#define GRAPHICS_VECTOR3D_H #define MATH_VECTOR3D_H
#include "common/scummsys.h" #include "common/scummsys.h"
#include "common/endian.h" #include "common/endian.h"
namespace Graphics { namespace Math {
class Vector3d { class Vector3d {
public: public:
@ -183,12 +183,12 @@ inline Vector3d get_vector3d(const char *data) {
return Vector3d(get_float(data), get_float(data + 4), get_float(data + 8)); return Vector3d(get_float(data), get_float(data + 4), get_float(data + 8));
} }
} // end of namespace Graphics } // end of namespace Math
namespace Common { namespace Common {
class Debug; class Debug;
} }
Common::Debug &operator<<(Common::Debug dbg, const Graphics::Vector3d &v); Common::Debug &operator<<(Common::Debug dbg, const Math::Vector3d &v);
#endif #endif