500 lines
14 KiB
C++
500 lines
14 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* This file is based on WME.
|
|
* http://dead-code.org/redir.php?target=wme
|
|
* Copyright (c) 2003-2013 Jan Nedoma and contributors
|
|
*/
|
|
|
|
#include "engines/wintermute/base/base_game.h"
|
|
#include "engines/wintermute/base/base_engine.h"
|
|
#include "engines/wintermute/base/gfx/base_renderer3d.h"
|
|
#include "engines/wintermute/base/gfx/xmaterial.h"
|
|
#include "engines/wintermute/base/gfx/xframe_node.h"
|
|
#include "engines/wintermute/base/gfx/xmath.h"
|
|
#include "engines/wintermute/base/gfx/xmodel.h"
|
|
#include "engines/wintermute/base/gfx/xfile_loader.h"
|
|
#include "engines/wintermute/dcgf.h"
|
|
|
|
namespace Wintermute {
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
FrameNode::FrameNode(BaseGame *inGame) : BaseNamedObject(inGame) {
|
|
DXMatrixIdentity(&_transformationMatrix);
|
|
DXMatrixIdentity(&_originalMatrix);
|
|
DXMatrixIdentity(&_combinedMatrix);
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
_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;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
FrameNode::~FrameNode() {
|
|
// remove child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
delete _frames[i];
|
|
}
|
|
_frames.removeAll();
|
|
|
|
// remove meshes
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
delete _meshes[i];
|
|
}
|
|
_meshes.removeAll();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
DXMatrix *FrameNode::getCombinedMatrix() {
|
|
return &_combinedMatrix;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
DXMatrix *FrameNode::getOriginalMatrix() {
|
|
return &_originalMatrix;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FrameNode::setTransformationMatrix(DXMatrix *mat) {
|
|
_transformationMatrix = *mat;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FrameNode::setTransformation(int slot, DXVector3 pos, DXVector3 scale, DXQuaternion rot, float lerpValue) {
|
|
if (slot < 0 || slot > 1)
|
|
return;
|
|
|
|
_transPos[slot] = pos;
|
|
_transScale[slot] = scale;
|
|
_transRot[slot] = rot;
|
|
_lerpValue[slot] = lerpValue;
|
|
|
|
_transUsed[slot] = true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::loadFromXData(const char *filename, XModel *model, XFileData *xobj) {
|
|
_game->miniUpdate();
|
|
|
|
bool res = true;
|
|
|
|
// get the type of the object
|
|
XClassType objectType = kXClassUnknown;
|
|
res = xobj->getType(objectType);
|
|
if (!res) {
|
|
BaseEngine::LOG(0, "Error getting object type");
|
|
return res;
|
|
}
|
|
|
|
if (objectType == kXClassMesh) { // load a child mesh
|
|
XMesh *mesh = _game->_renderer3D->createXMesh();
|
|
res = mesh->loadFromXData(filename, xobj);
|
|
if (res) {
|
|
_meshes.add(mesh);
|
|
return true;
|
|
} else {
|
|
SAFE_DELETE(mesh);
|
|
return false;
|
|
}
|
|
} else if (objectType == kXClassFrameTransformMatrix) { // load the transformation matrix
|
|
XFrameTransformMatrixObject *frameTransformMatrix = xobj->getXFrameTransformMatrixObject();
|
|
if (!frameTransformMatrix) {
|
|
BaseEngine::LOG(0, "Error loading transformation matrix");
|
|
return false;
|
|
} else {
|
|
for (int i = 0; i < 16; ++i) {
|
|
_transformationMatrix._m4x4[i] = frameTransformMatrix->_frameMatrix[i];
|
|
}
|
|
_originalMatrix = _transformationMatrix;
|
|
return true;
|
|
}
|
|
} else if (objectType == kXClassAnimationSet) { // load animation set
|
|
return model->loadAnimationSet(filename, xobj);
|
|
} else if (objectType == kXClassAnimation) { // load a single animation (shouldn't happen here)
|
|
return model->loadAnimation(filename, xobj);
|
|
} else if (objectType == kXClassFrame) { // create a new child frame
|
|
FrameNode *childFrame = new FrameNode(_game);
|
|
|
|
// get the name of the child frame
|
|
res = XModel::loadName(childFrame, xobj);
|
|
if (!res) {
|
|
BaseEngine::LOG(0, "Error loading frame name");
|
|
SAFE_DELETE(childFrame);
|
|
return res;
|
|
}
|
|
|
|
// Enumerate child objects.
|
|
res = false;
|
|
uint32 numChildren = 0;
|
|
xobj->getChildren(numChildren);
|
|
for (uint32 i = 0; i < numChildren; i++) {
|
|
XFileData xchildData;
|
|
res = xobj->getChild(i, xchildData);
|
|
if (res)
|
|
res = childFrame->loadFromXData(filename, model, &xchildData);
|
|
}
|
|
if (res)
|
|
_frames.add(childFrame);
|
|
else
|
|
SAFE_DELETE(childFrame);
|
|
return res;
|
|
} else if (objectType == kXClassAnimTicksPerSecond) {
|
|
if (!xobj->getXAnimTicksPerSecondObject()) {
|
|
BaseEngine::LOG(0, "Error loading ticks per seconds info");
|
|
return res;
|
|
} else {
|
|
model->_ticksPerSecond = xobj->getXAnimTicksPerSecondObject()->_animTicksPerSecond;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FrameNode::mergeFromXData(const char *filename, XModel *model, XFileData *xobj) {
|
|
bool res = true;
|
|
|
|
// get the type of the object
|
|
XClassType objectType;
|
|
res = xobj->getType(objectType);
|
|
if (!res) {
|
|
BaseEngine::LOG(0, "Error getting object type");
|
|
return res;
|
|
} else if (objectType == kXClassAnimationSet) { // load animation set
|
|
return model->loadAnimationSet(filename, xobj);
|
|
} else if (objectType == kXClassAnimation) { // load a single animation (shouldn't happen here)
|
|
return model->loadAnimation(filename, xobj);
|
|
} else if (objectType == kXClassFrame) { // scan child frames
|
|
// Enumerate child objects.
|
|
res = false;
|
|
|
|
uint32 numChildren = 0;
|
|
xobj->getChildren(numChildren);
|
|
for (uint32 i = 0; i < numChildren; i++) {
|
|
XFileData xchildData;
|
|
res = xobj->getChild(i, xchildData);
|
|
if (res)
|
|
res = mergeFromXData(filename, model, &xchildData);
|
|
}
|
|
return res;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::findBones(FrameNode *rootFrame) {
|
|
// find the bones of the meshes
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->findBones(rootFrame);
|
|
}
|
|
|
|
// find the bones for the child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->findBones(rootFrame);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
FrameNode *FrameNode::findFrame(const char *frameName) {
|
|
if (_name && strcmp(_name, frameName) == 0) {
|
|
return this;
|
|
} else {
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
FrameNode *foundFrame = _frames[i]->findFrame(frameName);
|
|
if (foundFrame) {
|
|
return foundFrame;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::updateMatrices(DXMatrix *parentMat) {
|
|
if (_transUsed[0]) {
|
|
DXVector3 transPos = _transPos[0];
|
|
DXVector3 transScale = _transScale[0];
|
|
DXQuaternion transRot = _transRot[0];
|
|
float lerpValue = _lerpValue[0];
|
|
|
|
if (_transUsed[1]) {
|
|
DXVec3Lerp(&transScale, &transScale, &_transScale[1], lerpValue);
|
|
DXQuaternionSlerp(&transRot, &transRot, &_transRot[1], lerpValue);
|
|
DXVec3Lerp(&transPos, &transPos, &_transPos[1], lerpValue);
|
|
}
|
|
|
|
// prepare local transformation matrix
|
|
DXMatrixIdentity(&_transformationMatrix);
|
|
|
|
DXMatrix scaleMat;
|
|
DXMatrixScaling(&scaleMat, transScale._x, transScale._y, transScale._z);
|
|
DXMatrixMultiply(&_transformationMatrix, &_transformationMatrix, &scaleMat);
|
|
|
|
DXMatrix rotMat;
|
|
DXMatrixRotationQuaternion(&rotMat, &transRot);
|
|
DXMatrixMultiply(&_transformationMatrix, &_transformationMatrix, &rotMat);
|
|
|
|
DXMatrix posMat;
|
|
DXMatrixTranslation(&posMat, transPos._x, transPos._y, transPos._z);
|
|
DXMatrixMultiply(&_transformationMatrix, &_transformationMatrix, &posMat);
|
|
}
|
|
_transUsed[0] = _transUsed[1] = false;
|
|
|
|
// multiply by parent transformation
|
|
DXMatrixMultiply(&_combinedMatrix, &_transformationMatrix, parentMat);
|
|
|
|
// update child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->updateMatrices(&_combinedMatrix);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::updateMeshes() {
|
|
bool res = true;
|
|
|
|
// update meshes
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
res = _meshes[i]->update(this);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
// render child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
res = _frames[i]->updateMeshes();
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::resetMatrices() {
|
|
_transformationMatrix = _originalMatrix;
|
|
|
|
// update child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->resetMatrices();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth) {
|
|
bool res = true;
|
|
|
|
// meshes
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
res = _meshes[i]->updateShadowVol(shadow, modelMat, light, extrusionDepth);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
// child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
res = _frames[i]->updateShadowVol(shadow, modelMat, light, extrusionDepth);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::render(XModel *model) {
|
|
bool res = true;
|
|
|
|
// render meshes
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
res = _meshes[i]->render(model);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
// render child frames
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
res = _frames[i]->render(model);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool FrameNode::renderFlatShadowModel(uint32 shadowColor) {
|
|
bool res = true;
|
|
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
res = _meshes[i]->renderFlatShadowModel(shadowColor);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
res = _frames[i]->renderFlatShadowModel(shadowColor);
|
|
if (!res) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::pickPoly(DXVector3 *pickRayOrig, DXVector3 *pickRayDir) {
|
|
bool found = false;
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
found = _meshes[i]->pickPoly(pickRayOrig, pickRayDir);
|
|
if (found) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
found = _frames[i]->pickPoly(pickRayOrig, pickRayDir);
|
|
if (found) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::getBoundingBox(DXVector3 *boxStart, DXVector3 *boxEnd) {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
boxStart->_x = MIN(boxStart->_x, _meshes[i]->_BBoxStart._x);
|
|
boxStart->_y = MIN(boxStart->_y, _meshes[i]->_BBoxStart._y);
|
|
boxStart->_z = MIN(boxStart->_z, _meshes[i]->_BBoxStart._z);
|
|
|
|
boxEnd->_x = MAX(boxEnd->_x, _meshes[i]->_BBoxEnd._x);
|
|
boxEnd->_y = MAX(boxEnd->_y, _meshes[i]->_BBoxEnd._y);
|
|
boxEnd->_z = MAX(boxEnd->_z, _meshes[i]->_BBoxEnd._z);
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->getBoundingBox(boxStart, boxEnd);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::hasChildren() {
|
|
return _frames.getSize() > 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::setMaterialSprite(char *matName, BaseSprite *sprite) {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->setMaterialSprite(matName, sprite);
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->setMaterialSprite(matName, sprite);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::setMaterialTheora(char *matName, VideoTheoraPlayer *theora) {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->setMaterialTheora(matName, theora);
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->setMaterialTheora(matName, theora);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::setMaterialEffect(char *matName, Effect3D *effect, Effect3DParams *params) {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->setMaterialEffect(matName, effect, params);
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->setMaterialEffect(matName, effect, params);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::removeMaterialEffect(const char *matName) {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->removeMaterialEffect(matName);
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->removeMaterialEffect(matName);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::invalidateDeviceObjects() {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->invalidateDeviceObjects();
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->invalidateDeviceObjects();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool FrameNode::restoreDeviceObjects() {
|
|
for (int32 i = 0; i < _meshes.getSize(); i++) {
|
|
_meshes[i]->restoreDeviceObjects();
|
|
}
|
|
|
|
for (int32 i = 0; i < _frames.getSize(); i++) {
|
|
_frames[i]->restoreDeviceObjects();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace Wintermute
|