[Scummvm-git-logs] scummvm master -> b2232e301b1d15c7d2bd99ed220c67829d94f7aa
aquadran
noreply at scummvm.org
Sat Oct 19 09:44:14 UTC 2024
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
b2232e301b WINTERMUTE: Convert to DX math where applicable
Commit: b2232e301b1d15c7d2bd99ed220c67829d94f7aa
https://github.com/scummvm/scummvm/commit/b2232e301b1d15c7d2bd99ed220c67829d94f7aa
Author: Paweł Kołodziejski (aquadran at gmail.com)
Date: 2024-10-19T11:44:09+02:00
Commit Message:
WINTERMUTE: Convert to DX math where applicable
Changed paths:
engines/wintermute/ad/ad_actor_3dx.cpp
engines/wintermute/ad/ad_actor_3dx.h
engines/wintermute/ad/ad_attach_3dx.cpp
engines/wintermute/ad/ad_attach_3dx.h
engines/wintermute/ad/ad_object_3d.cpp
engines/wintermute/ad/ad_object_3d.h
engines/wintermute/ad/ad_path3d.cpp
engines/wintermute/ad/ad_path3d.h
engines/wintermute/ad/ad_path_point3d.cpp
engines/wintermute/ad/ad_path_point3d.h
engines/wintermute/ad/ad_scene.cpp
engines/wintermute/ad/ad_scene_geometry.cpp
engines/wintermute/ad/ad_scene_geometry.h
engines/wintermute/ad/ad_waypoint_group3d.cpp
engines/wintermute/ad/ad_waypoint_group3d.h
engines/wintermute/base/base_object.cpp
engines/wintermute/base/base_object.h
engines/wintermute/base/base_persistence_manager.cpp
engines/wintermute/base/base_persistence_manager.h
engines/wintermute/base/gfx/3dcamera.cpp
engines/wintermute/base/gfx/3dcamera.h
engines/wintermute/base/gfx/3dlight.cpp
engines/wintermute/base/gfx/3dlight.h
engines/wintermute/base/gfx/3dmesh.h
engines/wintermute/base/gfx/3dshadow_volume.cpp
engines/wintermute/base/gfx/3dshadow_volume.h
engines/wintermute/base/gfx/base_renderer3d.h
engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
engines/wintermute/base/gfx/opengl/base_render_opengl3d.h
engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.h
engines/wintermute/base/gfx/opengl/mesh3ds_opengl.cpp
engines/wintermute/base/gfx/opengl/mesh3ds_opengl_shader.cpp
engines/wintermute/base/gfx/xanimation.cpp
engines/wintermute/base/gfx/xanimation.h
engines/wintermute/base/gfx/xframe_node.cpp
engines/wintermute/base/gfx/xframe_node.h
engines/wintermute/base/gfx/xmesh.cpp
engines/wintermute/base/gfx/xmesh.h
engines/wintermute/base/gfx/xmodel.cpp
engines/wintermute/base/gfx/xmodel.h
engines/wintermute/base/gfx/xskinmesh.cpp
engines/wintermute/math/math_util.cpp
engines/wintermute/math/math_util.h
diff --git a/engines/wintermute/ad/ad_actor_3dx.cpp b/engines/wintermute/ad/ad_actor_3dx.cpp
index a7717e72cfa..c098f9a4a4b 100644
--- a/engines/wintermute/ad/ad_actor_3dx.cpp
+++ b/engines/wintermute/ad/ad_actor_3dx.cpp
@@ -64,7 +64,7 @@ IMPLEMENT_PERSISTENT(AdActor3DX, false)
//////////////////////////////////////////////////////////////////////////
AdActor3DX::AdActor3DX(BaseGame *inGame) : AdObject3D(inGame) {
- _targetPoint3D = Math::Vector3d(0.0f, 0.0f, 0.0f);
+ _targetPoint3D = DXVector3(0.0f, 0.0f, 0.0f);
_targetPoint2D = new BasePoint;
_targetAngle = 0.0f;
@@ -98,7 +98,7 @@ AdActor3DX::AdActor3DX(BaseGame *inGame) : AdObject3D(inGame) {
_goToTolerance = 2;
- _partOffset = Math::Vector3d(0.0f, 0.0f, 0.0f);
+ _partOffset = DXVector3(0.0f, 0.0f, 0.0f);
}
//////////////////////////////////////////////////////////////////////////
@@ -185,18 +185,18 @@ bool AdActor3DX::update() {
}
float walkVel = _directWalkVelocity == 0.0f ? _velocity : _directWalkVelocity;
- Math::Vector3d newPos = _posVector;
+ DXVector3 newPos = _posVector;
if (_directWalkMode == DIRECT_WALK_FW) {
// we add the direction vector since in a right handed coordinate system
// angles turn counter-clockwise (wme uses a left handed coordinate system, so there it's a subtraction)
- newPos.x() += sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
- newPos.z() += cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._x += sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._z += cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
}
if (_directWalkMode == DIRECT_WALK_BK) {
// but here we subtract
- newPos.x() -= sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
- newPos.z() -= cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._x -= sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._z -= cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
}
AdScene *scene = ((AdGame *)_gameRef)->_scene;
@@ -205,7 +205,7 @@ bool AdActor3DX::update() {
bool canWalk = false;
if (scene->_2DPathfinding) {
- Math::Matrix4 newWorldMat;
+ DXMatrix newWorldMat;
getMatrix(&newWorldMat, &newPos);
int32 newX, newY;
@@ -399,7 +399,10 @@ bool AdActor3DX::display() {
if (ShadowType == SHADOW_STENCIL) {
displayShadowVolume();
} else if (ShadowType > SHADOW_NONE) {
- _gameRef->_renderer3D->displayShadow(this, Math::Vector3d(_shadowLightPos.x() * _scale3D, _shadowLightPos.y() * _scale3D, _shadowLightPos.z() * _scale3D), true);
+ DXVector3 lightPos = DXVector3(_shadowLightPos._x * _scale3D,
+ _shadowLightPos._y * _scale3D,
+ _shadowLightPos._z * _scale3D);
+ _gameRef->_renderer3D->displayShadow(this, &lightPos, true);
}
_gameRef->_renderer3D->setSpriteBlendMode(_blendMode);
@@ -469,11 +472,11 @@ bool AdActor3DX::displayShadowVolume() {
_gameRef->_renderer3D->setWorldTransform(_worldMatrix);
- Math::Vector3d lightVector = Math::Vector3d(_shadowLightPos.x() * _scale3D,
- _shadowLightPos.y() * _scale3D,
- _shadowLightPos.z() * _scale3D);
- float extrusionDepth = lightVector.length() * 1.5f;
- lightVector.normalize();
+ DXVector3 lightPos = DXVector3(_shadowLightPos._x * _scale3D,
+ _shadowLightPos._y * _scale3D,
+ _shadowLightPos._z * _scale3D);
+ float extrusionDepth = DXVec3Length(&lightPos) * 1.5f;
+ DXVec3Normalize(&lightPos, &lightPos);
getShadowVolume()->setColor(_shadowColor);
@@ -486,10 +489,10 @@ bool AdActor3DX::displayShadowVolume() {
shadowModel = _xmodel;
}
- shadowModel->updateShadowVol(getShadowVolume(), _worldMatrix, lightVector, extrusionDepth);
+ shadowModel->updateShadowVol(getShadowVolume(), &_worldMatrix, &lightPos, extrusionDepth);
- Math::Matrix4 origWorld;
- _gameRef->_renderer3D->getWorldTransform(origWorld);
+ DXMatrix origWorld;
+ _gameRef->_renderer3D->getWorldTransform(&origWorld);
// handle the attachments
for (uint32 i = 0; i < _attachments.size(); i++) {
@@ -504,10 +507,9 @@ bool AdActor3DX::displayShadowVolume() {
continue;
}
- DXMatrix viewMatrix, worldMatrix;
- worldMatrix = DXMatrix(_worldMatrix.getData());
- DXMatrixMultiply(&viewMatrix, &worldMatrix, boneMat);
- at->displayShadowVol(viewMatrix, lightVector, extrusionDepth, true);
+ DXMatrix viewMat;
+ DXMatrixMultiply(&viewMat, &_worldMatrix, boneMat);
+ at->displayShadowVol(&viewMat, &lightPos, extrusionDepth, true);
}
// restore model's world matrix and render the shadow volume
@@ -541,8 +543,8 @@ bool AdActor3DX::displayAttachments(bool registerObjects) {
return true;
}
- Math::Matrix4 origView;
- _gameRef->_renderer3D->getWorldTransform(origView);
+ DXMatrix origView;
+ _gameRef->_renderer3D->getWorldTransform(&origView);
for (uint32 i = 0; i < _attachments.size(); i++) {
AdAttach3DX *at = _attachments[i];
@@ -555,10 +557,10 @@ bool AdActor3DX::displayAttachments(bool registerObjects) {
continue;
}
- Math::Matrix4 viewMat;
- viewMat.setData(*boneMat);
+ DXMatrix viewMat = *boneMat;
+ DXMatrixMultiply(&viewMat, &origView, boneMat);
- at->displayAttachable(viewMat, registerObjects);
+ at->displayAttachable(&viewMat, registerObjects);
}
_gameRef->_renderer3D->setWorldTransform(origView);
@@ -581,7 +583,7 @@ bool AdActor3DX::turnTo(float angle) {
}
//////////////////////////////////////////////////////////////////////////
-void AdActor3DX::goTo3D(Math::Vector3d targetPos, float targetAngle) {
+void AdActor3DX::goTo3D(DXVector3 targetPos, float targetAngle) {
_afterWalkAngle = targetAngle;
if (_targetPoint3D == targetPos && _state == STATE_FOLLOWING_PATH) {
@@ -637,21 +639,21 @@ void AdActor3DX::getNextStep3D() {
if (_angle != _targetAngle)
turnToStep(_angVelocity);
- Math::Vector3d newPos = _posVector;
+ DXVector3 newPos = _posVector;
// we add the direction vector since in a right handed coordinate system
// angles turn counter-clockwise (wme uses a left handed coordinate system, so there it's a subtraction)
- newPos.x() += sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
- newPos.z() += cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._x += sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._z += cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
- Math::Vector3d origVec, newVec;
- Math::Vector3d *currentPos = _path3D->getCurrent();
+ DXVector3 origVec, newVec;
+ DXVector3 *currentPos = _path3D->getCurrent();
if (currentPos != nullptr) {
origVec = *currentPos - _posVector;
newVec = *currentPos - newPos;
}
- if (currentPos == nullptr || origVec.length() < newVec.length()) {
+ if (currentPos == nullptr || DXVec3Length(&origVec) < DXVec3Length(&newVec)) {
if (currentPos != nullptr) {
_posVector = *currentPos;
}
@@ -673,15 +675,15 @@ void AdActor3DX::getNextStep3D() {
}
//////////////////////////////////////////////////////////////////////////
-void AdActor3DX::initLine3D(Math::Vector3d startPt, Math::Vector3d endPt, bool firstStep) {
+void AdActor3DX::initLine3D(DXVector3 startPt, DXVector3 endPt, bool firstStep) {
if (firstStep) {
_nextState = STATE_FOLLOWING_PATH;
// wme subtracted 90 dregrees from the angle, so that the angle zero points downwards
// and the angle 90 goes left
// now we have a right handed coordinate system, so we add 90 degrees instead
- turnTo(radToDeg(-atan2(endPt.z() - startPt.z(), endPt.x() - startPt.x())) + 90);
+ turnTo(radToDeg(-atan2(endPt._z - startPt._z, endPt._x - startPt._x)) + 90);
} else {
- _turningLeft = prepareTurn(radToDeg(-atan2(endPt.z() - startPt.z(), endPt.x() - startPt.x())) + 90);
+ _turningLeft = prepareTurn(radToDeg(-atan2(endPt._z - startPt._z, endPt._x - startPt._x)) + 90);
}
}
@@ -699,23 +701,23 @@ void AdActor3DX::getNextStep2D() {
turnToStep(_angVelocity);
}
- Math::Vector3d newPos = _posVector;
+ DXVector3 newPos = _posVector;
// we add the direction vector since in a right handed coordinate system
// angles turn counter-clockwise (wme uses a left handed coordinate system, so there it's a subtraction)
- newPos.x() += sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
- newPos.z() += cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._x += sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+ newPos._z += cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
- Math::Vector3d currentPoint;
+ DXVector3 currentPoint;
adGame->_scene->_sceneGeometry->convert2Dto3DTolerant(_path2D->getCurrent()->x,
_path2D->getCurrent()->y,
¤tPoint);
- Math::Vector3d origVec, newVec;
+ DXVector3 origVec, newVec;
origVec = currentPoint - _posVector;
newVec = currentPoint - newPos;
- if (origVec.length() < newVec.length()) {
+ if (DXVec3Length(&origVec) < DXVec3Length(&newVec)) {
_posVector = currentPoint;
if (_path2D->getNext() == nullptr) {
@@ -756,7 +758,7 @@ void AdActor3DX::followPath2D() {
if (_path2D->getCurrent() != nullptr) {
_state = STATE_FOLLOWING_PATH;
- Math::Vector3d currentPoint;
+ DXVector3 currentPoint;
adGameRef->_scene->_sceneGeometry->convert2Dto3DTolerant(_path2D->getCurrent()->x,
_path2D->getCurrent()->y,
¤tPoint);
@@ -950,15 +952,15 @@ bool AdActor3DX::loadBuffer(byte *buffer, bool complete) {
break;
case TOKEN_X:
- parser.scanStr((char *)params, "%f", &_posVector.x());
+ parser.scanStr((char *)params, "%f", &_posVector._x);
break;
case TOKEN_Y:
- parser.scanStr((char *)params, "%f", &_posVector.y());
+ parser.scanStr((char *)params, "%f", &_posVector._y);
break;
case TOKEN_Z:
- parser.scanStr((char *)params, "%f", &_posVector.z());
+ parser.scanStr((char *)params, "%f", &_posVector._z);
break;
case TOKEN_ANGLE:
@@ -993,9 +995,9 @@ bool AdActor3DX::loadBuffer(byte *buffer, bool complete) {
}
case TOKEN_LIGHT_POSITION:
- parser.scanStr((char *)params, "%f,%f,%f", &_shadowLightPos.x(), &_shadowLightPos.y(), &_shadowLightPos.z());
+ parser.scanStr((char *)params, "%f,%f,%f", &_shadowLightPos._x, &_shadowLightPos._y, &_shadowLightPos._z);
// invert z coordinate since wme uses a Direct3D coordinate system but we use OpenGL
- _shadowLightPos.z() *= -1.0f;
+ _shadowLightPos._z *= -1.0f;
break;
case TOKEN_SHADOW: {
@@ -1508,11 +1510,11 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GoTo3D") == 0 || strcmp(name, "GoTo3DAsync") == 0) {
stack->correctParams(3);
- Math::Vector3d pos;
- pos.x() = stack->pop()->getFloat();
- pos.y() = stack->pop()->getFloat();
+ DXVector3 pos;
+ pos._x = stack->pop()->getFloat();
+ pos._y = stack->pop()->getFloat();
// scripts will expect a Direct3D coordinate system
- pos.z() = -stack->pop()->getFloat();
+ pos._z = -stack->pop()->getFloat();
goTo3D(pos);
if (strcmp(name, "GoTo3DAsync") != 0) {
@@ -1541,7 +1543,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
}
} else {
if (adGame->_scene && adGame->_scene->_sceneGeometry) {
- Math::Vector3d pos;
+ DXVector3 pos;
if (adGame->_scene->_sceneGeometry->convert2Dto3DTolerant(x, y, &pos)) {
//_gameRef->QuickMessageForm("%d, %d -> %f, %f, %f", x, y, pos.x, pos.y, pos.z);
goTo3D(pos);
@@ -1627,7 +1629,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
}
} else {
if (adGame->_scene->_sceneGeometry) {
- Math::Vector3d pos;
+ DXVector3 pos;
if (adGame->_scene->_sceneGeometry->convert2Dto3DTolerant(ent->getWalkToX(), ent->getWalkToY(), &pos)) {
if (ent->getWalkToX() == 0 && ent->getWalkToY() == 0) {
@@ -1659,9 +1661,9 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
// turn to object?
if (val->isNative() && _gameRef->validObject((BaseObject *)val->getNative())) {
BaseObject *obj = (BaseObject *)val->getNative();
- Math::Vector3d objPos;
+ DXVector3 objPos;
((AdGame *)_gameRef)->_scene->_sceneGeometry->convert2Dto3D(obj->_posX, obj->_posY, &objPos);
- angle = radToDeg(-atan2(objPos.z() - _posVector.z(), objPos.x() - _posVector.x())) + 90;
+ angle = radToDeg(-atan2(objPos._z - _posVector._z, objPos._x - _posVector._x)) + 90;
} else {
// otherwise turn to direction
dir = val->getInt();
@@ -2011,7 +2013,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
float offsetY = stack->pop()->getFloat();
float offsetZ = stack->pop()->getFloat();
- PartEmitter *emitter = createParticleEmitter(boneName, Math::Vector3d(offsetX, offsetY, offsetZ));
+ PartEmitter *emitter = createParticleEmitter(boneName, DXVector3(offsetX, offsetY, offsetZ));
if (emitter) {
stack->pushNative(_partEmitter, true);
} else {
@@ -2444,7 +2446,7 @@ PartEmitter *AdActor3DX::createParticleEmitter(bool followParent, int offsetX, i
}
//////////////////////////////////////////////////////////////////////////
-PartEmitter *AdActor3DX::createParticleEmitter(const char *boneName, Math::Vector3d offset) {
+PartEmitter *AdActor3DX::createParticleEmitter(const char *boneName, DXVector3 offset) {
_partBone = boneName;
_partOffset = offset;
return AdObject::createParticleEmitter(true);
@@ -2466,7 +2468,7 @@ bool AdActor3DX::updatePartEmitter() {
return false;
}
- Math::Vector3d bonePos;
+ DXVector3 bonePos;
getBonePosition3D(_partBone.c_str(), &bonePos, &_partOffset);
int32 x = 0, y = 0;
static_cast<AdGame *>(_gameRef)->_scene->_sceneGeometry->convert3Dto2D(&bonePos, &x, &y);
diff --git a/engines/wintermute/ad/ad_actor_3dx.h b/engines/wintermute/ad/ad_actor_3dx.h
index 20541e33f73..3be4ac484bb 100644
--- a/engines/wintermute/ad/ad_actor_3dx.h
+++ b/engines/wintermute/ad/ad_actor_3dx.h
@@ -31,6 +31,7 @@
#include "engines/wintermute/ad/ad_object_3d.h"
#include "engines/wintermute/base/base_animation_transition_time.h"
#include "engines/wintermute/base/base_point.h"
+#include "engines/wintermute/base/gfx/xmath.h"
#include "engines/wintermute/coll_templ.h"
namespace Wintermute {
@@ -42,10 +43,10 @@ class AdPath3D;
class AdActor3DX : public AdObject3D {
public:
PartEmitter *createParticleEmitter(bool followParent = false, int offsetX = 0, int offsetY = 0) override;
- virtual PartEmitter *createParticleEmitter(const char *boneName, Math::Vector3d offset);
+ virtual PartEmitter *createParticleEmitter(const char *boneName, DXVector3 offset);
bool updatePartEmitter() override;
Common::String _partBone;
- Math::Vector3d _partOffset;
+ DXVector3 _partOffset;
bool displayShadowVolume();
bool restoreDeviceObjects() override;
@@ -85,17 +86,17 @@ public:
DECLARE_PERSISTENT(AdActor3DX, AdObject3D)
bool _turningLeft;
- void initLine3D(Math::Vector3d startPt, Math::Vector3d endPt, bool firstStep);
+ void initLine3D(DXVector3 startPt, DXVector3 endPt, bool firstStep);
void getNextStep3D();
void followPath3D();
void getNextStep2D();
void followPath2D();
- void goTo3D(Math::Vector3d targetPos, float targetAngle = -1.0f);
+ void goTo3D(DXVector3 targetPos, float targetAngle = -1.0f);
void goTo2D(int x, int y, float targetAngle = -1.0f);
bool turnTo(float angle);
- Math::Vector3d _targetPoint3D;
+ DXVector3 _targetPoint3D;
BasePoint *_targetPoint2D;
float _targetAngle;
bool display() override;
diff --git a/engines/wintermute/ad/ad_attach_3dx.cpp b/engines/wintermute/ad/ad_attach_3dx.cpp
index db4b583ea3e..cf0f09bad50 100644
--- a/engines/wintermute/ad/ad_attach_3dx.cpp
+++ b/engines/wintermute/ad/ad_attach_3dx.cpp
@@ -83,14 +83,12 @@ bool AdAttach3DX::update() {
}
//////////////////////////////////////////////////////////////////////////
-bool AdAttach3DX::displayAttachable(const Math::Matrix4 &viewMat, bool registerObjects) {
+bool AdAttach3DX::displayAttachable(DXMatrix *viewMat, bool registerObjects) {
DXMatrix finalMatrix, worldMatrix, viewMatrix;
- worldMatrix = DXMatrix(_worldMatrix.getData());
- viewMatrix = DXMatrix(viewMat.getData());
+ worldMatrix = DXMatrix(_worldMatrix);
+ viewMatrix = DXMatrix(*viewMat);
DXMatrixMultiply(&finalMatrix, &worldMatrix, &viewMatrix);
- Math::Matrix4 finalMat;
- finalMat.setData(finalMatrix);
- _gameRef->_renderer3D->setWorldTransform(finalMat);
+ _gameRef->_renderer3D->setWorldTransform(finalMatrix);
if (_xmodel) {
_xmodel->render();
@@ -109,17 +107,15 @@ bool AdAttach3DX::displayAttachable(const Math::Matrix4 &viewMat, bool registerO
}
//////////////////////////////////////////////////////////////////////////
-bool AdAttach3DX::displayShadowVol(const DXMatrix &modelMat, const Math::Vector3d &light, float extrusionDepth, bool update) {
- DXMatrix finalMatrix, worldMatrix;
- worldMatrix = DXMatrix(_worldMatrix.getData());
- DXMatrixMultiply(&finalMatrix, &modelMat, &worldMatrix);
- Math::Matrix4 finalMat;
- finalMat.setData(finalMatrix);
+bool AdAttach3DX::displayShadowVol(DXMatrix *modelMat, DXVector3 *light, float extrusionDepth, bool update) {
+ DXMatrix finalMat, worldMatrix;
+ worldMatrix = DXMatrix(_worldMatrix);
+ DXMatrixMultiply(&finalMat, modelMat, &worldMatrix);
if (_xmodel) {
if (update) {
getShadowVolume()->reset();
- _xmodel->updateShadowVol(getShadowVolume(), finalMat, light, extrusionDepth);
+ _xmodel->updateShadowVol(getShadowVolume(), &finalMat, light, extrusionDepth);
}
_gameRef->_renderer3D->setWorldTransform(finalMat);
diff --git a/engines/wintermute/ad/ad_attach_3dx.h b/engines/wintermute/ad/ad_attach_3dx.h
index ed6d11c8e3f..c58e27b025e 100644
--- a/engines/wintermute/ad/ad_attach_3dx.h
+++ b/engines/wintermute/ad/ad_attach_3dx.h
@@ -41,8 +41,8 @@ public:
bool init(const char *modelFile, const char *name, const char *parentBone);
bool update() override;
- bool displayAttachable(const Math::Matrix4 &viewMat, bool registerObjects);
- bool displayShadowVol(const DXMatrix &modelMat, const Math::Vector3d &light, float extrusionDepth, bool update);
+ bool displayAttachable(DXMatrix *viewMat, bool registerObjects);
+ bool displayShadowVol(DXMatrix *modelMat, DXVector3 *light, float extrusionDepth, bool update);
bool invalidateDeviceObjects() override;
bool restoreDeviceObjects() override;
diff --git a/engines/wintermute/ad/ad_object_3d.cpp b/engines/wintermute/ad/ad_object_3d.cpp
index 377df08d9be..e86c9c6f2b9 100644
--- a/engines/wintermute/ad/ad_object_3d.cpp
+++ b/engines/wintermute/ad/ad_object_3d.cpp
@@ -48,7 +48,7 @@ AdObject3D::AdObject3D(BaseGame *inGame) : AdObject(inGame) {
_velocity = 1.0f;
_angVelocity = 1.0f;
- _lastPosVector = Math::Vector3d(0.0f, 0.0f, 0.0f);
+ _lastPosVector = DXVector3(0.0f, 0.0f, 0.0f);
_state = _nextState = STATE_READY;
@@ -110,7 +110,7 @@ bool AdObject3D::update() {
// drop to floor
if (_dropToFloor && adGame->_scene && adGame->_scene->_sceneGeometry) {
- _posVector.y() = adGame->_scene->_sceneGeometry->getHeightAt(_posVector, 5.0f);
+ _posVector._y = adGame->_scene->_sceneGeometry->getHeightAt(_posVector, 5.0f);
}
getMatrix(&_worldMatrix);
@@ -126,16 +126,14 @@ bool AdObject3D::update() {
}
//////////////////////////////////////////////////////////////////////////
-bool AdObject3D::convert3DTo2D(Math::Matrix4 *worldMat, int32 *posX, int32 *posY) {
+bool AdObject3D::convert3DTo2D(DXMatrix *worldMat, int32 *posX, int32 *posY) {
DXMatrix viewMat, projMat, world;
DXVector3 vec2d(0.0f, 0.0f, 0.0f);
DXVector3 origin(0.0f, 0.0f, 0.0f);
- Math::Matrix4 view, proj;
- _gameRef->_renderer3D->getViewTransform(view);
- _gameRef->_renderer3D->getProjectionTransform(proj);
- viewMat = DXMatrix(view.getData());
- projMat = DXMatrix(proj.getData());
- world = DXMatrix(worldMat->getData());
+ _gameRef->_renderer3D->getViewTransform(&viewMat);
+ _gameRef->_renderer3D->getProjectionTransform(&projMat);
+
+ world = *worldMat;
DXMatrixTranspose(&world, &world);
Rect32 viewport = _gameRef->_renderer3D->getViewPort();
@@ -186,10 +184,10 @@ bool AdObject3D::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "SkipTo3D") == 0) {
stack->correctParams(3);
- _posVector.x() = stack->pop()->getFloat();
- _posVector.y() = stack->pop()->getFloat();
+ _posVector._x = stack->pop()->getFloat();
+ _posVector._y = stack->pop()->getFloat();
// scripts will expect a Direct3D coordinate system
- _posVector.z() = -stack->pop()->getFloat();
+ _posVector._z = -stack->pop()->getFloat();
stack->pushNULL();
@@ -218,15 +216,15 @@ bool AdObject3D::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
else if (strcmp(name, "GetBonePosition3D") == 0) {
stack->correctParams(1);
const char *boneName = stack->pop()->getString();
- Math::Vector3d pos(0, 0, 0);
+ DXVector3 pos(0, 0, 0);
getBonePosition3D(boneName, &pos);
ScValue *val = stack->getPushValue();
if (val) {
- val->setProperty("X", pos.x());
- val->setProperty("Y", pos.y());
- val->setProperty("Z", pos.z());
+ val->setProperty("X", pos._x);
+ val->setProperty("Y", pos._y);
+ val->setProperty("Z", pos._z);
}
return true;
@@ -274,14 +272,14 @@ ScValue *AdObject3D::scGetProperty(const Common::String &name) {
// PosX
//////////////////////////////////////////////////////////////////////////
else if (name == "PosX") {
- _scValue->setFloat(_posVector.x());
+ _scValue->setFloat(_posVector._x);
return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// PosY
//////////////////////////////////////////////////////////////////////////
else if (name == "PosY") {
- _scValue->setFloat(_posVector.y());
+ _scValue->setFloat(_posVector._y);
return _scValue;
}
//////////////////////////////////////////////////////////////////////////
@@ -289,7 +287,7 @@ ScValue *AdObject3D::scGetProperty(const Common::String &name) {
//////////////////////////////////////////////////////////////////////////
else if (name == "PosZ") {
// scripts will expect a Direct3D coordinate system
- _scValue->setFloat(-_posVector.z());
+ _scValue->setFloat(-_posVector._z);
return _scValue;
}
//////////////////////////////////////////////////////////////////////////
@@ -394,14 +392,14 @@ bool AdObject3D::scSetProperty(const char *name, ScValue *value) {
// PosX
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "PosX") == 0) {
- _posVector.x() = value->getFloat();
+ _posVector._x = value->getFloat();
return true;
}
//////////////////////////////////////////////////////////////////////////
// PosY
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "PosY") == 0) {
- _posVector.y() = value->getFloat();
+ _posVector._y = value->getFloat();
return true;
}
//////////////////////////////////////////////////////////////////////////
@@ -409,7 +407,7 @@ bool AdObject3D::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "PosZ") == 0) {
// scripts will expect a Direct3D coordinate system
- _posVector.z() = -value->getFloat();
+ _posVector._z = -value->getFloat();
return true;
}
@@ -419,7 +417,7 @@ bool AdObject3D::scSetProperty(const char *name, ScValue *value) {
else if (strcmp(name, "X") == 0) {
_posX = value->getInt();
AdGame *adGame = (AdGame *)_gameRef;
- Math::Vector3d pos;
+ DXVector3 pos;
if (adGame->_scene->_sceneGeometry && adGame->_scene->_sceneGeometry->convert2Dto3D(_posX, _posY, &pos)) {
_posVector = pos;
}
@@ -432,7 +430,7 @@ bool AdObject3D::scSetProperty(const char *name, ScValue *value) {
else if (strcmp(name, "Y") == 0) {
_posY = value->getInt();
AdGame *adGame = (AdGame *)_gameRef;
- Math::Vector3d pos;
+ DXVector3 pos;
if (adGame->_scene->_sceneGeometry && adGame->_scene->_sceneGeometry->convert2Dto3D(_posX, _posY, &pos)) {
_posVector = pos;
}
@@ -575,7 +573,7 @@ bool AdObject3D::persist(BasePersistenceManager *persistMgr) {
//////////////////////////////////////////////////////////////////////////
bool AdObject3D::skipTo(int x, int y, bool tolerant) {
AdGame *adGame = (AdGame *)_gameRef;
- Math::Vector3d pos;
+ DXVector3 pos;
bool success;
if (tolerant) {
@@ -619,7 +617,7 @@ bool AdObject3D::getBonePosition2D(const char *boneName, int32 *x, int32 *y) {
return false;
}
- DXMatrix bonePosMat, worldMatrix = DXMatrix(_worldMatrix.getData());
+ DXMatrix bonePosMat, worldMatrix = DXMatrix(_worldMatrix);
DXMatrixMultiply(&bonePosMat, boneMat, &worldMatrix);
DXVector4 vectBone4;
@@ -627,13 +625,13 @@ bool AdObject3D::getBonePosition2D(const char *boneName, int32 *x, int32 *y) {
DXVec3Transform(&vectBone4, &vectBone3, &bonePosMat);
DXVector3 vectBone(vectBone4._x, vectBone4._y, vectBone4._z);
- Math::Vector3d vectBonePos = Math::Vector3d(vectBone4._x, vectBone4._y, vectBone4._z);
+ DXVector3 vectBonePos = DXVector3(vectBone4._x, vectBone4._y, vectBone4._z);
adGame->_scene->_sceneGeometry->convert3Dto2D(&vectBonePos, x, y);
return true;
}
//////////////////////////////////////////////////////////////////////////
-bool AdObject3D::getBonePosition3D(const char *boneName, Math::Vector3d *pos, Math::Vector3d *offset) {
+bool AdObject3D::getBonePosition3D(const char *boneName, DXVector3 *pos, DXVector3 *offset) {
if (!_xmodel) {
return false;
}
@@ -643,16 +641,16 @@ bool AdObject3D::getBonePosition3D(const char *boneName, Math::Vector3d *pos, Ma
return false;
}
- DXMatrix bonePosMat, worldMatrix = DXMatrix(_worldMatrix.getData());
+ DXMatrix bonePosMat, worldMatrix = DXMatrix(_worldMatrix);
DXMatrixMultiply(&bonePosMat, boneMat, &worldMatrix);
DXVector4 vectBone4;
- DXVector3 vectBone3(offset->x(), offset->x(), offset->y());
+ DXVector3 vectBone3(offset->_x, offset->_x, offset->_y);
DXVec3Transform(&vectBone4, &vectBone3, &bonePosMat);
- pos->x() = vectBone4._x;
- pos->y() = vectBone4._y;
- pos->z() = vectBone4._z;
+ pos->_x = vectBone4._x;
+ pos->_y = vectBone4._y;
+ pos->_z = vectBone4._z;
return true;
}
diff --git a/engines/wintermute/ad/ad_object_3d.h b/engines/wintermute/ad/ad_object_3d.h
index e2b43a3b2fd..547b225a8cb 100644
--- a/engines/wintermute/ad/ad_object_3d.h
+++ b/engines/wintermute/ad/ad_object_3d.h
@@ -40,10 +40,10 @@ class ShadowVolume;
class AdObject3D : public AdObject {
public:
bool setupLights();
- bool convert3DTo2D(Math::Matrix4 *worldMat, int32 *posX, int32 *posY);
+ bool convert3DTo2D(DXMatrix *worldMat, int32 *posX, int32 *posY);
bool skipTo(int x, int y, bool tolerant = false);
char *_tempSkelAnim;
- Math::Vector3d _lastPosVector;
+ DXVector3 _lastPosVector;
DECLARE_PERSISTENT(AdObject3D, AdObject)
bool _dropToFloor;
bool display() override;
@@ -51,7 +51,7 @@ public:
AdObject3D(BaseGame *inGame);
virtual ~AdObject3D();
bool getBonePosition2D(const char *boneName, int32 *x, int32 *y);
- bool getBonePosition3D(const char *boneName, Math::Vector3d *pos, Math::Vector3d *offset = nullptr);
+ bool getBonePosition3D(const char *boneName, DXVector3 *pos, DXVector3 *offset = nullptr);
float _velocity;
float _angVelocity;
diff --git a/engines/wintermute/ad/ad_path3d.cpp b/engines/wintermute/ad/ad_path3d.cpp
index dfa0d9d9eee..fa28f711fb5 100644
--- a/engines/wintermute/ad/ad_path3d.cpp
+++ b/engines/wintermute/ad/ad_path3d.cpp
@@ -55,13 +55,13 @@ void AdPath3D::reset() {
}
//////////////////////////////////////////////////////////////////////////
-void AdPath3D::addPoint(Math::Vector3d point) {
- _points.add(new Math::Vector3d(point));
+void AdPath3D::addPoint(DXVector3 point) {
+ _points.add(new DXVector3(point));
}
//////////////////////////////////////////////////////////////////////////
void AdPath3D::addPoint(float x, float y, float z) {
- _points.add(new Math::Vector3d(x, y, z));
+ _points.add(new DXVector3(x, y, z));
}
//////////////////////////////////////////////////////////////////////////
@@ -73,7 +73,7 @@ bool AdPath3D::setReady(bool ready) {
}
//////////////////////////////////////////////////////////////////////////
-Math::Vector3d *AdPath3D::getFirst() {
+DXVector3 *AdPath3D::getFirst() {
if (_points.size() > 0) {
_currIndex = 0;
return _points[_currIndex];
@@ -83,7 +83,7 @@ Math::Vector3d *AdPath3D::getFirst() {
}
//////////////////////////////////////////////////////////////////////////
-Math::Vector3d *AdPath3D::getNext() {
+DXVector3 *AdPath3D::getNext() {
_currIndex++;
if (static_cast<uint>(_currIndex) < _points.size()) {
return _points[_currIndex];
@@ -93,7 +93,7 @@ Math::Vector3d *AdPath3D::getNext() {
}
//////////////////////////////////////////////////////////////////////////
-Math::Vector3d *AdPath3D::getCurrent() {
+DXVector3 *AdPath3D::getCurrent() {
if (_currIndex >= 0 && static_cast<uint>(_currIndex) < _points.size()) {
return _points[_currIndex];
} else {
@@ -112,9 +112,9 @@ bool AdPath3D::persist(BasePersistenceManager *persistMgr) {
int32 j = _points.size();
persistMgr->transferSint32("ArraySize", &j);
for (int i = 0; i < j; i++) {
- persistMgr->transferFloat("x", &_points[i]->x());
- persistMgr->transferFloat("y", &_points[i]->y());
- persistMgr->transferFloat("z", &_points[i]->z());
+ persistMgr->transferFloat("x", &_points[i]->_x);
+ persistMgr->transferFloat("y", &_points[i]->_y);
+ persistMgr->transferFloat("z", &_points[i]->_z);
}
} else {
int32 j = 0;
diff --git a/engines/wintermute/ad/ad_path3d.h b/engines/wintermute/ad/ad_path3d.h
index 042e095a111..61fb4f22fab 100644
--- a/engines/wintermute/ad/ad_path3d.h
+++ b/engines/wintermute/ad/ad_path3d.h
@@ -38,17 +38,17 @@ namespace Wintermute {
class AdPath3D : public BaseClass {
public:
- Math::Vector3d *getCurrent();
- Math::Vector3d *getNext();
- Math::Vector3d *getFirst();
+ DXVector3 *getCurrent();
+ DXVector3 *getNext();
+ DXVector3 *getFirst();
bool setReady(bool ready);
void addPoint(float x, float y, float z);
- void addPoint(Math::Vector3d Point);
+ void addPoint(DXVector3 Point);
void reset();
AdPath3D(BaseGame *inGame);
virtual ~AdPath3D();
bool _ready;
- BaseArray<Math::Vector3d *> _points;
+ BaseArray<DXVector3 *> _points;
int32 _currIndex;
DECLARE_PERSISTENT(AdPath3D, BaseClass)
diff --git a/engines/wintermute/ad/ad_path_point3d.cpp b/engines/wintermute/ad/ad_path_point3d.cpp
index 279d30d12eb..58ce06ce267 100644
--- a/engines/wintermute/ad/ad_path_point3d.cpp
+++ b/engines/wintermute/ad/ad_path_point3d.cpp
@@ -27,6 +27,7 @@
#include "engines/wintermute/ad/ad_path_point3d.h"
#include "engines/wintermute/base/base_persistence_manager.h"
+#include "engines/wintermute/base/gfx/xmath.h"
namespace Wintermute {
@@ -34,7 +35,7 @@ IMPLEMENT_PERSISTENT(AdPathPoint3D, false)
//////////////////////////////////////////////////////////////////////////
AdPathPoint3D::AdPathPoint3D() : BaseClass() {
- _pos = Math::Vector3d(0.0f, 0.0f, 0.0f);
+ _pos = DXVector3(0.0f, 0.0f, 0.0f);
_distance = 0.0f;
_marked = false;
@@ -42,7 +43,7 @@ AdPathPoint3D::AdPathPoint3D() : BaseClass() {
}
//////////////////////////////////////////////////////////////////////////
-AdPathPoint3D::AdPathPoint3D(Math::Vector3d pos, float dist) {
+AdPathPoint3D::AdPathPoint3D(DXVector3 pos, float dist) {
_pos = pos;
_distance = dist;
@@ -61,9 +62,9 @@ bool AdPathPoint3D::persist(BasePersistenceManager *persistMgr) {
persistMgr->transferBool(TMEMBER(_marked));
persistMgr->transferPtr(TMEMBER(_origin));
- persistMgr->transferFloat("x", &_pos.x());
- persistMgr->transferFloat("y", &_pos.y());
- persistMgr->transferFloat("z", &_pos.z());
+ persistMgr->transferFloat("x", &_pos._x);
+ persistMgr->transferFloat("y", &_pos._y);
+ persistMgr->transferFloat("z", &_pos._z);
return true;
}
diff --git a/engines/wintermute/ad/ad_path_point3d.h b/engines/wintermute/ad/ad_path_point3d.h
index 97f90bcf56c..4f0157f8dc3 100644
--- a/engines/wintermute/ad/ad_path_point3d.h
+++ b/engines/wintermute/ad/ad_path_point3d.h
@@ -31,6 +31,7 @@
#include "engines/wintermute/persistent.h"
#include "engines/wintermute/base/base.h"
+#include "engines/wintermute/base/gfx/xmath.h"
#include "math/vector3d.h"
@@ -39,13 +40,13 @@ namespace Wintermute {
class AdPathPoint3D: public BaseClass {
public:
DECLARE_PERSISTENT(AdPathPoint3D, BaseClass)
- AdPathPoint3D(Math::Vector3d pos, float dist);
+ AdPathPoint3D(DXVector3 pos, float dist);
AdPathPoint3D();
virtual ~AdPathPoint3D();
AdPathPoint3D *_origin;
bool _marked;
float _distance;
- Math::Vector3d _pos;
+ DXVector3 _pos;
};
}
diff --git a/engines/wintermute/ad/ad_scene.cpp b/engines/wintermute/ad/ad_scene.cpp
index b096c980313..ee863b6df7a 100644
--- a/engines/wintermute/ad/ad_scene.cpp
+++ b/engines/wintermute/ad/ad_scene.cpp
@@ -2136,14 +2136,14 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
script->runtimeError("Scene.GetLightPosition: Scene doesn't contain any geometry");
stack->pushInt(0);
} else {
- Math::Vector3d pos = _sceneGeometry->getLightPos(lightName);
+ DXVector3 pos = _sceneGeometry->getLightPos(lightName);
ScValue *val = stack->getPushValue();
if (val) {
- val->setProperty("X", pos.x());
- val->setProperty("Y", pos.y());
+ val->setProperty("X", pos._x);
+ val->setProperty("Y", pos._y);
// invert z coordinate to change to OpenGL coordinate system
- val->setProperty("Z", -pos.z());
+ val->setProperty("Z", -pos._z);
}
}
diff --git a/engines/wintermute/ad/ad_scene_geometry.cpp b/engines/wintermute/ad/ad_scene_geometry.cpp
index aae5f1dc2db..3e6b14f4902 100644
--- a/engines/wintermute/ad/ad_scene_geometry.cpp
+++ b/engines/wintermute/ad/ad_scene_geometry.cpp
@@ -47,6 +47,7 @@
#include "engines/wintermute/base/gfx/3dlight.h"
#include "engines/wintermute/base/gfx/3dloader_3ds.h"
#include "engines/wintermute/base/gfx/3dmesh.h"
+#include "engines/wintermute/base/gfx/xmath.h"
#include "engines/wintermute/math/math_util.h"
#include "engines/wintermute/system/sys_class_registry.h"
#include "engines/wintermute/wintermute.h"
@@ -60,7 +61,7 @@ IMPLEMENT_PERSISTENT(AdSceneGeometry, false)
//////////////////////////////////////////////////////////////////////////
AdSceneGeometry::AdSceneGeometry(BaseGame *gameRef) : BaseObject(gameRef) {
_activeCamera = _activeLight = -1;
- _viewMatrix.setToIdentity();
+ DXMatrixIdentity(&_viewMatrix);
_waypointHeight = 10.0f;
_wptMarker = NULL;
@@ -69,14 +70,14 @@ AdSceneGeometry::AdSceneGeometry(BaseGame *gameRef) : BaseObject(gameRef) {
_PFMaxTime = 15;
_PFRerun = false;
- _PFSource = _PFTarget = _PFAlternateTarget = Math::Vector3d(0, 0, 0);
+ _PFSource = _PFTarget = _PFAlternateTarget = DXVector3(0, 0, 0);
_PFAlternateDist = FLT_MAX;
_drawingViewport.setRect(0, 0, 0, 0);
- _lastWorldMat.setToIdentity();
- _lastViewMat.setToIdentity();
- _lastProjMat.setToIdentity();
+ DXMatrixIdentity(&_lastWorldMat);
+ DXMatrixIdentity(&_lastViewMat);
+ DXMatrixIdentity(&_lastProjMat);
_lastOffsetX = _lastOffsetY = 0;
_lastScrollX = _lastScrollY = 0;
@@ -126,7 +127,7 @@ void AdSceneGeometry::cleanup() {
_lights.clear();
_activeCamera = _activeLight = -1;
- _viewMatrix.setToIdentity();
+ DXMatrixIdentity(&_viewMatrix);
for (i = 0; i < _PFPath.size(); i++) {
delete _PFPath[i];
@@ -277,8 +278,8 @@ bool AdSceneGeometry::loadFile(const char *filename) {
bool AdSceneGeometry::dropWaypoints() {
for (uint i = 0; i < _waypointGroups.size(); i++) {
for (uint j = 0; j < _waypointGroups[i]->_points.size(); j++) {
- Math::Vector3d *point = _waypointGroups[i]->_points[j];
- point->y() = getHeightAt(*point) + _waypointHeight;
+ DXVector3 *point = _waypointGroups[i]->_points[j];
+ point->_y = getHeightAt(*point) + _waypointHeight;
}
}
return true;
@@ -350,7 +351,7 @@ bool AdSceneGeometry::setActiveLight(char *light) {
}
//////////////////////////////////////////////////////////////////////////
-Math::Matrix4 *AdSceneGeometry::getViewMatrix() {
+DXMatrix *AdSceneGeometry::getViewMatrix() {
return &_viewMatrix;
}
@@ -359,9 +360,9 @@ bool AdSceneGeometry::storeDrawingParams() {
_drawingViewport = _gameRef->_renderer3D->getViewPort();
// store values
- _gameRef->_renderer3D->getWorldTransform(_lastWorldMat);
- _gameRef->_renderer3D->getViewTransform(_lastViewMat);
- _gameRef->_renderer3D->getProjectionTransform(_lastProjMat);
+ _gameRef->_renderer3D->getWorldTransform(&_lastWorldMat);
+ _gameRef->_renderer3D->getViewTransform(&_lastViewMat);
+ _gameRef->_renderer3D->getProjectionTransform(&_lastProjMat);
AdScene *scene = ((AdGame *)_gameRef)->_scene;
@@ -410,33 +411,32 @@ bool AdSceneGeometry::renderShadowGeometry() {
}
//////////////////////////////////////////////////////////////////////////
-float AdSceneGeometry::getHeightAt(Math::Vector3d pos, float tolerance, bool *intFound) {
- float ret = pos.y();
- Math::Vector3d intersection;
- Math::Vector3d dir = Math::Vector3d(0, -1, 0);
+float AdSceneGeometry::getHeightAt(DXVector3 pos, float tolerance, bool *intFound) {
+ float ret = pos._y;
+ DXVector3 intersection;
+ DXVector3 dir = DXVector3(0, -1, 0);
- pos.y() += tolerance;
+ pos._y += tolerance;
bool intFoundTmp = false;
for (uint32 i = 0; i < _planes.size(); i++) {
for (int j = 0; j < _planes[i]->_mesh->faceCount(); j++) {
uint16 *triangle = _planes[i]->_mesh->getFace(j);
- float *v0 = _planes[i]->_mesh->getVertexPosition(triangle[0]);
- float *v1 = _planes[i]->_mesh->getVertexPosition(triangle[1]);
- float *v2 = _planes[i]->_mesh->getVertexPosition(triangle[2]);
-
- if (intersectTriangle(pos, dir,
- Math::Vector3d(v0[0], v0[1], v0[2]),
- Math::Vector3d(v1[0], v1[1], v1[2]),
- Math::Vector3d(v2[0], v2[1], v2[2]),
- intersection.x(), intersection.y(), intersection.z())) {
- if (intersection.y() > pos.y() + tolerance) {
+ float *vp0 = _planes[i]->_mesh->getVertexPosition(triangle[0]);
+ float *vp1 = _planes[i]->_mesh->getVertexPosition(triangle[1]);
+ float *vp2 = _planes[i]->_mesh->getVertexPosition(triangle[2]);
+ DXVector3 v0(vp0[0], vp0[1], vp0[2]);
+ DXVector3 v1(vp1[0], vp1[1], vp1[2]);
+ DXVector3 v2(vp2[0], vp2[1], vp2[2]);
+
+ if (intersectTriangle(pos, dir, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z)) {
+ if (intersection._y > pos._y + tolerance) {
continue; // only fall down
}
- if (!intFoundTmp || ABS(ret - pos.y()) > ABS(intersection.y() - pos.y())) {
- ret = intersection.y();
+ if (!intFoundTmp || ABS(ret - pos._y) > ABS(intersection._y - pos._y)) {
+ ret = intersection._y;
}
intFoundTmp = true;
@@ -452,28 +452,26 @@ float AdSceneGeometry::getHeightAt(Math::Vector3d pos, float tolerance, bool *in
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::directPathExists(Math::Vector3d *p1, Math::Vector3d *p2) {
+bool AdSceneGeometry::directPathExists(DXVector3 *p1, DXVector3 *p2) {
// test walkplanes
for (uint i = 0; i < _planes.size(); i++) {
for (int j = 0; j < _planes[i]->_mesh->faceCount(); j++) {
uint16 *triangle = _planes[i]->_mesh->getFace(j);
- float *v0 = _planes[i]->_mesh->getVertexPosition(triangle[0]);
- float *v1 = _planes[i]->_mesh->getVertexPosition(triangle[1]);
- float *v2 = _planes[i]->_mesh->getVertexPosition(triangle[2]);
- Math::Vector3d intersection;
+ float *vp0 = _planes[i]->_mesh->getVertexPosition(triangle[0]);
+ float *vp1 = _planes[i]->_mesh->getVertexPosition(triangle[1]);
+ float *vp2 = _planes[i]->_mesh->getVertexPosition(triangle[2]);
+ DXVector3 v0(vp0[0], vp0[1], vp0[2]);
+ DXVector3 v1(vp1[0], vp1[1], vp1[2]);
+ DXVector3 v2(vp2[0], vp2[1], vp2[2]);
+ DXVector3 intersection;
float dist;
- if (pickGetIntersect(*p1, *p2, Math::Vector3d(v0[0], v0[1], v0[2]),
- Math::Vector3d(v1[0], v1[1], v1[2]),
- Math::Vector3d(v2[0], v2[1], v2[2]),
- intersection, dist)) {
- if (intersectTriangle(*p1, *p1 - *p2, v0, v1, v2,
- intersection.x(), intersection.y(), intersection.z())) {
+ if (pickGetIntersect(*p1, *p2, v0, v1, v2, &intersection, &dist)) {
+ if (intersectTriangle(*p1, *p1 - *p2, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z)) {
return false;
}
- if (intersectTriangle(*p2, *p2 - *p1, v0, v1, v2,
- intersection.x(), intersection.y(), intersection.z())) {
+ if (intersectTriangle(*p2, *p2 - *p1, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z)) {
return false;
}
}
@@ -488,23 +486,23 @@ bool AdSceneGeometry::directPathExists(Math::Vector3d *p1, Math::Vector3d *p2) {
for (int j = 0; j < _blocks[i]->_mesh->faceCount(); j++) {
uint16 *triangle = _blocks[i]->_mesh->getFace(j);
- float *v0 = _blocks[i]->_mesh->getVertexPosition(triangle[0]);
- float *v1 = _blocks[i]->_mesh->getVertexPosition(triangle[1]);
- float *v2 = _blocks[i]->_mesh->getVertexPosition(triangle[2]);
- Math::Vector3d intersection;
+ float *vp0 = _blocks[i]->_mesh->getVertexPosition(triangle[0]);
+ float *vp1 = _blocks[i]->_mesh->getVertexPosition(triangle[1]);
+ float *vp2 = _blocks[i]->_mesh->getVertexPosition(triangle[2]);
+ DXVector3 v0(vp0[0], vp0[1], vp0[2]);
+ DXVector3 v1(vp1[0], vp1[1], vp1[2]);
+ DXVector3 v2(vp2[0], vp2[1], vp2[2]);
+ DXVector3 intersection;
float dist;
- if (pickGetIntersect(*p1, *p2, Math::Vector3d(v0[0], v0[1], v0[2]),
- Math::Vector3d(v1[0], v1[1], v1[2]),
- Math::Vector3d(v2[0], v2[1], v2[2]),
- intersection, dist)) {
+ if (pickGetIntersect(*p1, *p2, v0, v1, v2, &intersection, &dist)) {
if (intersectTriangle(*p1, *p1 - *p2, v0, v1, v2,
- intersection.x(), intersection.y(), intersection.z())) {
+ &intersection._x, &intersection._y, &intersection._z)) {
return false;
}
if (intersectTriangle(*p2, *p2 - *p1, v0, v1, v2,
- intersection.x(), intersection.y(), intersection.z())) {
+ &intersection._x, &intersection._y, &intersection._z)) {
return false;
}
}
@@ -515,7 +513,7 @@ bool AdSceneGeometry::directPathExists(Math::Vector3d *p1, Math::Vector3d *p2) {
}
//////////////////////////////////////////////////////////////////////////
-Math::Vector3d AdSceneGeometry::getBlockIntersection(Math::Vector3d *p1, Math::Vector3d *p2) {
+DXVector3 AdSceneGeometry::getBlockIntersection(DXVector3 *p1, DXVector3 *p2) {
// test blocks
for (uint i = 0; i < _blocks.size(); i++) {
if (!_blocks[i]->_active) {
@@ -524,33 +522,35 @@ Math::Vector3d AdSceneGeometry::getBlockIntersection(Math::Vector3d *p1, Math::V
for (int j = 0; j < _blocks[i]->_mesh->faceCount(); j++) {
uint16 *triangle = _blocks[i]->_mesh->getFace(j);
- float *v0 = _blocks[i]->_mesh->getVertexPosition(triangle[0]);
- float *v1 = _blocks[i]->_mesh->getVertexPosition(triangle[1]);
- float *v2 = _blocks[i]->_mesh->getVertexPosition(triangle[2]);
-
- Math::Vector3d intersection;
+ float *vp0 = _blocks[i]->_mesh->getVertexPosition(triangle[0]);
+ float *vp1 = _blocks[i]->_mesh->getVertexPosition(triangle[1]);
+ float *vp2 = _blocks[i]->_mesh->getVertexPosition(triangle[2]);
+ DXVector3 v0(vp0[0], vp0[1], vp0[2]);
+ DXVector3 v1(vp1[0], vp1[1], vp1[2]);
+ DXVector3 v2(vp2[0], vp2[1], vp2[2]);
+ DXVector3 intersection;
float dist;
- if (pickGetIntersect(*p1, *p2, v0, v1, v2, intersection, dist)) {
- if (intersectTriangle(*p1, *p1 - *p2, v0, v1, v2, intersection.x(), intersection.y(), intersection.z())) {
+ if (pickGetIntersect(*p1, *p2, v0, v1, v2, &intersection, &dist)) {
+ if (intersectTriangle(*p1, *p1 - *p2, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z)) {
return intersection;
}
- if (intersectTriangle(*p2, *p2 - *p1, v0, v1, v2, intersection.x(), intersection.y(), intersection.z())) {
+ if (intersectTriangle(*p2, *p2 - *p1, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z)) {
return intersection;
}
}
}
}
- return Math::Vector3d(0, 0, 0);
+ return DXVector3(0, 0, 0);
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::convert2Dto3DTolerant(int x, int y, Math::Vector3d *pos) {
- bool Ret = convert2Dto3D(x, y, pos);
- if (Ret) {
- return Ret;
+bool AdSceneGeometry::convert2Dto3DTolerant(int x, int y, DXVector3 *pos) {
+ bool ret = convert2Dto3D(x, y, pos);
+ if (ret) {
+ return ret;
}
int lenLeft = 0;
@@ -631,10 +631,10 @@ bool AdSceneGeometry::convert2Dto3DTolerant(int x, int y, Math::Vector3d *pos) {
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::convert2Dto3D(int x, int y, Math::Vector3d *pos) {
+bool AdSceneGeometry::convert2Dto3D(int x, int y, DXVector3 *pos) {
if (!_lastValuesInitialized) {
_drawingViewport = _gameRef->_renderer3D->getViewPort();
- _gameRef->_renderer3D->getProjectionTransform(_lastProjMat);
+ _gameRef->_renderer3D->getProjectionTransform(&_lastProjMat);
}
float resWidth, resHeight;
@@ -657,12 +657,12 @@ bool AdSceneGeometry::convert2Dto3D(int x, int y, Math::Vector3d *pos) {
// Compute the vector of the pick ray in screen space
DXVector3 vec;
- vec._x = (((2.0f * x) / _drawingViewport.width()) - 1) / _lastProjMat(0, 0);
- vec._y = -(((2.0f * y) / _drawingViewport.height()) - 1) / _lastProjMat(1, 1);
+ vec._x = (((2.0f * x) / _drawingViewport.width()) - 1) / _lastProjMat.matrix._11;
+ vec._y = -(((2.0f * y) / _drawingViewport.height()) - 1) / _lastProjMat.matrix._22;
vec._z = -1.0f;
// Get the inverse view matrix
- DXMatrix m, viewMatrix = DXMatrix(_lastViewMat.getData());
+ DXMatrix m, viewMatrix = DXMatrix(_lastViewMat);
DXMatrixInverse(&m, nullptr, &viewMatrix);
// Transform the screen space pick ray into 3D space
@@ -673,30 +673,28 @@ bool AdSceneGeometry::convert2Dto3D(int x, int y, Math::Vector3d *pos) {
vPickRayOrig._y = m.matrix._42;
vPickRayOrig._z = m.matrix._43;
- Math::Vector3d pickRayDir = Math::Vector3d(vPickRayDir);
- Math::Vector3d pickRayOrig = Math::Vector3d(vPickRayOrig);
+ DXVector3 pickRayDir = DXVector3(vPickRayDir);
+ DXVector3 pickRayOrig = DXVector3(vPickRayOrig);
bool intFound = false;
float minDist = FLT_MAX;
DXVector3 intersection, ray;
-
for (uint32 i = 0; i < _planes.size(); i++) {
for (int j = 0; j < _planes[i]->_mesh->faceCount(); j++) {
uint16 *triangle = _planes[i]->_mesh->getFace(j);
- float *v0 = _planes[i]->_mesh->getVertexPosition(triangle[0]);
- float *v1 = _planes[i]->_mesh->getVertexPosition(triangle[1]);
- float *v2 = _planes[i]->_mesh->getVertexPosition(triangle[2]);
-
- if (intersectTriangle(pickRayOrig, pickRayDir,
- Math::Vector3d(v0[0], v0[1], v0[2]),
- Math::Vector3d(v1[0], v1[1], v1[2]),
- Math::Vector3d(v2[0], v2[1], v2[2]),
- intersection._x, intersection._y, intersection._z)) {
+ float *vp0 = _planes[i]->_mesh->getVertexPosition(triangle[0]);
+ float *vp1 = _planes[i]->_mesh->getVertexPosition(triangle[1]);
+ float *vp2 = _planes[i]->_mesh->getVertexPosition(triangle[2]);
+ DXVector3 v0(vp0[0], vp0[1], vp0[2]);
+ DXVector3 v1(vp1[0], vp1[1], vp1[2]);
+ DXVector3 v2(vp2[0], vp2[1], vp2[2]);
+
+ if (intersectTriangle(pickRayOrig, pickRayDir, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z)) {
ray = intersection - vPickRayOrig;
float dist = DXVec3Length(&ray);
if (dist < minDist) {
- *pos = Math::Vector3d(intersection);
+ *pos = intersection;
minDist = dist;
}
@@ -709,18 +707,18 @@ bool AdSceneGeometry::convert2Dto3D(int x, int y, Math::Vector3d *pos) {
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::getPath(Math::Vector3d source, Math::Vector3d target, AdPath3D *path, bool rerun) {
+bool AdSceneGeometry::getPath(DXVector3 source, DXVector3 target, AdPath3D *path, bool rerun) {
if (!_PFReady) {
return false;
} else {
- source.y() = getHeightAt(source, _waypointHeight) + _waypointHeight;
- target.y() = getHeightAt(target, _waypointHeight) + _waypointHeight;
+ source._y = getHeightAt(source, _waypointHeight) + _waypointHeight;
+ target._y = getHeightAt(target, _waypointHeight) + _waypointHeight;
_PFReady = false;
_PFSource = source;
_PFTarget = target;
_PFTargetPath = path;
- _PFAlternateTarget = Math::Vector3d(0, 0, 0);
+ _PFAlternateTarget = DXVector3(0, 0, 0);
_PFAlternateDist = FLT_MAX;
_PFTargetPath->reset();
@@ -774,7 +772,7 @@ void AdSceneGeometry::pathFinderStep() {
_PFReady = true;
if (!_PFRerun) {
- if (_PFAlternateTarget != Math::Vector3d(0, 0, 0)) {
+ if (_PFAlternateTarget != DXVector3(0, 0, 0)) {
getPath(_PFSource, _PFAlternateTarget, _PFTargetPath, true);
} else {
_PFTargetPath->setReady(true);
@@ -791,7 +789,7 @@ void AdSceneGeometry::pathFinderStep() {
// target point marked, generate path and terminate
if (lowest_pt->_pos == _PFTarget) {
while (lowest_pt != NULL) {
- _PFTargetPath->_points.insert_at(0, new Math::Vector3d(lowest_pt->_pos));
+ _PFTargetPath->_points.insert_at(0, new DXVector3(lowest_pt->_pos));
lowest_pt = lowest_pt->_origin;
}
// remove current position
@@ -814,16 +812,16 @@ void AdSceneGeometry::pathFinderStep() {
_PFPath[i]->_origin = lowest_pt;
} else {
if (!_PFRerun && _PFPath[i]->_pos == _PFTarget) {
- Math::Vector3d Line = _PFPath[i]->_pos - lowest_pt->_pos;
- float Len = Line.getMagnitude();
+ DXVector3 line = _PFPath[i]->_pos - lowest_pt->_pos;
+ float len = DXVec3Length(&line);
- if (Len < _PFAlternateDist) {
- _PFAlternateDist = Len;
+ if (len < _PFAlternateDist) {
+ _PFAlternateDist = len;
_PFAlternateTarget = getBlockIntersection(&lowest_pt->_pos, &_PFPath[i]->_pos);
- Math::Vector3d Dir = _PFAlternateTarget - lowest_pt->_pos;
- Dir.normalize();
- _PFAlternateTarget -= Dir * 30;
+ DXVector3 dir = _PFAlternateTarget - lowest_pt->_pos;
+ DXVec3Normalize(&dir, &dir);
+ _PFAlternateTarget -= dir * 30;
}
}
}
@@ -832,13 +830,13 @@ void AdSceneGeometry::pathFinderStep() {
}
//////////////////////////////////////////////////////////////////////////
-float AdSceneGeometry::getPointsDist(Math::Vector3d p1, Math::Vector3d p2) {
+float AdSceneGeometry::getPointsDist(DXVector3 p1, DXVector3 p2) {
if (!directPathExists(&p1, &p2)) {
return -1;
}
- Math::Vector3d vect = p2 - p1;
- return vect.getMagnitude();
+ DXVector3 vect = p2 - p1;
+ return DXVec3Length(&vect);
}
//////////////////////////////////////////////////////////////////////////
@@ -873,7 +871,7 @@ bool compareLights(const Light3D *light1, const Light3D *light2) {
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::enableLights(Math::Vector3d point, BaseArray<char *> &ignoreLights) {
+bool AdSceneGeometry::enableLights(DXVector3 point, BaseArray<char *> &ignoreLights) {
const int maxLightCount = 100;
int activeLightCount = 0;
@@ -902,16 +900,16 @@ bool AdSceneGeometry::enableLights(Math::Vector3d point, BaseArray<char *> &igno
continue;
}
- Math::Vector3d dif;
+ DXVector3 dif;
if (_lights[i]->_isSpotlight) {
- Math::Vector3d dir = _lights[i]->_target - _lights[i]->_position;
+ DXVector3 dir = _lights[i]->_target - _lights[i]->_position;
dif = (_lights[i]->_position + dir * 0.75f) - point;
} else {
dif = _lights[i]->_position - point;
}
- _lights[i]->_distance = dif.getMagnitude();
+ _lights[i]->_distance = fabs(DXVec3Length(&dif));
activeLights.push_back(_lights[i]);
}
@@ -965,12 +963,12 @@ bool AdSceneGeometry::enableLights(Math::Vector3d point, BaseArray<char *> &igno
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::correctTargetPoint(const Math::Vector3d &source, Math::Vector3d *target) {
+bool AdSceneGeometry::correctTargetPoint(const DXVector3 &source, DXVector3 *target) {
// the source parameter is not even used in wme3d
int i;
int MaxLen = 1000;
int Step = 10;
- Math::Vector3d newTarget;
+ DXVector3 newTarget;
int lenLeft = 0;
int lenRight = 0;
@@ -980,7 +978,7 @@ bool AdSceneGeometry::correctTargetPoint(const Math::Vector3d &source, Math::Vec
// left
newTarget = *target;
for (i = 1; i <= MaxLen; i += Step) {
- newTarget.x() -= i;
+ newTarget._x -= i;
if (!directPathExists(target, &newTarget)) {
lenLeft = i;
break;
@@ -990,7 +988,7 @@ bool AdSceneGeometry::correctTargetPoint(const Math::Vector3d &source, Math::Vec
// right
newTarget = *target;
for (i = 1; i <= MaxLen; i += Step) {
- newTarget.x() += i;
+ newTarget._x += i;
if (!directPathExists(target, &newTarget)) {
lenRight = i;
break;
@@ -1000,7 +998,7 @@ bool AdSceneGeometry::correctTargetPoint(const Math::Vector3d &source, Math::Vec
// up
newTarget = *target;
for (i = 1; i <= MaxLen; i += Step) {
- newTarget.z() -= i;
+ newTarget._z -= i;
if (!directPathExists(target, &newTarget)) {
lenUp = i;
break;
@@ -1010,7 +1008,7 @@ bool AdSceneGeometry::correctTargetPoint(const Math::Vector3d &source, Math::Vec
// down
newTarget = *target;
for (i = 1; i <= MaxLen; i += Step) {
- newTarget.z() += i;
+ newTarget._z += i;
if (!directPathExists(target, &newTarget)) {
lenDown = i;
break;
@@ -1049,9 +1047,9 @@ bool AdSceneGeometry::correctTargetPoint(const Math::Vector3d &source, Math::Vec
}
if (abs(offsetX) < abs(offsetZ)) {
- target->x() += offsetX;
+ target->_x += offsetX;
} else {
- target->z() += offsetZ;
+ target->_z += offsetZ;
}
return true;
@@ -1161,13 +1159,13 @@ uint32 AdSceneGeometry::getLightColor(const char *lightName) {
}
//////////////////////////////////////////////////////////////////////////
-Math::Vector3d AdSceneGeometry::getLightPos(const char *lightName) {
+DXVector3 AdSceneGeometry::getLightPos(const char *lightName) {
for (uint i = 0; i < _lights.size(); i++) {
if (scumm_stricmp(lightName, _lights[i]->getName()) == 0) {
return _lights[i]->_position;
}
}
- return Math::Vector3d(0, 0, 0);
+ return DXVector3(0, 0, 0);
}
//////////////////////////////////////////////////////////////////////////
@@ -1330,15 +1328,15 @@ bool AdSceneGeometry::persist(BasePersistenceManager *persistMgr) {
}
//////////////////////////////////////////////////////////////////////////
-bool AdSceneGeometry::convert3Dto2D(Math::Vector3d *position, int32 *x, int32 *y) {
+bool AdSceneGeometry::convert3Dto2D(DXVector3 *position, int32 *x, int32 *y) {
DXMatrix worldMat;
DXMatrixIdentity(&worldMat);
- DXMatrix projMat = DXMatrix(_lastProjMat.getData());
+ DXMatrix projMat = DXMatrix(_lastProjMat);
DXMatrixTranspose(&projMat, &projMat);
- DXMatrix viewMat = DXMatrix(_lastViewMat.getData());
+ DXMatrix viewMat = DXMatrix(_lastViewMat);
DXMatrixTranspose(&viewMat, &viewMat);
- DXVector3 vect2D, pos = DXVector3(position->x(), position->y(), position->z());
+ DXVector3 vect2D, pos = DXVector3(position->_x, position->_y, position->_z);
DXVec3Project(&vect2D, &pos, &_drawingViewport, &projMat, &viewMat, &worldMat);
*x = vect2D._x + _lastScrollX;
*y = vect2D._y + _lastScrollY;
diff --git a/engines/wintermute/ad/ad_scene_geometry.h b/engines/wintermute/ad/ad_scene_geometry.h
index bd77c378da7..e8380167fc4 100644
--- a/engines/wintermute/ad/ad_scene_geometry.h
+++ b/engines/wintermute/ad/ad_scene_geometry.h
@@ -53,18 +53,18 @@ public:
bool dropWaypoints();
bool setLightColor(const char *lightName, uint32 color);
uint32 getLightColor(const char *lightName);
- Math::Vector3d getLightPos(const char *lightName);
+ DXVector3 getLightPos(const char *lightName);
bool enableNode(const char *nodeName, bool enable = true);
bool isNodeEnabled(const char *nodeName);
bool enableLight(const char *lightName, bool enable = true);
bool isLightEnabled(const char *lightName);
DECLARE_PERSISTENT(AdSceneGeometry, BaseObject)
- bool correctTargetPoint(const Math::Vector3d &source, Math::Vector3d *target);
+ bool correctTargetPoint(const DXVector3 &source, DXVector3 *target);
bool _lastValuesInitialized;
- Math::Matrix4 _lastWorldMat;
- Math::Matrix4 _lastViewMat;
- Math::Matrix4 _lastProjMat;
+ DXMatrix _lastWorldMat;
+ DXMatrix _lastViewMat;
+ DXMatrix _lastProjMat;
int _lastOffsetX;
int _lastOffsetY;
Rect32 _drawingViewport;
@@ -72,26 +72,26 @@ public:
int _lastScrollY;
bool createLights();
- bool enableLights(Math::Vector3d Point, BaseArray<char *> &IgnoreLights);
+ bool enableLights(DXVector3 Point, BaseArray<char *> &IgnoreLights);
bool initLoop();
- float getPointsDist(Math::Vector3d p1, Math::Vector3d p2);
+ float getPointsDist(DXVector3 p1, DXVector3 p2);
void pathFinderStep();
- bool getPath(Math::Vector3d source, Math::Vector3d target, AdPath3D *path, bool rerun = false);
- bool convert2Dto3D(int x, int y, Math::Vector3d *pos);
- bool convert2Dto3DTolerant(int x, int y, Math::Vector3d *pos);
- bool convert3Dto2D(Math::Vector3d *pos, int32 *x, int32 *y);
+ bool getPath(DXVector3 source, DXVector3 target, AdPath3D *path, bool rerun = false);
+ bool convert2Dto3D(int x, int y, DXVector3 *pos);
+ bool convert2Dto3DTolerant(int x, int y, DXVector3 *pos);
+ bool convert3Dto2D(DXVector3 *pos, int32 *x, int32 *y);
BaseSprite *_wptMarker;
float _waypointHeight;
- bool directPathExists(Math::Vector3d *p1, Math::Vector3d *p2);
- float getHeightAt(Math::Vector3d pos, float Ttlerance = 0.0f, bool *intFound = NULL);
+ bool directPathExists(DXVector3 *p1, DXVector3 *p2);
+ float getHeightAt(DXVector3 pos, float Ttlerance = 0.0f, bool *intFound = NULL);
bool storeDrawingParams();
bool render(bool render);
bool renderShadowGeometry();
- Math::Matrix4 *getViewMatrix();
- Math::Matrix4 _viewMatrix;
+ DXMatrix *getViewMatrix();
+ DXMatrix _viewMatrix;
bool setActiveCamera(const char *camera, float fov, float nearClipPlane, float farClipPlane);
bool setActiveCamera(int camera, float fow, float nearClipPlane, float farClipPlane);
//bool SetActiveCameraTwin(char* Camera);
@@ -117,12 +117,12 @@ public:
private:
AdGeomExt *getGeometryExtension(char *filename);
- Math::Vector3d getBlockIntersection(Math::Vector3d *p1, Math::Vector3d *p2);
+ DXVector3 getBlockIntersection(DXVector3 *p1, DXVector3 *p2);
bool _PFReady;
- Math::Vector3d _PFSource;
- Math::Vector3d _PFTarget;
+ DXVector3 _PFSource;
+ DXVector3 _PFTarget;
AdPath3D *_PFTargetPath;
- Math::Vector3d _PFAlternateTarget;
+ DXVector3 _PFAlternateTarget;
float _PFAlternateDist;
bool _PFRerun;
BaseArray<AdPathPoint3D *> _PFPath;
diff --git a/engines/wintermute/ad/ad_waypoint_group3d.cpp b/engines/wintermute/ad/ad_waypoint_group3d.cpp
index 4688a903148..d32fda0b60d 100644
--- a/engines/wintermute/ad/ad_waypoint_group3d.cpp
+++ b/engines/wintermute/ad/ad_waypoint_group3d.cpp
@@ -47,27 +47,27 @@ AdWaypointGroup3D::~AdWaypointGroup3D() {
//////////////////////////////////////////////////////////////////////////
bool AdWaypointGroup3D::addFromMesh(Mesh3DS *mesh) {
- Math::Vector3d min = Math::Vector3d(0, 0, 0);
- Math::Vector3d max = Math::Vector3d(0, 0, 0);
+ DXVector3 min = DXVector3(0, 0, 0);
+ DXVector3 max = DXVector3(0, 0, 0);
if (mesh->vertexCount() > 0) {
min = max = mesh->getVertexPosition(0);
}
for (int i = 0; i < mesh->vertexCount(); i++) {
- min.x() = MIN(min.x(), mesh->getVertexPosition(i)[0]);
- min.y() = MIN(min.y(), mesh->getVertexPosition(i)[1]);
- min.z() = MIN(min.z(), mesh->getVertexPosition(i)[2]);
+ min._x = MIN(min._x, mesh->getVertexPosition(i)[0]);
+ min._y = MIN(min._y, mesh->getVertexPosition(i)[1]);
+ min._z = MIN(min._z, mesh->getVertexPosition(i)[2]);
- max.x() = MAX(max.x(), mesh->getVertexPosition(i)[0]);
- max.y() = MAX(max.y(), mesh->getVertexPosition(i)[1]);
- max.z() = MAX(max.z(), mesh->getVertexPosition(i)[2]);
+ max._x = MAX(max._x, mesh->getVertexPosition(i)[0]);
+ max._y = MAX(max._y, mesh->getVertexPosition(i)[1]);
+ max._z = MAX(max._z, mesh->getVertexPosition(i)[2]);
}
- Math::Vector3d *vect = new Math::Vector3d;
- vect->x() = min.x() + (max.x() - min.x()) / 2;
- vect->y() = min.y() + (max.y() - min.y()) / 2;
- vect->z() = min.z() + (max.z() - min.z()) / 2;
+ DXVector3 *vect = new DXVector3;
+ vect->_x = min._x + (max._x - min._x) / 2;
+ vect->_y = min._y + (max._y - min._y) / 2;
+ vect->_z = min._z + (max._z - min._z) / 2;
_points.add(vect);
diff --git a/engines/wintermute/ad/ad_waypoint_group3d.h b/engines/wintermute/ad/ad_waypoint_group3d.h
index e0c2fb2af57..74f82f3ede7 100644
--- a/engines/wintermute/ad/ad_waypoint_group3d.h
+++ b/engines/wintermute/ad/ad_waypoint_group3d.h
@@ -47,7 +47,7 @@ public:
bool addFromMesh(Mesh3DS *mesh);
AdWaypointGroup3D(BaseGame *inGame);
virtual ~AdWaypointGroup3D();
- BaseArray<Math::Vector3d *> _points;
+ BaseArray<DXVector3 *> _points;
};
}
diff --git a/engines/wintermute/base/base_object.cpp b/engines/wintermute/base/base_object.cpp
index 54c5d66bff0..741c9249443 100644
--- a/engines/wintermute/base/base_object.cpp
+++ b/engines/wintermute/base/base_object.cpp
@@ -102,16 +102,16 @@ BaseObject::BaseObject(BaseGame *inGame) : BaseScriptHolder(inGame) {
#ifdef ENABLE_WME3D
_xmodel = nullptr;
_shadowModel = nullptr;
- _posVector = Math::Vector3d(0.0f, 0.0f, 0.0f);
+ _posVector = DXVector3(0.0f, 0.0f, 0.0f);
_angle = 0.0f;
_scale3D = 1.0f;
- _worldMatrix.setToIdentity();
+ DXMatrixIdentity(&_worldMatrix);
_shadowImage = nullptr;
_shadowSize = 10.0f;
_shadowType = SHADOW_NONE;
_shadowColor = 0x80000000;
- _shadowLightPos = Math::Vector3d(-40.0f, 200.0f, -40.0f);
+ _shadowLightPos = DXVector3(-40.0f, 200.0f, -40.0f);
_drawBackfaces = true;
#endif
@@ -564,7 +564,7 @@ bool BaseObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
double y = stack->pop()->getFloat();
double z = stack->pop()->getFloat();
// invert z coordinate because of OpenGL coordinate system
- _shadowLightPos = Math::Vector3d(x, y, -z);
+ _shadowLightPos = DXVector3(x, y, -z);
stack->pushNULL();
return STATUS_OK;
@@ -1369,30 +1369,27 @@ bool BaseObject::afterMove() {
}
#ifdef ENABLE_WME3D
-bool BaseObject::getMatrix(Math::Matrix4 *model, Math::Vector3d *pos) {
- if (pos == nullptr) {
- pos = &_posVector;
+bool BaseObject::getMatrix(DXMatrix *modelMatrix, DXVector3 *posVect) {
+ if (posVect == nullptr) {
+ posVect = &_posVector;
}
- DXVector3 posVect = DXVector3(pos->x(), pos->y(), pos->z());
- DXMatrix modelMatrix;
DXMatrix matRot, matScale, matTrans;
DXMatrixRotationYawPitchRoll(&matRot, degToRad(_angle), 0, 0);
DXMatrixScaling(&matScale, _scale3D, _scale3D, _scale3D);
- DXMatrixTranslation(&matTrans, posVect._x, posVect._y, posVect._z);
- DXMatrixMultiply(&modelMatrix, &matRot, &matScale);
- DXMatrixMultiply(&modelMatrix, &modelMatrix, &matTrans);
+ DXMatrixTranslation(&matTrans, posVect->_x, posVect->_y, posVect->_z);
+ DXMatrixMultiply(modelMatrix, &matRot, &matScale);
+ DXMatrixMultiply(modelMatrix, modelMatrix, &matTrans);
- model->setData(modelMatrix._m4x4);
- model->transpose();
+ DXMatrixTranspose(modelMatrix, modelMatrix);
return true;
}
//////////////////////////////////////////////////////////////////////////
bool BaseObject::renderModel() {
- Math::Matrix4 objectMat;
+ DXMatrix objectMat;
getMatrix(&objectMat);
_gameRef->_renderer3D->setWorldTransform(objectMat);
diff --git a/engines/wintermute/base/base_object.h b/engines/wintermute/base/base_object.h
index e13606654f0..dbdc223faa6 100644
--- a/engines/wintermute/base/base_object.h
+++ b/engines/wintermute/base/base_object.h
@@ -149,14 +149,14 @@ public:
float _angle;
XModel *_xmodel;
XModel *_shadowModel;
- Math::Matrix4 _worldMatrix;
- Math::Vector3d _posVector;
- bool getMatrix(Math::Matrix4 *modelMatrix, Math::Vector3d *posVect = nullptr);
+ DXMatrix _worldMatrix;
+ DXVector3 _posVector;
+ bool getMatrix(DXMatrix *modelMatrix, DXVector3 *posVect = nullptr);
uint32 _shadowColor;
BaseSurface *_shadowImage;
float _shadowSize;
float _scale3D;
- Math::Vector3d _shadowLightPos;
+ DXVector3 _shadowLightPos;
bool _drawBackfaces;
TShadowType _shadowType;
diff --git a/engines/wintermute/base/base_persistence_manager.cpp b/engines/wintermute/base/base_persistence_manager.cpp
index 4e07a9099b6..7ab5c206c4f 100644
--- a/engines/wintermute/base/base_persistence_manager.cpp
+++ b/engines/wintermute/base/base_persistence_manager.cpp
@@ -826,29 +826,6 @@ bool BasePersistenceManager::transferVector2(const char *name, Vector2 *val) {
#ifdef ENABLE_WME3D
//////////////////////////////////////////////////////////////////////////
// Vector3
-bool BasePersistenceManager::transferVector3d(const char *name, Math::Vector3d *val) {
- if (_saving) {
- putFloat(val->x());
- putFloat(val->y());
- putFloat(val->z());
-
- if (_saveStream->err()) {
- return STATUS_FAILED;
- }
-
- return STATUS_OK;
- } else {
- val->x() = getFloat();
- val->y() = getFloat();
- val->z() = getFloat();
-
- if (_loadStream->err()) {
- return STATUS_FAILED;
- }
-
- return STATUS_OK;
- }
-}
bool BasePersistenceManager::transferVector3d(const char *name, DXVector3 *val) {
if (_saving) {
putFloat(val->_x);
@@ -875,33 +852,6 @@ bool BasePersistenceManager::transferVector3d(const char *name, DXVector3 *val)
//////////////////////////////////////////////////////////////////////////
// Matrix4
-bool BasePersistenceManager::transferMatrix4(const char *name, Math::Matrix4 *val) {
- if (_saving) {
- for (int r = 0; r < 4; ++r) {
- for (int c = 0; c < 4; ++c) {
- putFloat((*val)(r, c));
- }
- }
-
- if (_saveStream->err()) {
- return STATUS_FAILED;
- }
-
- return STATUS_OK;
- } else {
- for (int r = 0; r < 4; ++r) {
- for (int c = 0; c < 4; ++c) {
- (*val)(r, c) = getFloat();
- }
- }
-
- if (_loadStream->err()) {
- return STATUS_FAILED;
- }
-
- return STATUS_OK;
- }
-}
bool BasePersistenceManager::transferMatrix4(const char *name, DXMatrix *val) {
if (_saving) {
for (int i = 0; i < 16; ++i) {
diff --git a/engines/wintermute/base/base_persistence_manager.h b/engines/wintermute/base/base_persistence_manager.h
index 36c04a6c2ed..6eb9b0a35e0 100644
--- a/engines/wintermute/base/base_persistence_manager.h
+++ b/engines/wintermute/base/base_persistence_manager.h
@@ -100,8 +100,6 @@ public:
bool transferVector2(const char *name, Vector2 *val);
#ifdef ENABLE_WME3D
bool transferVector3d(const char *name, DXVector3 *val);
- bool transferVector3d(const char *name, Math::Vector3d *val);
- bool transferMatrix4(const char *name, Math::Matrix4 *val);
bool transferMatrix4(const char *name, DXMatrix *val);
bool transferAngle(const char *name, float *val);
#endif
diff --git a/engines/wintermute/base/gfx/3dcamera.cpp b/engines/wintermute/base/gfx/3dcamera.cpp
index 8b132627752..c4d195fdad6 100644
--- a/engines/wintermute/base/gfx/3dcamera.cpp
+++ b/engines/wintermute/base/gfx/3dcamera.cpp
@@ -41,8 +41,8 @@ namespace Wintermute {
//////////////////////////////////////////////////////////////////////////
Camera3D::Camera3D(BaseGame *inGame) : BaseNamedObject(inGame) {
- _position = Math::Vector3d(0.0f, 0.0f, 0.0f);
- _target = Math::Vector3d(0.0f, 0.0f, 0.0f);
+ _position = DXVector3(0.0f, 0.0f, 0.0f);
+ _target = DXVector3(0.0f, 0.0f, 0.0f);
_bank = 0.0f;
_fov = _origFov = degToRad(45.0f);
_nearClipPlane = _farClipPlane = -1.0f;
@@ -53,7 +53,7 @@ Camera3D::~Camera3D() {
}
//////////////////////////////////////////////////////////////////////////
-bool Camera3D::getViewMatrix(Math::Matrix4 *viewMatrix) {
+bool Camera3D::getViewMatrix(DXMatrix *viewMatrix) {
DXVector3 up = DXVector3(0.0f, 1.0f, 0.0f);
if (_bank != 0) {
@@ -62,17 +62,17 @@ bool Camera3D::getViewMatrix(Math::Matrix4 *viewMatrix) {
DXVec3TransformCoord(&up, &up, &rot);
}
- DXVector3 position = DXVector3(_position.getData());
- DXVector3 target = DXVector3(_target.getData());
- DXMatrix view = DXMatrix(viewMatrix->getData());
+ DXVector3 position = DXVector3(_position);
+ DXVector3 target = DXVector3(_target);
+ DXMatrix view = DXMatrix(*viewMatrix);
DXMatrixLookAtRH(&view, &position, &target, &up);
- viewMatrix->setData(view);
+ *viewMatrix = view;
return true;
}
//////////////////////////////////////////////////////////////////////////
-void Camera3D::setupPos(Math::Vector3d pos, Math::Vector3d target, float bank) {
+void Camera3D::setupPos(DXVector3 pos, DXVector3 target, float bank) {
_position = pos;
_target = target;
_bank = bank;
@@ -80,7 +80,7 @@ void Camera3D::setupPos(Math::Vector3d pos, Math::Vector3d target, float bank) {
//////////////////////////////////////////////////////////////////////////
void Camera3D::rotateView(float x, float y, float z) {
- Math::Vector3d vVector; // Vector for the position/view.
+ DXVector3 vVector; // Vector for the position/view.
// Get our view vector (The direciton we are facing)
vVector = _target - _position; // This gets the direction of the view
@@ -88,45 +88,45 @@ void Camera3D::rotateView(float x, float y, float z) {
// Rotate the view along the desired axis
if (x) {
// Rotate the view vector up or down, then add it to our position
- _target.z() = (float)(_position.z() + sin(x) * vVector.y() + cos(x) * vVector.z());
- _target.y() = (float)(_position.y() + cos(x) * vVector.y() - sin(x) * vVector.z());
+ _target._z = (float)(_position._z + sin(x) * vVector._y + cos(x) * vVector._z);
+ _target._y = (float)(_position._y + cos(x) * vVector._y - sin(x) * vVector._z);
}
if (y) {
// Rotate the view vector right or left, then add it to our position
- _target.z() = (float)(_position.z() + sin(y) * vVector.x() + cos(y) * vVector.z());
- _target.x() = (float)(_position.x() + cos(y) * vVector.x() - sin(y) * vVector.z());
+ _target._z = (float)(_position._z + sin(y) * vVector._x + cos(y) * vVector._z);
+ _target._x = (float)(_position._x + cos(y) * vVector._x - sin(y) * vVector._z);
}
if (z) {
// Rotate the view vector diagnally right or diagnally down, then add it to our position
- _target.x() = (float)(_position.x() + sin(z) * vVector.y() + cos(z) * vVector.x());
- _target.y() = (float)(_position.y() + cos(z) * vVector.y() - sin(z) * vVector.x());
+ _target._x = (float)(_position._x + sin(z) * vVector._y + cos(z) * vVector._x);
+ _target._y = (float)(_position._y + cos(z) * vVector._y - sin(z) * vVector._x);
}
}
//////////////////////////////////////////////////////////////////////////
void Camera3D::move(float speed) {
- Math::Vector3d vector; // Init a vector for our view
+ DXVector3 vector; // Init a vector for our view
// Get our view vector (The direciton we are facing)
vector = _target - _position; // This gets the direction of the view
- _position.x() += vector.x() * speed; // Add our acceleration to our position's X
- _position.z() += vector.z() * speed; // Add our acceleration to our position's Z
- _target.x() += vector.x() * speed; // Add our acceleration to our view's X
- _target.z() += vector.z() * speed; // Add our acceleration to our view's Z
+ _position._x += vector._x * speed; // Add our acceleration to our position's X
+ _position._z += vector._z * speed; // Add our acceleration to our position's Z
+ _target._x += vector._x * speed; // Add our acceleration to our view's X
+ _target._z += vector._z * speed; // Add our acceleration to our view's Z
}
bool Camera3D::loadFrom3DS(Common::MemoryReadStream &fileStream) {
uint32 wholeChunkSize = fileStream.readUint32LE();
int32 end = fileStream.pos() + wholeChunkSize - 6;
- _position.x() = fileStream.readFloatLE();
- _position.z() = -fileStream.readFloatLE();
- _position.y() = fileStream.readFloatLE();
+ _position._x = fileStream.readFloatLE();
+ _position._z = -fileStream.readFloatLE();
+ _position._y = fileStream.readFloatLE();
- _target.x() = fileStream.readFloatLE();
- _target.z() = -fileStream.readFloatLE();
- _target.y() = fileStream.readFloatLE();
+ _target._x = fileStream.readFloatLE();
+ _target._z = -fileStream.readFloatLE();
+ _target._y = fileStream.readFloatLE();
_bank = fileStream.readFloatLE();
diff --git a/engines/wintermute/base/gfx/3dcamera.h b/engines/wintermute/base/gfx/3dcamera.h
index 5f160ab9002..f95b226be2b 100644
--- a/engines/wintermute/base/gfx/3dcamera.h
+++ b/engines/wintermute/base/gfx/3dcamera.h
@@ -31,6 +31,7 @@
#include "common/memstream.h"
#include "engines/wintermute/base/base_named_object.h"
+#include "engines/wintermute/base/gfx/xmath.h"
#include "math/matrix4.h"
#include "math/vector3d.h"
@@ -41,13 +42,13 @@ class Camera3D : public BaseNamedObject {
public:
void move(float speed);
void rotateView(float x, float y, float z);
- void setupPos(Math::Vector3d pos, Math::Vector3d target, float Bank = 0);
- bool getViewMatrix(Math::Matrix4 *viewMatrix);
+ void setupPos(DXVector3 pos, DXVector3 target, float bank = 0);
+ bool getViewMatrix(DXMatrix *viewMatrix);
Camera3D(BaseGame *inGame);
virtual ~Camera3D();
- Math::Vector3d _position;
- Math::Vector3d _target;
+ DXVector3 _position;
+ DXVector3 _target;
float _bank;
float _fov;
float _origFov;
diff --git a/engines/wintermute/base/gfx/3dlight.cpp b/engines/wintermute/base/gfx/3dlight.cpp
index 5d498a0d42e..9f0066b82bc 100644
--- a/engines/wintermute/base/gfx/3dlight.cpp
+++ b/engines/wintermute/base/gfx/3dlight.cpp
@@ -41,8 +41,8 @@ namespace Wintermute {
//////////////////////////////////////////////////////////////////////////
Light3D::Light3D(BaseGame *inGame) : BaseScriptable(inGame, false, false) {
_diffuseColor = BYTETORGBA(255, 255, 255, 255);
- _position = Math::Vector3d(0, 0, 0);
- _target = Math::Vector3d(0, 0, 0);
+ _position = DXVector3(0, 0, 0);
+ _target = DXVector3(0, 0, 0);
_isSpotlight = false;
_falloff = 0;
_active = true;
@@ -57,11 +57,11 @@ Light3D::~Light3D() {
//////////////////////////////////////////////////////////////////////////
bool Light3D::setLight(int index) {
- Math::Vector4d diffuse;
- diffuse.getData()[0] = RGBCOLGetR(_diffuseColor) / 256.0f;
- diffuse.getData()[1] = RGBCOLGetG(_diffuseColor) / 256.0f;
- diffuse.getData()[2] = RGBCOLGetB(_diffuseColor) / 256.0f;
- diffuse.getData()[3] = 1.0f;
+ DXVector4 diffuse;
+ diffuse._x = RGBCOLGetR(_diffuseColor) / 256.0f;
+ diffuse._y = RGBCOLGetG(_diffuseColor) / 256.0f;
+ diffuse._z = RGBCOLGetB(_diffuseColor) / 256.0f;
+ diffuse._w = 1.0f;
_gameRef->_renderer3D->setLightParameters(index, _position, _target - _position, diffuse, _isSpotlight);
@@ -73,9 +73,9 @@ bool Light3D::setLight(int index) {
}
//////////////////////////////////////////////////////////////////////////
-bool Light3D::getViewMatrix(Math::Matrix4 *viewMatrix) {
- Math::Vector3d up = Math::Vector3d(0.0f, 1.0f, 0.0f);
- *viewMatrix = Math::makeLookAtMatrix(_position, _target, up);
+bool Light3D::getViewMatrix(DXMatrix *viewMatrix) {
+ DXVector3 up = DXVector3(0.0f, 1.0f, 0.0f);
+ DXMatrixLookAtRH(viewMatrix, &_position, &_target, &up);
return true;
}
@@ -90,9 +90,9 @@ bool Light3D::loadFrom3DS(Common::MemoryReadStream &fileStream) {
uint32 wholeChunkSize = fileStream.readUint32LE();
int32 end = fileStream.pos() + wholeChunkSize - 6;
- _position.x() = fileStream.readFloatLE();
- _position.z() = -fileStream.readFloatLE();
- _position.y() = fileStream.readFloatLE();
+ _position._x = fileStream.readFloatLE();
+ _position._z = -fileStream.readFloatLE();
+ _position._y = fileStream.readFloatLE();
while (fileStream.pos() < end) {
uint16 chunkId = fileStream.readUint16LE();
@@ -100,9 +100,9 @@ bool Light3D::loadFrom3DS(Common::MemoryReadStream &fileStream) {
switch (chunkId) {
case SPOTLIGHT:
- _target.x() = fileStream.readFloatLE();
- _target.z() = -fileStream.readFloatLE();
- _target.y() = fileStream.readFloatLE();
+ _target._x = fileStream.readFloatLE();
+ _target._z = -fileStream.readFloatLE();
+ _target._y = fileStream.readFloatLE();
// this is appearently not used
fileStream.readFloatLE();
diff --git a/engines/wintermute/base/gfx/3dlight.h b/engines/wintermute/base/gfx/3dlight.h
index 49040b1b3bb..d18921e7408 100644
--- a/engines/wintermute/base/gfx/3dlight.h
+++ b/engines/wintermute/base/gfx/3dlight.h
@@ -41,12 +41,12 @@ namespace Wintermute {
class Light3D : public BaseScriptable {
public:
bool persist(BasePersistenceManager *persistMgr);
- bool getViewMatrix(Math::Matrix4 *viewMatrix);
+ bool getViewMatrix(DXMatrix *viewMatrix);
Light3D(BaseGame *inGame);
virtual ~Light3D();
uint32 _diffuseColor;
- Math::Vector3d _position;
- Math::Vector3d _target;
+ DXVector3 _position;
+ DXVector3 _target;
bool _isSpotlight;
bool _active;
float _falloff;
diff --git a/engines/wintermute/base/gfx/3dmesh.h b/engines/wintermute/base/gfx/3dmesh.h
index 0a7c7dbcc73..f889e1a992a 100644
--- a/engines/wintermute/base/gfx/3dmesh.h
+++ b/engines/wintermute/base/gfx/3dmesh.h
@@ -59,7 +59,7 @@ protected:
uint16 _vertexCount;
uint16 *_indexData;
uint16 _indexCount;
- Math::Vector4d _color;
+ DXVector4 _color;
};
} // namespace Wintermute
diff --git a/engines/wintermute/base/gfx/3dshadow_volume.cpp b/engines/wintermute/base/gfx/3dshadow_volume.cpp
index d196ba33ad6..eb7a1591c75 100644
--- a/engines/wintermute/base/gfx/3dshadow_volume.cpp
+++ b/engines/wintermute/base/gfx/3dshadow_volume.cpp
@@ -48,15 +48,14 @@ bool ShadowVolume::reset() {
}
//////////////////////////////////////////////////////////////////////////^M
-bool ShadowVolume::addMesh(DXVector3 *mesh, uint32 *adjacency, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth) {
+bool ShadowVolume::addMesh(DXMesh *mesh, uint32 *adjacency, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth) {
// TODO
return true;
}
//////////////////////////////////////////////////////////////////////////
-void ShadowVolume::addVertex(const DXVector3 &vertex) {
- Math::Vector3d vec = Math::Vector3d(vertex._x, vertex._y, vertex._z);
- _vertices.add(vec);
+void ShadowVolume::addVertex(DXVector3 &vertex) {
+ _vertices.add(vertex);
}
//////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/base/gfx/3dshadow_volume.h b/engines/wintermute/base/gfx/3dshadow_volume.h
index e10562476f2..199fc4c4267 100644
--- a/engines/wintermute/base/gfx/3dshadow_volume.h
+++ b/engines/wintermute/base/gfx/3dshadow_volume.h
@@ -29,6 +29,8 @@
#define WINTERMUTE_3D_SHADOW_VOLUME_H
#include "engines/wintermute/base/base.h"
+#include "engines/wintermute/base/gfx/xbuffer.h"
+#include "engines/wintermute/base/gfx/xmesh.h"
#include "engines/wintermute/base/gfx/xmath.h"
#include "engines/wintermute/coll_templ.h"
#include "math/matrix4.h"
@@ -51,8 +53,8 @@ public:
ShadowVolume(BaseGame *inGame);
virtual ~ShadowVolume();
- bool addMesh(DXVector3 *mesh, uint32 *adjacency, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);
- void addVertex(const DXVector3 &vertex);
+ bool addMesh(DXMesh *mesh, uint32 *adjacency, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);
+ void addVertex(DXVector3 &vertex);
bool reset();
virtual bool renderToStencilBuffer() = 0;
@@ -61,7 +63,7 @@ public:
bool setColor(uint32 color);
protected:
- BaseArray<Math::Vector3d> _vertices; // Vertex data for rendering shadow volume
+ BaseArray<DXVector3> _vertices; // Vertex data for rendering shadow volume
uint32 _color;
private:
diff --git a/engines/wintermute/base/gfx/base_renderer3d.h b/engines/wintermute/base/gfx/base_renderer3d.h
index 80fdada9e80..e79afb2111a 100644
--- a/engines/wintermute/base/gfx/base_renderer3d.h
+++ b/engines/wintermute/base/gfx/base_renderer3d.h
@@ -38,6 +38,8 @@
#include "graphics/opengl/system_headers.h"
+#include "engines/wintermute/base/gfx/xmath.h"
+
#endif
namespace Wintermute {
@@ -73,7 +75,7 @@ public:
virtual bool enableShadows() = 0;
virtual bool disableShadows() = 0;
virtual bool usingStencilBuffer() = 0;
- virtual void displayShadow(BaseObject *object, const Math::Vector3d &light, bool lightPosRelative) = 0;
+ virtual void displayShadow(BaseObject *object, const DXVector3 *light, bool lightPosRelative) = 0;
//HRESULT InvalidateTexture(LPDIRECT3DTEXTURE Texture);
virtual void setSpriteBlendMode(Graphics::TSpriteBlendMode blendMode) = 0;
@@ -117,8 +119,8 @@ public:
virtual void enableLight(int index) = 0;
virtual void disableLight(int index) = 0;
- virtual void setLightParameters(int index, const Math::Vector3d &position, const Math::Vector3d &direction,
- const Math::Vector4d &diffuse, bool spotlight) = 0;
+ virtual void setLightParameters(int index, const DXVector3 &position, const DXVector3 &direction,
+ const DXVector4 &diffuse, bool spotlight) = 0;
virtual void enableCulling() = 0;
virtual void disableCulling() = 0;
@@ -129,20 +131,20 @@ public:
virtual bool setProjection2D() = 0;
- virtual bool setWorldTransform(const Math::Matrix4 &transform) = 0;
- virtual bool setViewTransform(const Math::Matrix4 &transform) = 0;
- virtual bool setProjectionTransform(const Math::Matrix4 &transform) = 0;
+ virtual bool setWorldTransform(const DXMatrix &transform) = 0;
+ virtual bool setViewTransform(const DXMatrix &transform) = 0;
+ virtual bool setProjectionTransform(const DXMatrix &transform) = 0;
- void getWorldTransform(Math::Matrix4 &transform) {
- transform = _worldMatrix;
+ void getWorldTransform(DXMatrix *transform) {
+ *transform = _worldMatrix;
}
- void getViewTransform(Math::Matrix4 &transform) {
- transform = _viewMatrix;
+ void getViewTransform(DXMatrix *transform) {
+ *transform = _viewMatrix;
}
- void getProjectionTransform(Math::Matrix4 &transform) {
- transform = _projectionMatrix;
+ void getProjectionTransform(DXMatrix *transform) {
+ *transform = _projectionMatrix;
}
Camera3D *_camera;
@@ -161,9 +163,9 @@ public:
// ScummVM specific methods <--
protected:
- Math::Matrix4 _worldMatrix;
- Math::Matrix4 _viewMatrix;
- Math::Matrix4 _projectionMatrix;
+ DXMatrix _worldMatrix;
+ DXMatrix _viewMatrix;
+ DXMatrix _projectionMatrix;
Rect32 _viewport;
float _fov;
float _nearClipPlane;
diff --git a/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp b/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
index 83852b39b6b..bf766aa7d27 100644
--- a/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
+++ b/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
@@ -116,21 +116,21 @@ void BaseRenderOpenGL3D::disableLight(int index) {
glDisable(GL_LIGHT0 + index);
}
-void BaseRenderOpenGL3D::setLightParameters(int index, const Math::Vector3d &position, const Math::Vector3d &direction, const Math::Vector4d &diffuse, bool spotlight) {
+void BaseRenderOpenGL3D::setLightParameters(int index, const DXVector3 &position, const DXVector3 &direction, const DXVector4 &diffuse, bool spotlight) {
float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
- glLightfv(GL_LIGHT0 + index, GL_DIFFUSE, diffuse.getData());
+ glLightfv(GL_LIGHT0 + index, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0 + index, GL_AMBIENT, zero);
glLightfv(GL_LIGHT0 + index, GL_SPECULAR, zero);
- _lightPositions[index].x() = position.x();
- _lightPositions[index].y() = position.y();
- _lightPositions[index].z() = position.z();
- _lightPositions[index].w() = 1.0f;
+ _lightPositions[index]._x = position._x;
+ _lightPositions[index]._y = position._y;
+ _lightPositions[index]._z = position._z;
+ _lightPositions[index]._w = 1.0f;
if (spotlight) {
_lightDirections[index] = direction;
- glLightfv(GL_LIGHT0 + index, GL_SPOT_DIRECTION, direction.getData());
+ glLightfv(GL_LIGHT0 + index, GL_SPOT_DIRECTION, direction);
glLightf(GL_LIGHT0 + index, GL_SPOT_EXPONENT, 0.0f);
// wme sets the phi angle to 1.0 (in radians)
@@ -159,7 +159,7 @@ bool BaseRenderOpenGL3D::disableShadows() {
return true;
}
-void BaseRenderOpenGL3D::displayShadow(BaseObject *object, const Math::Vector3d &lightPos, bool lightPosRelative) {
+void BaseRenderOpenGL3D::displayShadow(BaseObject *object, const DXVector3 *lightPos, bool lightPosRelative) {
BaseSurface *shadowImage = _gameRef->_shadowImage;
if (object->_shadowImage) {
@@ -187,11 +187,14 @@ void BaseRenderOpenGL3D::displayShadow(BaseObject *object, const Math::Vector3d
rotation(2, 2) = cosOfAngle;
Math::Matrix4 translation;
translation.setToIdentity();
- translation.setPosition(object->_posVector);
+ Math::Vector3d posVector = Math::Vector3d(object->_posVector);
+ translation.setPosition(posVector);
Math::Matrix4 worldTransformation = translation * rotation * scale;
worldTransformation.transpose();
- worldTransformation = worldTransformation * _viewMatrix;
+ Math::Matrix4 viewMatrix;
+ viewMatrix.setData(_viewMatrix);
+ worldTransformation = worldTransformation * viewMatrix;
glLoadMatrixf(worldTransformation.getData());
@@ -214,7 +217,7 @@ void BaseRenderOpenGL3D::displayShadow(BaseObject *object, const Math::Vector3d
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDepthMask(GL_TRUE);
- glLoadMatrixf(_viewMatrix.getData());
+ glLoadMatrixf(_viewMatrix);
}
bool BaseRenderOpenGL3D::usingStencilBuffer() {
@@ -371,9 +374,7 @@ bool BaseRenderOpenGL3D::setProjection() {
matProj.matrix._31 = -(offsetX + (mleft - mright) / 2 - modWidth) / viewportWidth * 2.0f;
matProj.matrix._32 = (offsetY + (mtop - mbottom) / 2 - modHeight) / viewportHeight * 2.0f;
- Math::Matrix4 m;
- m.setData(matProj);
- return setProjectionTransform(m);
+ return setProjectionTransform(matProj);
}
bool BaseRenderOpenGL3D::setProjection2D() {
@@ -385,25 +386,28 @@ bool BaseRenderOpenGL3D::setProjection2D() {
return true;
}
-bool BaseRenderOpenGL3D::setWorldTransform(const Math::Matrix4 &transform) {
+bool BaseRenderOpenGL3D::setWorldTransform(const DXMatrix &transform) {
_worldMatrix = transform;
- Math::Matrix4 tmp = transform;
+ Math::Matrix4 tmp;
+ tmp.setData(transform);
tmp.transpose();
- Math::Matrix4 newModelViewTransform = tmp * _viewMatrix;
+ Math::Matrix4 viewMatrix;
+ viewMatrix.setData(_viewMatrix);
+ Math::Matrix4 newModelViewTransform = tmp * viewMatrix;
glLoadMatrixf(newModelViewTransform.getData());
return true;
}
-bool BaseRenderOpenGL3D::setViewTransform(const Math::Matrix4 &transform) {
+bool BaseRenderOpenGL3D::setViewTransform(const DXMatrix &transform) {
_viewMatrix = transform;
- glLoadMatrixf(transform.getData());
+ glLoadMatrixf(transform);
return true;
}
-bool BaseRenderOpenGL3D::setProjectionTransform(const Math::Matrix4 &transform) {
+bool BaseRenderOpenGL3D::setProjectionTransform(const DXMatrix &transform) {
_projectionMatrix = transform;
glMatrixMode(GL_PROJECTION);
- glLoadMatrixf(transform.getData());
+ glLoadMatrixf(transform);
glMatrixMode(GL_MODELVIEW);
return true;
@@ -530,7 +534,7 @@ bool BaseRenderOpenGL3D::setup3D(Camera3D *camera, bool force) {
if (camera)
_camera = camera;
if (_camera) {
- Math::Matrix4 viewMatrix;
+ DXMatrix viewMatrix;
_camera->getViewMatrix(&viewMatrix);
setViewTransform(viewMatrix);
@@ -553,8 +557,8 @@ bool BaseRenderOpenGL3D::setup3D(Camera3D *camera, bool force) {
}
for (int i = 0; i < getMaxActiveLights(); ++i) {
- glLightfv(GL_LIGHT0 + i, GL_POSITION, _lightPositions[i].getData());
- glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, _lightDirections[i].getData());
+ glLightfv(GL_LIGHT0 + i, GL_POSITION, _lightPositions[i]);
+ glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, _lightDirections[i]);
}
bool fogEnabled;
@@ -782,25 +786,25 @@ void BaseRenderOpenGL3D::renderSceneGeometry(const BaseArray<AdWalkplane *> &pla
if (lights[i]->_active) {
glBegin(GL_LINES);
glColor3f(1.0f, 1.0f, 0.0f);
- Math::Vector3d right = lights[i]->_position + Math::Vector3d(1000.0f, 0.0f, 0.0f);
- Math::Vector3d up = lights[i]->_position + Math::Vector3d(0.0f, 1000.0f, 0.0f);
- Math::Vector3d backward = lights[i]->_position + Math::Vector3d(0.0f, 0.0f, 1000.0f);
- Math::Vector3d left = lights[i]->_position + Math::Vector3d(-1000.0f, 0.0f, 0.0f);
- Math::Vector3d down = lights[i]->_position + Math::Vector3d(0.0f, -1000.0f, 0.0f);
- Math::Vector3d forward = lights[i]->_position + Math::Vector3d(0.0f, 0.0f, -1000.0f);
-
- glVertex3fv(lights[i]->_position.getData());
- glVertex3fv(right.getData());
- glVertex3fv(lights[i]->_position.getData());
- glVertex3fv(up.getData());
- glVertex3fv(lights[i]->_position.getData());
- glVertex3fv(backward.getData());
- glVertex3fv(lights[i]->_position.getData());
- glVertex3fv(left.getData());
- glVertex3fv(lights[i]->_position.getData());
- glVertex3fv(down.getData());
- glVertex3fv(lights[i]->_position.getData());
- glVertex3fv(forward.getData());
+ DXVector3 right = lights[i]->_position + DXVector3(1000.0f, 0.0f, 0.0f);
+ DXVector3 up = lights[i]->_position + DXVector3(0.0f, 1000.0f, 0.0f);
+ DXVector3 backward = lights[i]->_position + DXVector3(0.0f, 0.0f, 1000.0f);
+ DXVector3 left = lights[i]->_position + DXVector3(-1000.0f, 0.0f, 0.0f);
+ DXVector3 down = lights[i]->_position + DXVector3(0.0f, -1000.0f, 0.0f);
+ DXVector3 forward = lights[i]->_position + DXVector3(0.0f, 0.0f, -1000.0f);
+
+ glVertex3fv(lights[i]->_position);
+ glVertex3fv(right);
+ glVertex3fv(lights[i]->_position);
+ glVertex3fv(up);
+ glVertex3fv(lights[i]->_position);
+ glVertex3fv(backward);
+ glVertex3fv(lights[i]->_position);
+ glVertex3fv(left);
+ glVertex3fv(lights[i]->_position);
+ glVertex3fv(down);
+ glVertex3fv(lights[i]->_position);
+ glVertex3fv(forward);
glEnd();
}
}
diff --git a/engines/wintermute/base/gfx/opengl/base_render_opengl3d.h b/engines/wintermute/base/gfx/opengl/base_render_opengl3d.h
index 9c1fd0cd116..d753de851e3 100644
--- a/engines/wintermute/base/gfx/opengl/base_render_opengl3d.h
+++ b/engines/wintermute/base/gfx/opengl/base_render_opengl3d.h
@@ -63,14 +63,14 @@ public:
int getMaxActiveLights() override;
void enableLight(int index) override;
void disableLight(int index) override;
- void setLightParameters(int index, const Math::Vector3d &position, const Math::Vector3d &direction, const Math::Vector4d &diffuse, bool spotlight) override;
+ void setLightParameters(int index, const DXVector3 &position, const DXVector3 &direction, const DXVector4 &diffuse, bool spotlight) override;
void enableCulling() override;
void disableCulling() override;
bool enableShadows() override;
bool disableShadows() override;
- void displayShadow(BaseObject *object, const Math::Vector3d &lightPos, bool lightPosRelative) override;
+ void displayShadow(BaseObject *object, const DXVector3 *lightPos, bool lightPosRelative) override;
bool usingStencilBuffer() override;
void dumpData(const char *filename) override {}
@@ -85,9 +85,9 @@ public:
bool setProjection() override;
bool setProjection2D() override;
- bool setWorldTransform(const Math::Matrix4 &transform) override;
- bool setViewTransform(const Math::Matrix4 &transform) override;
- bool setProjectionTransform(const Math::Matrix4 &transform) override;
+ bool setWorldTransform(const DXMatrix &transform) override;
+ bool setViewTransform(const DXMatrix &transform) override;
+ bool setProjectionTransform(const DXMatrix &transform) override;
bool windowedBlt() override;
@@ -139,8 +139,8 @@ public:
private:
SimpleShadowVertex _simpleShadow[4];
- Common::Array<Math::Vector4d> _lightPositions;
- Common::Array<Math::Vector3d> _lightDirections;
+ Common::Array<DXVector4> _lightPositions;
+ Common::Array<DXVector3> _lightDirections;
};
} // wintermute namespace
diff --git a/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp b/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
index 21943fbd0b8..e455776f52b 100644
--- a/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
+++ b/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
@@ -130,25 +130,32 @@ void BaseRenderOpenGL3DShader::disableLight(int index) {
_xmodelShader->setUniform1f(uniform.c_str(), -1.0f);
}
-void BaseRenderOpenGL3DShader::setLightParameters(int index, const Math::Vector3d &position,
- const Math::Vector3d &direction,
- const Math::Vector4d &diffuse, bool spotlight) {
+void BaseRenderOpenGL3DShader::setLightParameters(int index, const DXVector3 &position,
+ const DXVector3 &direction,
+ const DXVector4 &diffuse, bool spotlight) {
Math::Vector4d position4d;
- position4d.x() = position.x();
- position4d.y() = position.y();
- position4d.z() = position.z();
+ position4d.x() = position._x;
+ position4d.y() = position._y;
+ position4d.z() = position._z;
position4d.w() = 1.0f;
Math::Vector4d direction4d;
- direction4d.x() = direction.x();
- direction4d.y() = direction.y();
- direction4d.z() = direction.z();
+ direction4d.x() = direction._x;
+ direction4d.y() = direction._y;
+ direction4d.z() = direction._z;
direction4d.w() = 0.0f;
if (spotlight) {
direction4d.w() = -1.0f;
}
+ Math::Vector4d diffuse4d;
+ diffuse4d.x() = diffuse._x;
+ diffuse4d.y() = diffuse._y;
+ diffuse4d.z() = diffuse._z;
+ diffuse4d.w() = 0.0f;
+
+
_xmodelShader->use();
Common::String uniform = Common::String::format("lights[%i]._position", index);
@@ -158,7 +165,7 @@ void BaseRenderOpenGL3DShader::setLightParameters(int index, const Math::Vector3
_xmodelShader->setUniform(uniform.c_str(), direction4d);
uniform = Common::String::format("lights[%i]._color", index);
- _xmodelShader->setUniform(uniform.c_str(), diffuse);
+ _xmodelShader->setUniform(uniform.c_str(), diffuse4d);
}
void BaseRenderOpenGL3DShader::enableCulling() {
@@ -251,30 +258,32 @@ bool BaseRenderOpenGL3DShader::disableShadows() {
return true;
}
-void BaseRenderOpenGL3DShader::displayShadow(BaseObject *object, const Math::Vector3d &lightPos, bool lightPosRelative) {
+void BaseRenderOpenGL3DShader::displayShadow(BaseObject *object, const DXVector3 *lightPos, bool lightPosRelative) {
if (_flatShadowMaskShader) {
if (object->_shadowType <= SHADOW_SIMPLE) {
// TODO: Display simple shadow here
return;
}
- Math::Vector3d position = lightPos;
- Math::Vector3d target = object->_posVector;
+ DXVector3 position = *lightPos;
+ Math::Vector3d target = Math::Vector3d(object->_posVector);
if (lightPosRelative) {
- position = object->_posVector + lightPos;
+ position = object->_posVector + *lightPos;
}
- Math::Matrix4 lightViewMatrix = Math::makeLookAtMatrix(position, target, Math::Vector3d(0.0f, 1.0f, 0.0f));
+ Math::Vector3d pos = Math::Vector3d(position);
+ Math::Matrix4 lightViewMatrix = Math::makeLookAtMatrix(pos, target, Math::Vector3d(0.0f, 1.0f, 0.0f));
Math::Matrix4 translation;
- translation.setPosition(-position);
+ translation.setPosition(-pos);
translation.transpose();
lightViewMatrix = translation * lightViewMatrix;
_flatShadowXModelShader->use();
_flatShadowXModelShader->setUniform("viewMatrix", lightViewMatrix);
- Math::Matrix4 tmp = object->_worldMatrix;
+ Math::Matrix4 tmp;
+ tmp.setData(object->_worldMatrix);
tmp.transpose();
_flatShadowXModelShader->setUniform("modelMatrix", tmp);
@@ -308,14 +317,18 @@ void BaseRenderOpenGL3DShader::displayShadow(BaseObject *object, const Math::Vec
Math::Matrix4 shadowPosition;
shadowPosition.setToIdentity();
- shadowPosition.setPosition(object->_posVector);
+ Math::Vector3d posVector = Math::Vector3d(object->_posVector);
+ shadowPosition.setPosition(posVector);
shadowPosition.transpose();
+ Math::Matrix4 viewMatrix, projectionMatrix;
+ viewMatrix.setData(_viewMatrix);
+ projectionMatrix.setData(_projectionMatrix);
_flatShadowMaskShader->use();
_flatShadowMaskShader->setUniform("lightViewMatrix", lightViewMatrix);
_flatShadowMaskShader->setUniform("worldMatrix", shadowPosition);
- _flatShadowMaskShader->setUniform("viewMatrix", _viewMatrix);
- _flatShadowMaskShader->setUniform("projMatrix", _projectionMatrix);
+ _flatShadowMaskShader->setUniform("viewMatrix", viewMatrix);
+ _flatShadowMaskShader->setUniform("projMatrix", projectionMatrix);
_flatShadowMaskShader->setUniform("shadowColor", _flatShadowColor);
glBindBuffer(GL_ARRAY_BUFFER, _flatShadowMaskVBO);
@@ -468,9 +481,7 @@ bool BaseRenderOpenGL3DShader::setProjection() {
matProj.matrix._31 = -(offsetX + (mleft - mright) / 2 - modWidth) / viewportWidth * 2.0f;
matProj.matrix._32 = (offsetY + (mtop - mbottom) / 2 - modHeight) / viewportHeight * 2.0f;
- Math::Matrix4 m;
- m.setData(matProj);
- return setProjectionTransform(m);
+ return setProjectionTransform(matProj);
}
bool BaseRenderOpenGL3DShader::setProjection2D() {
@@ -492,12 +503,15 @@ bool BaseRenderOpenGL3DShader::setProjection2D() {
return true;
}
-bool BaseRenderOpenGL3DShader::setWorldTransform(const Math::Matrix4 &transform) {
+bool BaseRenderOpenGL3DShader::setWorldTransform(const DXMatrix &transform) {
_worldMatrix = transform;
- Math::Matrix4 tmp = transform;
+ Math::Matrix4 tmp;
+ tmp.setData(transform);
tmp.transpose();
- Math::Matrix4 newInvertedTranspose = tmp * _viewMatrix;
+ Math::Matrix4 viewMatrix;
+ viewMatrix.setData(_viewMatrix);
+ Math::Matrix4 newInvertedTranspose = tmp * viewMatrix;
newInvertedTranspose.inverse();
newInvertedTranspose.transpose();
@@ -511,12 +525,12 @@ bool BaseRenderOpenGL3DShader::setWorldTransform(const Math::Matrix4 &transform)
return true;
}
-bool BaseRenderOpenGL3DShader::setViewTransform(const Math::Matrix4 &transform) {
+bool BaseRenderOpenGL3DShader::setViewTransform(const DXMatrix &transform) {
_viewMatrix = transform;
return true;
}
-bool BaseRenderOpenGL3DShader::setProjectionTransform(const Math::Matrix4 &transform) {
+bool BaseRenderOpenGL3DShader::setProjectionTransform(const DXMatrix &transform) {
_projectionMatrix = transform;
return true;
}
@@ -552,8 +566,9 @@ bool BaseRenderOpenGL3DShader::initRenderer(int width, int height, bool windowed
static const char *shadowMaskAttributes[] = { "position", nullptr };
_shadowMaskShader = OpenGL::Shader::fromFiles("wme_shadow_mask", shadowMaskAttributes);
- _transformStack.push_back(Math::Matrix4());
- _transformStack.back().setToIdentity();
+ DXMatrix m;
+ DXMatrixIdentity(&m);
+ _transformStack.push_back(m);
static const char *XModelAttributes[] = {"position", "texcoord", "normal", nullptr};
_xmodelShader = OpenGL::Shader::fromFiles("wme_modelx", XModelAttributes);
@@ -561,7 +576,7 @@ bool BaseRenderOpenGL3DShader::initRenderer(int width, int height, bool windowed
setDefaultAmbientLightColor();
for (int i = 0; i < getMaxActiveLights(); ++i) {
- setLightParameters(i, Math::Vector3d(0, 0, 0), Math::Vector3d(0, 0, 0), Math::Vector4d(0, 0, 0, 0), false);
+ setLightParameters(i, DXVector3(0, 0, 0), DXVector3(0, 0, 0), DXVector4(0, 0, 0, 0), false);
disableLight(i);
}
@@ -661,7 +676,7 @@ bool BaseRenderOpenGL3DShader::setup3D(Camera3D *camera, bool force) {
if (camera)
_camera = camera;
if (_camera) {
- Math::Matrix4 viewMatrix;
+ DXMatrix viewMatrix;
_camera->getViewMatrix(&viewMatrix);
setViewTransform(viewMatrix);
@@ -703,19 +718,22 @@ bool BaseRenderOpenGL3DShader::setup3D(Camera3D *camera, bool force) {
setProjection();
}
+ Math::Matrix4 viewMatrix, projectionMatrix;
+ viewMatrix.setData(_viewMatrix);
+ projectionMatrix.setData(_projectionMatrix);
_xmodelShader->use();
- _xmodelShader->setUniform("viewMatrix", _viewMatrix);
- _xmodelShader->setUniform("projMatrix", _projectionMatrix);
+ _xmodelShader->setUniform("viewMatrix", viewMatrix);
+ _xmodelShader->setUniform("projMatrix", projectionMatrix);
// this is 8 / 255, since 8 is the value used by wme (as a DWORD)
_xmodelShader->setUniform1f("alphaRef", 0.031f);
_geometryShader->use();
- _geometryShader->setUniform("viewMatrix", _viewMatrix);
- _geometryShader->setUniform("projMatrix", _projectionMatrix);
+ _geometryShader->setUniform("viewMatrix", viewMatrix);
+ _geometryShader->setUniform("projMatrix", projectionMatrix);
_shadowVolumeShader->use();
- _shadowVolumeShader->setUniform("viewMatrix", _viewMatrix);
- _shadowVolumeShader->setUniform("projMatrix", _projectionMatrix);
+ _shadowVolumeShader->setUniform("viewMatrix", viewMatrix);
+ _shadowVolumeShader->setUniform("projMatrix", projectionMatrix);
return true;
}
diff --git a/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.h b/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.h
index 4141aa7488b..a036b0c010c 100644
--- a/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.h
+++ b/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.h
@@ -53,14 +53,14 @@ public:
int getMaxActiveLights() override;
void enableLight(int index) override;
void disableLight(int index) override;
- void setLightParameters(int index, const Math::Vector3d &position, const Math::Vector3d &direction, const Math::Vector4d &diffuse, bool spotlight) override;
+ void setLightParameters(int index, const DXVector3 &position, const DXVector3 &direction, const DXVector4 &diffuse, bool spotlight) override;
void enableCulling() override;
void disableCulling() override;
bool enableShadows() override;
bool disableShadows() override;
- void displayShadow(BaseObject *object, const Math::Vector3d &lightPos, bool lightPosRelative) override;
+ void displayShadow(BaseObject *object, const DXVector3 *lightPos, bool lightPosRelative) override;
bool usingStencilBuffer() override;
void dumpData(const char *filename) override {}
@@ -74,9 +74,9 @@ public:
bool setProjection() override;
bool setProjection2D() override;
- bool setWorldTransform(const Math::Matrix4 &transform) override;
- bool setViewTransform(const Math::Matrix4 &transform) override;
- bool setProjectionTransform(const Math::Matrix4 &transform) override;
+ bool setWorldTransform(const DXMatrix &transform) override;
+ bool setViewTransform(const DXMatrix &transform) override;
+ bool setProjectionTransform(const DXMatrix &transform) override;
bool windowedBlt() override;
@@ -129,7 +129,7 @@ public:
private:
Math::Matrix4 _projectionMatrix2d;
- Common::Array<Math::Matrix4> _transformStack;
+ Common::Array<DXMatrix> _transformStack;
Math::Vector4d _flatShadowColor;
int _shadowTextureWidth;
diff --git a/engines/wintermute/base/gfx/opengl/mesh3ds_opengl.cpp b/engines/wintermute/base/gfx/opengl/mesh3ds_opengl.cpp
index 09204904814..73b3cbe795c 100644
--- a/engines/wintermute/base/gfx/opengl/mesh3ds_opengl.cpp
+++ b/engines/wintermute/base/gfx/opengl/mesh3ds_opengl.cpp
@@ -36,14 +36,14 @@ Mesh3DSOpenGL::~Mesh3DSOpenGL() {
}
void Mesh3DSOpenGL::fillVertexBuffer(uint32 color) {
- _color.x() = RGBCOLGetR(color) / 255.0f;
- _color.y() = RGBCOLGetG(color) / 255.0f;
- _color.z() = RGBCOLGetB(color) / 255.0f;
- _color.w() = RGBCOLGetA(color) / 255.0f;
+ _color._x = RGBCOLGetR(color) / 255.0f;
+ _color._y = RGBCOLGetG(color) / 255.0f;
+ _color._z = RGBCOLGetB(color) / 255.0f;
+ _color._w = RGBCOLGetA(color) / 255.0f;
}
void Mesh3DSOpenGL::render() {
- glColor4f(_color.x(), _color.y(), _color.z(), _color.w());
+ glColor4f(_color._x, _color._y, _color._z, _color._w);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(GeometryVertex), reinterpret_cast<byte *>(_vertexData));
glDrawElements(GL_TRIANGLES, _indexCount, GL_UNSIGNED_SHORT, _indexData);
diff --git a/engines/wintermute/base/gfx/opengl/mesh3ds_opengl_shader.cpp b/engines/wintermute/base/gfx/opengl/mesh3ds_opengl_shader.cpp
index 99764674c29..9be3c3f9a73 100644
--- a/engines/wintermute/base/gfx/opengl/mesh3ds_opengl_shader.cpp
+++ b/engines/wintermute/base/gfx/opengl/mesh3ds_opengl_shader.cpp
@@ -40,10 +40,10 @@ Mesh3DSOpenGLShader::~Mesh3DSOpenGLShader() {
}
void Mesh3DSOpenGLShader::fillVertexBuffer(uint32 color) {
- _color.x() = RGBCOLGetR(color) / 255.0f;
- _color.y() = RGBCOLGetG(color) / 255.0f;
- _color.z() = RGBCOLGetB(color) / 255.0f;
- _color.w() = RGBCOLGetA(color) / 255.0f;
+ _color._x = RGBCOLGetR(color) / 255.0f;
+ _color._y = RGBCOLGetG(color) / 255.0f;
+ _color._z = RGBCOLGetB(color) / 255.0f;
+ _color._w = RGBCOLGetA(color) / 255.0f;
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(GeometryVertex) * _vertexCount, _vertexData, GL_STATIC_DRAW);
@@ -60,7 +60,8 @@ void Mesh3DSOpenGLShader::render() {
_shader->enableVertexAttribute("position", _vertexBuffer, 3, GL_FLOAT, false, sizeof(GeometryVertex), 0);
_shader->use(true);
- _shader->setUniform("color", _color);
+ Math::Vector4d color = Math::Vector4d(_color._x, _color._y, _color._z, 1.0f);
+ _shader->setUniform("color", color);
glDrawElements(GL_TRIANGLES, _indexCount, GL_UNSIGNED_SHORT, 0);
diff --git a/engines/wintermute/base/gfx/xanimation.cpp b/engines/wintermute/base/gfx/xanimation.cpp
index 6a8405719cc..6e464235cdb 100644
--- a/engines/wintermute/base/gfx/xanimation.cpp
+++ b/engines/wintermute/base/gfx/xanimation.cpp
@@ -148,13 +148,13 @@ bool Animation::loadAnimationKeyData(XAnimationKeyObject *animationKey) {
assert(fileRotKey->_numTfkeys == 4);
BoneRotationKey *rotKey = new BoneRotationKey;
- rotKey->_time = fileRotKey->_time;
+ rotKey->_time = fileRotKey->_time;
// NOTE x files are w x y z and QUATERNIONS are x y z w
- rotKey->_rotation.w() = fileRotKey->_tfkeys[0];
- rotKey->_rotation.x() = fileRotKey->_tfkeys[1];
- rotKey->_rotation.y() = fileRotKey->_tfkeys[2];
+ rotKey->_rotation._w = fileRotKey->_tfkeys[0];
+ rotKey->_rotation._x = fileRotKey->_tfkeys[1];
+ rotKey->_rotation._y = fileRotKey->_tfkeys[2];
// mirror z component
- rotKey->_rotation.z() = -fileRotKey->_tfkeys[3];
+ rotKey->_rotation._z = -fileRotKey->_tfkeys[3];
_rotKeys.push_back(rotKey);
}
@@ -170,9 +170,9 @@ bool Animation::loadAnimationKeyData(XAnimationKeyObject *animationKey) {
BoneScaleKey *scaleKey = new BoneScaleKey;
scaleKey->_time = fileScaleKey->_time;
- for (uint i = 0; i < fileScaleKey->_numTfkeys; ++i) {
- scaleKey->_scale.getData()[i] = fileScaleKey->_tfkeys[i];
- }
+ scaleKey->_scale._x = fileScaleKey->_tfkeys[0];
+ scaleKey->_scale._y = fileScaleKey->_tfkeys[1];
+ scaleKey->_scale._z = fileScaleKey->_tfkeys[2];
_scaleKeys.push_back(scaleKey);
}
@@ -188,10 +188,10 @@ bool Animation::loadAnimationKeyData(XAnimationKeyObject *animationKey) {
BonePositionKey *posKey = new BonePositionKey;
posKey->_time = filePosKey->_time;
- posKey->_pos.getData()[0] = filePosKey->_tfkeys[0];
- posKey->_pos.getData()[1] = filePosKey->_tfkeys[1];
+ posKey->_pos._x = filePosKey->_tfkeys[0];
+ posKey->_pos._y = filePosKey->_tfkeys[1];
// mirror Z
- posKey->_pos.getData()[2] = -filePosKey->_tfkeys[2];
+ posKey->_pos._z = -filePosKey->_tfkeys[2];
_posKeys.push_back(posKey);
}
@@ -237,9 +237,9 @@ bool Animation::loadAnimationKeyData(XAnimationKeyObject *animationKey) {
scaleKey->_time = time;
rotationKey->_time = time;
- positionKey->_pos = Math::Vector3d(transVec._x, transVec._y, transVec._z);
- scaleKey->_scale = Math::Vector3d(scaleVec._x, scaleVec._y, scaleVec._z);
- rotationKey->_rotation = Math::Vector4d(qRot._x, qRot._y, qRot._z, qRot._w);
+ positionKey->_pos = DXVector3(transVec._x, transVec._y, transVec._z);
+ scaleKey->_scale = DXVector3(scaleVec._x, scaleVec._y, scaleVec._z);
+ rotationKey->_rotation = DXQuaternion(qRot._x, qRot._y, qRot._z, qRot._w);
_posKeys.push_back(positionKey);
_scaleKeys.push_back(scaleKey);
@@ -299,8 +299,8 @@ bool Animation::update(int slot, uint32 localTime, float animLerpValue) {
}
// apply the lerp function on the scale vector
- DXVector3 scale1vec = DXVector3(_scaleKeys[keyIndex1]->_scale.x(), _scaleKeys[keyIndex1]->_scale.y(), _scaleKeys[keyIndex1]->_scale.z());
- DXVector3 scale2vec = DXVector3(_scaleKeys[keyIndex2]->_scale.x(), _scaleKeys[keyIndex2]->_scale.y(), _scaleKeys[keyIndex2]->_scale.z());
+ DXVector3 scale1vec = DXVector3(_scaleKeys[keyIndex1]->_scale._x, _scaleKeys[keyIndex1]->_scale._y, _scaleKeys[keyIndex1]->_scale._z);
+ DXVector3 scale2vec = DXVector3(_scaleKeys[keyIndex2]->_scale._x, _scaleKeys[keyIndex2]->_scale._y, _scaleKeys[keyIndex2]->_scale._z);
DXVec3Lerp(&resultScale, &scale1vec, &scale2vec, lerpValue);
animate = true;
@@ -337,16 +337,16 @@ bool Animation::update(int slot, uint32 localTime, float animLerpValue) {
DXQuaternion q1, q2;
// negate for opengl
- q1._x = -(-_rotKeys[keyIndex1]->_rotation.x());
- q1._y = -(-_rotKeys[keyIndex1]->_rotation.y());
- q1._z = -(-_rotKeys[keyIndex1]->_rotation.z());
- q1._w = _rotKeys[keyIndex1]->_rotation.w();
+ q1._x = -(-_rotKeys[keyIndex1]->_rotation._x);
+ q1._y = -(-_rotKeys[keyIndex1]->_rotation._y);
+ q1._z = -(-_rotKeys[keyIndex1]->_rotation._z);
+ q1._w = _rotKeys[keyIndex1]->_rotation._w;
// negate for opengl
- q2._x = -(-_rotKeys[keyIndex2]->_rotation.x());
- q2._y = -(-_rotKeys[keyIndex2]->_rotation.y());
- q2._z = -(-_rotKeys[keyIndex2]->_rotation.z());
- q2._w = _rotKeys[keyIndex2]->_rotation.w();
+ q2._x = -(-_rotKeys[keyIndex2]->_rotation._x);
+ q2._y = -(-_rotKeys[keyIndex2]->_rotation._y);
+ q2._z = -(-_rotKeys[keyIndex2]->_rotation._z);
+ q2._w = _rotKeys[keyIndex2]->_rotation._w;
DXQuaternionSlerp(&resultRot, &q1, &q2, lerpValue);
@@ -380,15 +380,15 @@ bool Animation::update(int slot, uint32 localTime, float animLerpValue) {
lerpValue = float(localTime - time1) / float(time2 - time1);
// apply the lerp function
- DXVector3 pos1vec = DXVector3(_posKeys[keyIndex1]->_pos.x(), _posKeys[keyIndex1]->_pos.y(), _posKeys[keyIndex1]->_pos.z());
- DXVector3 pos2vec = DXVector3(_posKeys[keyIndex2]->_pos.x(), _posKeys[keyIndex2]->_pos.y(), _posKeys[keyIndex2]->_pos.z());
+ DXVector3 pos1vec = DXVector3(_posKeys[keyIndex1]->_pos._x, _posKeys[keyIndex1]->_pos._y, _posKeys[keyIndex1]->_pos._z);
+ DXVector3 pos2vec = DXVector3(_posKeys[keyIndex2]->_pos._x, _posKeys[keyIndex2]->_pos._y, _posKeys[keyIndex2]->_pos._z);
DXVec3Lerp(&resultPos, &pos1vec, &pos2vec, lerpValue);
animate = true;
}
if (animate) {
- _targetFrame->setTransformation(slot, Math::Vector3d(resultPos), Math::Vector3d(resultScale), Math::Quaternion(resultRot._x, resultRot._y, resultRot._z, resultRot._w), animLerpValue);
+ _targetFrame->setTransformation(slot, DXVector3(resultPos), DXVector3(resultScale), DXQuaternion(resultRot._x, resultRot._y, resultRot._z, resultRot._w), animLerpValue);
}
return true;
diff --git a/engines/wintermute/base/gfx/xanimation.h b/engines/wintermute/base/gfx/xanimation.h
index 650a85b34c8..2021da5e71d 100644
--- a/engines/wintermute/base/gfx/xanimation.h
+++ b/engines/wintermute/base/gfx/xanimation.h
@@ -59,17 +59,17 @@ public:
protected:
struct BonePositionKey {
uint32 _time;
- Math::Vector3d _pos;
+ DXVector3 _pos;
};
struct BoneScaleKey {
uint32 _time;
- Math::Vector3d _scale;
+ DXVector3 _scale;
};
struct BoneRotationKey {
uint32 _time;
- Math::Quaternion _rotation;
+ DXQuaternion _rotation;
};
protected:
diff --git a/engines/wintermute/base/gfx/xframe_node.cpp b/engines/wintermute/base/gfx/xframe_node.cpp
index e951b0fc840..bc2065c28d4 100644
--- a/engines/wintermute/base/gfx/xframe_node.cpp
+++ b/engines/wintermute/base/gfx/xframe_node.cpp
@@ -39,14 +39,14 @@ namespace Wintermute {
//////////////////////////////////////////////////////////////////////////
FrameNode::FrameNode(BaseGame *inGame) : BaseNamedObject(inGame) {
- _transformationMatrix.setToIdentity();
- _originalMatrix.setToIdentity();
+ DXMatrixIdentity(&_transformationMatrix);
+ DXMatrixIdentity(&_originalMatrix);
DXMatrixIdentity(&_combinedMatrix);
for (int i = 0; i < 2; i++) {
- _transPos[i] = Math::Vector3d(0.0f, 0.0f, 0.0f);
- _transScale[i] = Math::Vector3d(1.0f, 1.0f, 1.0f);
- _transRot[i] = Math::Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
+ _transPos[i] = DXVector3(0.0f, 0.0f, 0.0f);
+ _transScale[i] = DXVector3(1.0f, 1.0f, 1.0f);
+ _transRot[i] = DXQuaternion(0.0f, 0.0f, 0.0f, 1.0f);
_lerpValue[i] = 0.0f;
_transUsed[i] = false;
@@ -76,17 +76,17 @@ DXMatrix *FrameNode::getCombinedMatrix() {
}
//////////////////////////////////////////////////////////////////////////
-Math::Matrix4 *FrameNode::getOriginalMatrix() {
+DXMatrix *FrameNode::getOriginalMatrix() {
return &_originalMatrix;
}
//////////////////////////////////////////////////////////////////////////
-void FrameNode::setTransformationMatrix(Math::Matrix4 *mat) {
+void FrameNode::setTransformationMatrix(DXMatrix *mat) {
_transformationMatrix = *mat;
}
//////////////////////////////////////////////////////////////////////////
-void FrameNode::setTransformation(int slot, Math::Vector3d pos, Math::Vector3d scale, Math::Quaternion rot, float lerpValue) {
+void FrameNode::setTransformation(int slot, DXVector3 pos, DXVector3 scale, DXQuaternion rot, float lerpValue) {
if (slot < 0 || slot > 1)
return;
@@ -124,23 +124,22 @@ bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFi
BaseEngine::LOG(0, "Error loading transformation matrix");
return false;
} else {
- // TODO: check if this is the right format
for (int r = 0; r < 4; ++r) {
for (int c = 0; c < 4; ++c) {
- _transformationMatrix(c, r) = frameTransformMatrix->_frameMatrix[r * 4 + c];
+ _transformationMatrix._m[c][r] = frameTransformMatrix->_frameMatrix[r * 4 + c];
}
}
// mirror at orign
- _transformationMatrix(2, 3) *= -1.0f;
+ _transformationMatrix._m[2][3] *= -1.0f;
// mirror base vectors
- _transformationMatrix(2, 0) *= -1.0f;
- _transformationMatrix(2, 1) *= -1.0f;
+ _transformationMatrix._m[2][0] *= -1.0f;
+ _transformationMatrix._m[2][1] *= -1.0f;
// change handedness
- _transformationMatrix(0, 2) *= -1.0f;
- _transformationMatrix(1, 2) *= -1.0f;
+ _transformationMatrix._m[0][2] *= -1.0f;
+ _transformationMatrix._m[1][2] *= -1.0f;
_originalMatrix = _transformationMatrix;
return true;
@@ -250,24 +249,24 @@ FrameNode *FrameNode::findFrame(const char *frameName) {
}
//////////////////////////////////////////////////////////////////////////
-bool FrameNode::updateMatrices(DXMatrix &parentMat) {
+bool FrameNode::updateMatrices(DXMatrix *parentMat) {
if (_transUsed[0]) {
- DXVector3 transPos = DXVector3(_transPos[0].getData());
- DXVector3 transScale = DXVector3(_transScale[0].getData());
- DXQuaternion transRot = DXQuaternion(_transRot[0].getData());
+ DXVector3 transPos = DXVector3(_transPos[0]);
+ DXVector3 transScale = DXVector3(_transScale[0]);
+ DXQuaternion transRot = DXQuaternion(_transRot[0]);
float lerpValue = _lerpValue[0];
if (_transUsed[1]) {
- DXVector3 transPos1 = DXVector3(_transPos[1].getData());
- DXVector3 transScale1 = DXVector3(_transScale[1].getData());
- DXQuaternion transRot1 = DXQuaternion(_transRot[1].getData());
+ DXVector3 transPos1 = DXVector3(_transPos[1]);
+ DXVector3 transScale1 = DXVector3(_transScale[1]);
+ DXQuaternion transRot1 = DXQuaternion(_transRot[1]);
DXVec3Lerp(&transScale, &transScale, &transScale1, lerpValue);
DXQuaternionSlerp(&transRot, &transRot, &transRot1, lerpValue);
DXVec3Lerp(&transPos, &transPos, &transPos1, lerpValue);
}
// prepare local transformation matrix
- DXMatrix transformationMatrix = DXMatrix(_transformationMatrix.getData());
+ DXMatrix transformationMatrix = DXMatrix(_transformationMatrix);
DXMatrixIdentity(&transformationMatrix);
DXMatrix scaleMat;
@@ -284,18 +283,18 @@ bool FrameNode::updateMatrices(DXMatrix &parentMat) {
DXMatrixTranslation(&posMat, transPos._x, transPos._y, transPos._z);
DXMatrixTranspose(&posMat, &posMat);
DXMatrixMultiply(&transformationMatrix, &posMat, &transformationMatrix);
- _transformationMatrix.setData(transformationMatrix._m4x4);
+ _transformationMatrix = transformationMatrix;
}
_transUsed[0] = _transUsed[1] = false;
// multiply by parent transformation
- DXMatrix transformationMatrix = DXMatrix(_transformationMatrix.getData());
- DXMatrixMultiply(&_combinedMatrix, &parentMat, &transformationMatrix);
+ DXMatrix transformationMatrix = DXMatrix(_transformationMatrix);
+ DXMatrixMultiply(&_combinedMatrix, parentMat, &transformationMatrix);
// update child frames
for (uint32 i = 0; i < _frames.size(); i++) {
- _frames[i]->updateMatrices(_combinedMatrix);
+ _frames[i]->updateMatrices(&_combinedMatrix);
}
return true;
@@ -336,7 +335,7 @@ bool FrameNode::resetMatrices() {
}
//////////////////////////////////////////////////////////////////////////
-bool FrameNode::updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth) {
+bool FrameNode::updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth) {
bool res = true;
// meshes
@@ -400,7 +399,7 @@ bool FrameNode::renderFlatShadowModel() {
}
//////////////////////////////////////////////////////////////////////////
-bool FrameNode::pickPoly(Math::Vector3d *pickRayOrig, Math::Vector3d *pickRayDir) {
+bool FrameNode::pickPoly(DXVector3 *pickRayOrig, DXVector3 *pickRayDir) {
bool found = false;
for (uint32 i = 0; i < _meshes.size(); i++) {
found = _meshes[i]->pickPoly(pickRayOrig, pickRayDir);
diff --git a/engines/wintermute/base/gfx/xframe_node.h b/engines/wintermute/base/gfx/xframe_node.h
index ae6062c642f..13df5ede1cc 100644
--- a/engines/wintermute/base/gfx/xframe_node.h
+++ b/engines/wintermute/base/gfx/xframe_node.h
@@ -48,24 +48,24 @@ public:
FrameNode(BaseGame *inGame);
virtual ~FrameNode();
- bool updateMatrices(DXMatrix &parentMat);
+ bool updateMatrices(DXMatrix *parentMat);
bool updateMeshes();
bool resetMatrices();
bool render(XModel *model);
bool renderFlatShadowModel();
- bool updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth);
+ bool updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);
bool loadFromXData(const Common::String &filename, XModel *model, XFileData *xobj);
bool mergeFromXData(const Common::String &filename, XModel *model, XFileData *xobj);
bool findBones(FrameNode *rootFrame);
FrameNode *findFrame(const char *frameName);
DXMatrix *getCombinedMatrix();
- Math::Matrix4 *getOriginalMatrix();
- void setTransformationMatrix(Math::Matrix4 *mat);
- bool pickPoly(Math::Vector3d *pickRayOrig, Math::Vector3d *pickRayDir);
+ DXMatrix *getOriginalMatrix();
+ void setTransformationMatrix(DXMatrix *mat);
+ bool pickPoly(DXVector3 *pickRayOrig, DXVector3 *pickRayDir);
bool getBoundingBox(DXVector3 *boxStart, DXVector3 *boxEnd);
- void setTransformation(int slot, Math::Vector3d pos, Math::Vector3d scale, Math::Quaternion rot, float lerpValue);
+ void setTransformation(int slot, DXVector3 pos, DXVector3 scale, DXQuaternion rot, float lerpValue);
bool hasChildren();
@@ -79,13 +79,13 @@ protected:
BaseArray<FrameNode *> _frames;
BaseArray<XMesh *> _meshes;
- Math::Matrix4 _transformationMatrix;
- Math::Matrix4 _originalMatrix;
+ DXMatrix _transformationMatrix;
+ DXMatrix _originalMatrix;
DXMatrix _combinedMatrix;
- Math::Vector3d _transPos[2];
- Math::Vector3d _transScale[2];
- Math::Quaternion _transRot[2];
+ DXVector3 _transPos[2];
+ DXVector3 _transScale[2];
+ DXQuaternion _transRot[2];
bool _transUsed[2];
float _lerpValue[2];
};
diff --git a/engines/wintermute/base/gfx/xmesh.cpp b/engines/wintermute/base/gfx/xmesh.cpp
index e74926de7bb..f9ddd85e45c 100644
--- a/engines/wintermute/base/gfx/xmesh.cpp
+++ b/engines/wintermute/base/gfx/xmesh.cpp
@@ -296,7 +296,7 @@ bool XMesh::update(FrameNode *parentFrame) {
}
//////////////////////////////////////////////////////////////////////////
-bool XMesh::updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth) {
+bool XMesh::updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth) {
if (!_blendedMesh)
return false;
@@ -306,12 +306,11 @@ bool XMesh::updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const
}
uint32 vertexSize = DXGetFVFVertexSize(_blendedMesh->getFVF()) / sizeof(float);
- DXVector3 invLight = DXVector3(light.getData());
- DXMatrix matInverseModel = DXMatrix(modelMat.getData());
+ DXVector3 invLight = *light;
+ DXMatrix matInverseModel = *modelMat;
DXMatrixInverse(&matInverseModel, nullptr, &matInverseModel);
DXMatrixTranspose(&matInverseModel, &matInverseModel);
- DXVector3 l = DXVector3(light.getData());
- DXVec3TransformNormal(&invLight, &l, &matInverseModel);
+ DXVec3TransformNormal(&invLight, light, &matInverseModel);
uint32 numEdges = 0;
@@ -396,7 +395,7 @@ bool XMesh::updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const
}
//////////////////////////////////////////////////////////////////////////
-bool XMesh::pickPoly(Math::Vector3d *pickRayOrig, Math::Vector3d *pickRayDir) {
+bool XMesh::pickPoly(DXVector3 *pickRayOrig, DXVector3 *pickRayDir) {
if (!_blendedMesh)
return false;
@@ -411,20 +410,17 @@ bool XMesh::pickPoly(Math::Vector3d *pickRayOrig, Math::Vector3d *pickRayDir) {
bool found = false;
- Math::Vector3d intersection;
+ DXVector3 intersection;
for (uint32 i = 0; i < numFaces; i++) {
- DXVector3 vp0 = *(DXVector3 *)(points + indices[3 * i + 0] * fvfSize);
- DXVector3 vp1 = *(DXVector3 *)(points + indices[3 * i + 1] * fvfSize);
- DXVector3 vp2 = *(DXVector3 *)(points + indices[3 * i + 2] * fvfSize);
- Math::Vector3d v0 = Math::Vector3d(vp0._x, vp0._y, vp0._z);
- Math::Vector3d v1 = Math::Vector3d(vp1._x, vp1._y, vp1._z);
- Math::Vector3d v2 = Math::Vector3d(vp2._x, vp2._y, vp2._z);
-
- if (isnan(v0.x()))
+ DXVector3 v0 = *(DXVector3 *)(points + indices[3 * i + 0] * fvfSize);
+ DXVector3 v1 = *(DXVector3 *)(points + indices[3 * i + 1] * fvfSize);
+ DXVector3 v2 = *(DXVector3 *)(points + indices[3 * i + 2] * fvfSize);
+
+ if (isnan(v0._x))
continue;
- found = intersectTriangle(*pickRayOrig, *pickRayDir, v0, v1, v2, intersection.x(), intersection.y(), intersection.z()) != false;
+ found = intersectTriangle(*pickRayOrig, *pickRayDir, v0, v1, v2, &intersection._x, &intersection._y, &intersection._z) != false;
if (found)
break;
}
diff --git a/engines/wintermute/base/gfx/xmesh.h b/engines/wintermute/base/gfx/xmesh.h
index eb07e5c0a86..905d5b4e85b 100644
--- a/engines/wintermute/base/gfx/xmesh.h
+++ b/engines/wintermute/base/gfx/xmesh.h
@@ -57,9 +57,9 @@ public:
virtual bool update(FrameNode *parentFrame);
virtual bool render(XModel *model) = 0;
virtual bool renderFlatShadowModel() = 0;
- bool updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth);
+ bool updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);
- bool pickPoly(Math::Vector3d *pickRayOrig, Math::Vector3d *pickRayDir);
+ bool pickPoly(DXVector3 *pickRayOrig, DXVector3 *pickRayDir);
DXVector3 _BBoxStart;
DXVector3 _BBoxEnd;
diff --git a/engines/wintermute/base/gfx/xmodel.cpp b/engines/wintermute/base/gfx/xmodel.cpp
index 34c5627bdda..92214590771 100644
--- a/engines/wintermute/base/gfx/xmodel.cpp
+++ b/engines/wintermute/base/gfx/xmodel.cpp
@@ -57,9 +57,9 @@ XModel::XModel(BaseGame *inGame, BaseObject *owner) : BaseObject(inGame) {
_rootFrame = nullptr;
_drawingViewport.setEmpty();
- _lastWorldMat.setToIdentity();
- _lastViewMat.setToIdentity();
- _lastProjMat.setToIdentity();
+ DXMatrixIdentity(&_lastWorldMat);
+ DXMatrixIdentity(&_lastViewMat);
+ DXMatrixIdentity(&_lastProjMat);
_lastOffsetX = _lastOffsetY = 0;
_BBoxStart = _BBoxEnd = DXVector3(0.0f, 0.0f, 0.0f);
@@ -366,7 +366,7 @@ bool XModel::update() {
if (_rootFrame) {
DXMatrix tempMat;
DXMatrixIdentity(&tempMat);
- _rootFrame->updateMatrices(tempMat);
+ _rootFrame->updateMatrices(&tempMat);
return _rootFrame->updateMeshes();
} else {
@@ -456,7 +456,7 @@ bool XModel::isAnimPending(char *animName) {
}
//////////////////////////////////////////////////////////////////////////
-bool XModel::updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth) {
+bool XModel::updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth) {
if (_rootFrame) {
return _rootFrame->updateShadowVol(shadow, modelMat, light, extrusionDepth);
} else {
@@ -478,9 +478,9 @@ bool XModel::render() {
bool res = _rootFrame->render(this);
// remember matrices for object picking purposes
- _gameRef->_renderer3D->getWorldTransform(_lastWorldMat);
- _gameRef->_renderer3D->getViewTransform(_lastViewMat);
- _gameRef->_renderer3D->getProjectionTransform(_lastProjMat);
+ _gameRef->_renderer3D->getWorldTransform(&_lastWorldMat);
+ _gameRef->_renderer3D->getViewTransform(&_lastViewMat);
+ _gameRef->_renderer3D->getProjectionTransform(&_lastProjMat);
// remember scene offset
Rect32 rc;
@@ -567,12 +567,12 @@ bool XModel::isTransparentAt(int x, int y) {
// Compute the vector of the pick ray in screen space
DXVector3 vec;
- vec._x = (((2.0f * x) / (_drawingViewport.width())) - 1) / _lastProjMat(0, 0);
- vec._y = -(((2.0f * y) / (_drawingViewport.height())) - 1) / _lastProjMat(1, 1);
+ vec._x = (((2.0f * x) / (_drawingViewport.width())) - 1) / _lastProjMat.matrix._11;
+ vec._y = -(((2.0f * y) / (_drawingViewport.height())) - 1) / _lastProjMat.matrix._22;
vec._z = -1.0f;
// Get the inverse view matrix
- DXMatrix m, viewMatrix = DXMatrix(_lastViewMat.getData());
+ DXMatrix m, viewMatrix = DXMatrix(_lastViewMat);
DXMatrixInverse(&m, nullptr, &viewMatrix);
// Transform the screen space pick ray into 3D space
@@ -585,17 +585,14 @@ bool XModel::isTransparentAt(int x, int y) {
// transform to model space
DXVector3 end = pickRayOrig + pickRayDir;
- DXMatrix worldMatrix = DXMatrix(_lastWorldMat.getData());
+ DXMatrix worldMatrix = DXMatrix(_lastWorldMat);
DXMatrixInverse(&m, nullptr, &worldMatrix);
DXMatrixTranspose(&m, &m);
DXVec3TransformCoord(&pickRayOrig, &pickRayOrig, &m);
DXVec3TransformCoord(&end, &end, &m);
pickRayDir = end - pickRayOrig;
- Math::Vector3d vPickRayOrig = Math::Vector3d(pickRayOrig._x, pickRayOrig._y, pickRayOrig._z);
- Math::Vector3d vPickRayDir = Math::Vector3d(pickRayDir._x, pickRayDir._y, pickRayDir._z);
-
- return !_rootFrame->pickPoly(&vPickRayOrig, &vPickRayDir);
+ return !_rootFrame->pickPoly(&pickRayOrig, &pickRayDir);
}
//////////////////////////////////////////////////////////////////////////
@@ -609,15 +606,12 @@ void XModel::updateBoundingRect() {
_boundingRect.left = _boundingRect.top = INT_MAX_VALUE;
_boundingRect.right = _boundingRect.bottom = INT_MIN_VALUE;
- Math::Matrix4 view, proj, world;
+ DXMatrix viewMat, projMat, worldMat;
DXVector3 vec2d(0, 0, 0);
- _gameRef->_renderer3D->getViewTransform(view);
- _gameRef->_renderer3D->getProjectionTransform(proj);
- _gameRef->_renderer3D->getWorldTransform(world);
- world.transpose();
- DXMatrix viewMat = DXMatrix(view.getData());
- DXMatrix projMat = DXMatrix(proj.getData());
- DXMatrix worldMat = DXMatrix(world.getData());
+ _gameRef->_renderer3D->getViewTransform(&viewMat);
+ _gameRef->_renderer3D->getProjectionTransform(&projMat);
+ _gameRef->_renderer3D->getWorldTransform(&worldMat);
+ DXMatrixTranspose(&worldMat, &worldMat);
_drawingViewport = _gameRef->_renderer3D->getViewPort();
diff --git a/engines/wintermute/base/gfx/xmodel.h b/engines/wintermute/base/gfx/xmodel.h
index 7d51f5fdd28..908509aae5c 100644
--- a/engines/wintermute/base/gfx/xmodel.h
+++ b/engines/wintermute/base/gfx/xmodel.h
@@ -135,7 +135,7 @@ public:
bool renderFlatShadowModel();
bool reset();
- bool updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth);
+ bool updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);
bool playAnim(int channel, const Common::String &anim, uint32 transitionTime = 0, bool forceReset = false, uint32 stopTransitionTime = 0);
bool isAnimPending(char *animName = nullptr);
@@ -179,9 +179,9 @@ private:
void updateBoundingRect();
void static inline updateRect(Rect32 *rc, DXVector3 *vec);
Rect32 _drawingViewport;
- Math::Matrix4 _lastWorldMat;
- Math::Matrix4 _lastViewMat;
- Math::Matrix4 _lastProjMat;
+ DXMatrix _lastWorldMat;
+ DXMatrix _lastViewMat;
+ DXMatrix _lastProjMat;
int32 _lastOffsetX;
int32 _lastOffsetY;
diff --git a/engines/wintermute/base/gfx/xskinmesh.cpp b/engines/wintermute/base/gfx/xskinmesh.cpp
index dabab728652..a2bd0c85dca 100644
--- a/engines/wintermute/base/gfx/xskinmesh.cpp
+++ b/engines/wintermute/base/gfx/xskinmesh.cpp
@@ -33,9 +33,6 @@
#include "engines/wintermute/base/gfx/xskinmesh.h"
#include "engines/wintermute/base/gfx/xmath.h"
-#include "common/array.h"
-#include "math/matrix4.h"
-
namespace Wintermute {
struct MeshData {
diff --git a/engines/wintermute/math/math_util.cpp b/engines/wintermute/math/math_util.cpp
index d01a1b32d9f..71db48d6dfd 100644
--- a/engines/wintermute/math/math_util.cpp
+++ b/engines/wintermute/math/math_util.cpp
@@ -54,14 +54,14 @@ float MathUtil::roundUp(float val) {
#ifdef ENABLE_WME3D
-bool intersectTriangle(const Math::Vector3d &origin, const Math::Vector3d &direction,
- const Math::Vector3d &vp0, const Math::Vector3d &vp1, const Math::Vector3d &vp2,
- float &t, float &u, float &v) {
- DXVector3 v0 = DXVector3(vp0.x(), vp0.y(), vp0.z());
- DXVector3 v1 = DXVector3(vp1.x(), vp1.y(), vp1.z());
- DXVector3 v2 = DXVector3(vp2.x(), vp2.y(), vp2.z());
- DXVector3 orig = DXVector3(origin.x(), origin.y(), origin.z());
- DXVector3 dir = DXVector3(direction.x(), direction.y(), direction.z());
+bool intersectTriangle(const DXVector3 &origin, const DXVector3 &direction,
+ DXVector3 &vp0, DXVector3 &vp1, DXVector3 &vp2,
+ float *t, float *u, float *v) {
+ DXVector3 v0 = DXVector3(vp0._x, vp0._y, vp0._z);
+ DXVector3 v1 = DXVector3(vp1._x, vp1._y, vp1._z);
+ DXVector3 v2 = DXVector3(vp2._x, vp2._y, vp2._z);
+ DXVector3 orig = DXVector3(origin._x, origin._y, origin._z);
+ DXVector3 dir = DXVector3(direction._x, direction._y, direction._z);
// Find vectors for two edges sharing vert0
DXVector3 edge1 = v1 - v0;
@@ -80,8 +80,8 @@ bool intersectTriangle(const Math::Vector3d &origin, const Math::Vector3d &direc
DXVector3 tvec = orig - v0;
// Calculate U parameter and test bounds
- u = DXVec3Dot(&tvec, &pvec);
- if (u < 0.0f || u > det)
+ *u = DXVec3Dot(&tvec, &pvec);
+ if (*u < 0.0f || *u > det)
return false;
// Prepare to test V parameter
@@ -89,38 +89,38 @@ bool intersectTriangle(const Math::Vector3d &origin, const Math::Vector3d &direc
DXVec3Cross(&qvec, &tvec, &edge1);
// Calculate V parameter and test bounds
- v = DXVec3Dot(&dir, &qvec);
- if (v < 0.0f || u + v > det)
+ *v = DXVec3Dot(&dir, &qvec);
+ if (*v < 0.0f || *u + *v > det)
return false;
// Calculate t, scale parameters, ray intersects triangle
- t = DXVec3Dot(&edge2, &qvec);
+ *t = DXVec3Dot(&edge2, &qvec);
float fInvDet = 1.0f / det;
- t *= fInvDet;
- u *= fInvDet;
- v *= fInvDet;
+ *t *= fInvDet;
+ *u *= fInvDet;
+ *v *= fInvDet;
DXVector3 intersection;
DXVector3 dest = orig + dir;
DXPlane plane;
DXPlaneFromPoints(&plane, &v0, &v1, &v2);
DXPlaneIntersectLine(&intersection, &plane, &orig, &dest);
- t = intersection._x;
- u = intersection._y;
- v = intersection._z;
+ *t = intersection._x;
+ *u = intersection._y;
+ *v = intersection._z;
return true;
}
-bool pickGetIntersect(const Math::Vector3d &lineS, const Math::Vector3d &lineE,
- const Math::Vector3d &vp0, const Math::Vector3d &vp1, const Math::Vector3d &vp2,
- Math::Vector3d &intersection, float &distance) {
- DXVector3 v0 = DXVector3(vp0.x(), vp0.y(), vp0.z());
- DXVector3 v1 = DXVector3(vp1.x(), vp1.y(), vp1.z());
- DXVector3 v2 = DXVector3(vp2.x(), vp2.y(), vp2.z());
- DXVector3 lineStart = DXVector3(lineS.x(), lineS.y(), lineS.z());
- DXVector3 lineEnd = DXVector3(lineE.x(), lineE.y(), lineE.z());
+bool pickGetIntersect(const DXVector3 lineS, const DXVector3 lineE,
+ const DXVector3 vp0, const DXVector3 vp1, const DXVector3 vp2,
+ DXVector3 *intersection, float *distance) {
+ DXVector3 v0 = DXVector3(vp0._x, vp0._y, vp0._z);
+ DXVector3 v1 = DXVector3(vp1._x, vp1._y, vp1._z);
+ DXVector3 v2 = DXVector3(vp2._x, vp2._y, vp2._z);
+ DXVector3 lineStart = DXVector3(lineS._x, lineS._y, lineS._z);
+ DXVector3 lineEnd = DXVector3(lineE._x, lineE._y, lineE._z);
// compute plane's normal
DXVector3 vertex;
@@ -157,11 +157,11 @@ bool pickGetIntersect(const Math::Vector3d &lineS, const Math::Vector3d &lineE,
else if (percentage > 1.0)
return false;
- distance = percentage; //record the distance from beginning of ray (0.0 -1.0)
+ *distance = percentage; //record the distance from beginning of ray (0.0 -1.0)
- intersection.x() = lineStart._x + direction._x * percentage; // add the percentage of the line to line start
- intersection.y() = lineStart._y + direction._y * percentage;
- intersection.z() = lineStart._z + direction._z * percentage;
+ intersection->_x = lineStart._x + direction._x * percentage; // add the percentage of the line to line start
+ intersection->_y = lineStart._y + direction._y * percentage;
+ intersection->_z = lineStart._z + direction._z * percentage;
return true;
}
diff --git a/engines/wintermute/math/math_util.h b/engines/wintermute/math/math_util.h
index b006c81ce3f..690f57d63f3 100644
--- a/engines/wintermute/math/math_util.h
+++ b/engines/wintermute/math/math_util.h
@@ -47,12 +47,12 @@ public:
#define degToRad(_val) (_val * DX_PI * (1.0f / 180.0f))
#define radToDeg(_val) (_val * (180.0f / DX_PI))
-bool intersectTriangle(const Math::Vector3d &origin, const Math::Vector3d &direction,
- const Math::Vector3d &v0, const Math::Vector3d &v1, const Math::Vector3d &v2,
- float &t, float &u, float &v);
-bool pickGetIntersect(const Math::Vector3d &lineStart, const Math::Vector3d &lineEnd,
- const Math::Vector3d &v0, const Math::Vector3d &v1, const Math::Vector3d &v2,
- Math::Vector3d &intersection, float &distance);
+bool intersectTriangle(const DXVector3 &orig, const DXVector3 &dir,
+ DXVector3 &v0, DXVector3 &v1, DXVector3 &v2,
+ float *t, float *u, float *v);
+bool pickGetIntersect(DXVector3 linestart, DXVector3 lineend,
+ DXVector3 v0, DXVector3 v1, DXVector3 v2,
+ DXVector3 *intersection, float *distance);
DXMatrix *matrixSetTranslation(DXMatrix *mat, DXVector3 *vec);
DXMatrix *matrixSetRotation(DXMatrix *mat, DXVector3 *vec);
void decomposeMatrixSimple(const DXMatrix *mat, DXVector3 *transVec, DXVector3 *scaleVec, DXQuaternion *rotQ);
More information about the Scummvm-git-logs
mailing list