ScummVM/scummvm
1
0
Fork 0
mirror of https://github.com/scummvm/scummvm.git synced 2026-06-20 05:45:29 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
de151ea3fddd6a2d36a41400a55366bd2a6a94de
scummvm/engines/hpl1/engine/graphics/Mesh.cpp
T

979 lines
29 KiB
C++
Raw Blame History

/* 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/>.
*
*/
/*
* Copyright (C) 2006-2010 - Frictional Games
*
* This file is part of HPL1 Engine.
*/
#include "hpl1/engine/graphics/Mesh.h"
#include "hpl1/engine/graphics/Animation.h"
#include "hpl1/engine/graphics/Beam.h"
#include "hpl1/engine/graphics/BillBoard.h"
#include "hpl1/engine/graphics/Bone.h"
#include "hpl1/engine/graphics/BoneState.h"
#include "hpl1/engine/graphics/Material.h"
#include "hpl1/engine/graphics/ParticleSystem3D.h"
#include "hpl1/engine/graphics/Skeleton.h"
#include "hpl1/engine/graphics/SubMesh.h"
#include "hpl1/engine/graphics/VertexBuffer.h"
#include "hpl1/engine/resources/AnimationManager.h"
#include "hpl1/engine/resources/MaterialManager.h"
#include "hpl1/engine/math/Math.h"
#include "hpl1/engine/physics/PhysicsBody.h"
#include "hpl1/engine/physics/PhysicsJointBall.h"
#include "hpl1/engine/physics/PhysicsJointHinge.h"
#include "hpl1/engine/physics/PhysicsJointScrew.h"
#include "hpl1/engine/physics/PhysicsJointSlider.h"
#include "hpl1/engine/physics/PhysicsWorld.h"
#include "hpl1/engine/scene/Light3DPoint.h"
#include "hpl1/engine/scene/Light3DSpot.h"
#include "hpl1/engine/scene/MeshEntity.h"
#include "hpl1/engine/scene/Node3D.h"
#include "hpl1/engine/scene/SoundEntity.h"
#include "hpl1/engine/scene/World3D.h"
namespace hpl {
//////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS
//////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------
cMesh::cMesh(const tString asName, cMaterialManager *apMaterialManager,
cAnimationManager *apAnimationManager) : iResourceBase(asName, 0) {
mpMaterialManager = apMaterialManager;
mpAnimationManager = apAnimationManager;
mpSkeleton = NULL;
mpRootNode = hplNew(cNode3D, ());
}
//-----------------------------------------------------------------------
cMesh::~cMesh() {
for (int i = 0; i < (int)mvSubMeshes.size(); i++) {
hplDelete(mvSubMeshes[i]);
}
if (mpSkeleton)
hplDelete(mpSkeleton);
for (int i = 0; i < (int)mvAnimations.size(); i++) {
// mpAnimationManager->Destroy(mvAnimations[i]);
hplDelete(mvAnimations[i]);
}
if (mpRootNode)
hplDelete(mpRootNode);
STLDeleteAll(mvColliders);
STLDeleteAll(mvPhysicJoints);
STLDeleteAll(mvLights);
STLDeleteAll(mvBillboards);
STLDeleteAll(mvBeams);
STLDeleteAll(mvParticleSystems);
STLDeleteAll(mvReferences);
STLDeleteAll(mvSoundEntities);
}
//-----------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS
//////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------
bool cMesh::CreateFromFile(const tString asFile) {
return false;
}
//-----------------------------------------------------------------------
cSubMesh *cMesh::CreateSubMesh(const tString &asName) {
cSubMesh *pSubMesh = hplNew(cSubMesh, (asName, mpMaterialManager));
pSubMesh->mpParent = this;
mvSubMeshes.push_back(pSubMesh);
m_mapSubMeshes.insert(tSubMeshMap::value_type(asName, pSubMesh));
return pSubMesh;
}
//-----------------------------------------------------------------------
cSubMesh *cMesh::GetSubMesh(unsigned int alIdx) {
if (alIdx >= mvSubMeshes.size())
return NULL;
return mvSubMeshes[alIdx];
}
cSubMesh *cMesh::GetSubMeshName(const tString &asName) {
tSubMeshMapIt it = m_mapSubMeshes.find(asName);
if (it == m_mapSubMeshes.end())
return NULL;
return it->second;
}
int cMesh::GetSubMeshNum() {
return (int)mvSubMeshes.size();
}
//-----------------------------------------------------------------------
void cMesh::SetSkeleton(cSkeleton *apSkeleton) {
mpSkeleton = apSkeleton;
}
cSkeleton *cMesh::GetSkeleton() {
return mpSkeleton;
}
//-----------------------------------------------------------------------
void cMesh::AddAnimation(cAnimation *apAnimation) {
mvAnimations.push_back(apAnimation);
tAnimationIndexMap::value_type value(apAnimation->GetName(), (int)mvAnimations.size() - 1);
m_mapAnimIndices.insert(value);
}
cAnimation *cMesh::GetAnimation(int alIndex) {
return mvAnimations[alIndex];
}
cAnimation *cMesh::GetAnimationFromName(const tString &asName) {
int lIdx = GetAnimationIndex(asName);
if (lIdx >= 0) {
return mvAnimations[lIdx];
} else {
return NULL;
}
}
int cMesh::GetAnimationIndex(const tString &asName) {
tAnimationIndexMapIt it = m_mapAnimIndices.find(asName);
if (it != m_mapAnimIndices.end()) {
return it->second;
} else {
return -1;
}
}
void cMesh::ClearAnimations(bool abDeleteAll) {
if (abDeleteAll) {
for (int i = 0; i < (int)mvAnimations.size(); i++) {
// mpAnimationManager->Destroy(mvAnimations[i]);
hplDelete(mvAnimations[i]);
}
}
mvAnimations.clear();
m_mapAnimIndices.clear();
}
int cMesh::GetAnimationNum() {
return (int)mvAnimations.size();
}
//-----------------------------------------------------------------------
void cMesh::SetupBones() {
if (mpSkeleton == NULL)
return;
// Here is the place to add more hardware friendly stuffs.
}
//-----------------------------------------------------------------------
cMeshJoint *cMesh::CreatePhysicsJoint(ePhysicsJointType aType) {
cMeshJoint *pJoint = hplNew(cMeshJoint, ());
pJoint->mType = aType;
mvPhysicJoints.push_back(pJoint);
return pJoint;
}
cMeshJoint *cMesh::GetPhysicsJoint(int alIdx) {
return mvPhysicJoints[alIdx];
}
int cMesh::GetPhysicsJointNum() {
return (int)mvPhysicJoints.size();
}
//-----------------------------------------------------------------------
iPhysicsJoint *cMesh::CreateJointInWorld(const tString &sNamePrefix, cMeshJoint *apMeshJoint,
iPhysicsBody *apParentBody, iPhysicsBody *apChildBody,
const cMatrixf &a_mtxOffset, iPhysicsWorld *apWorld) {
cVector3f vPivot = cMath::MatrixMul(a_mtxOffset, apMeshJoint->mvPivot);
cVector3f vPinDir = cMath::MatrixMul(a_mtxOffset.GetRotation(), apMeshJoint->mvPinDir);
///////////////////////////
// Hinge
if (apMeshJoint->mType == ePhysicsJointType_Hinge) {
iPhysicsJointHinge *pJoint = apWorld->CreateJointHinge(sNamePrefix + apMeshJoint->msName,
vPivot, vPinDir, apParentBody,
apChildBody);
pJoint->SetCollideBodies(apMeshJoint->mbCollide);
pJoint->SetMinAngle(cMath::ToRad(-apMeshJoint->mfMin));
pJoint->SetMaxAngle(cMath::ToRad(apMeshJoint->mfMax));
return pJoint;
}
///////////////////////////
// Ball
else if (apMeshJoint->mType == ePhysicsJointType_Ball) {
iPhysicsJointBall *pJoint = apWorld->CreateJointBall(sNamePrefix + apMeshJoint->msName,
vPivot, apParentBody, apChildBody);
pJoint->SetCollideBodies(apMeshJoint->mbCollide);
pJoint->SetConeLimits(vPinDir, cMath::ToRad(apMeshJoint->mfMin), cMath::ToRad(apMeshJoint->mfMax));
return pJoint;
}
///////////////////////////
// Slider
else if (apMeshJoint->mType == ePhysicsJointType_Slider) {
iPhysicsJointSlider *pJoint = apWorld->CreateJointSlider(sNamePrefix + apMeshJoint->msName, vPivot, vPinDir, apParentBody, apChildBody);
pJoint->SetCollideBodies(apMeshJoint->mbCollide);
pJoint->SetMinDistance(apMeshJoint->mfMin);
pJoint->SetMaxDistance(apMeshJoint->mfMax);
return pJoint;
}
///////////////////////////
// Screw
else if (apMeshJoint->mType == ePhysicsJointType_Screw) {
iPhysicsJointScrew *pJoint = apWorld->CreateJointScrew(sNamePrefix + apMeshJoint->msName,
vPivot, vPinDir, apParentBody, apChildBody);
pJoint->SetCollideBodies(apMeshJoint->mbCollide);
pJoint->SetMinDistance(apMeshJoint->mfMin);
pJoint->SetMaxDistance(apMeshJoint->mfMax);
return pJoint;
}
return NULL;
}
//-----------------------------------------------------------------------
void cMesh::CreateNodeBodies(iPhysicsBody **apRootBodyPtr, Common::Array<iPhysicsBody *> *apBodyVec,
cMeshEntity *apEntity, iPhysicsWorld *apPhysicsWorld,
const cMatrixf &a_mtxTransform) {
cMatrixf mtxOldOffset;
// Log("Creating node bodies!\n");
///////////////////////////////////
// Create bodies for the sub meshes (if available
for (int sub = 0; sub < GetSubMeshNum(); sub++) {
cSubMesh *pSubMesh = GetSubMesh(sub);
cSubMeshEntity *pSubEntity = apEntity->GetSubMeshEntity(sub);
tCollideShapeVec vShapes;
for (int shape = 0; shape < GetColliderNum(); shape++) {
cMeshCollider *pColl = GetCollider(shape);
if (pColl->msGroup == pSubMesh->GetGroup() && pColl->msGroup != "") {
mtxOldOffset = pColl->m_mtxOffset;
// Remove the scale
cMatrixf mtxSub = pSubEntity->GetWorldMatrix();
cMatrixf mtxScale = cMath::MatrixScale(pSubMesh->GetModelScale());
mtxSub = cMath::MatrixMul(mtxSub, cMath::MatrixInverse(mtxScale));
// Get the local offset of the collider, relative to the sub mesh
pColl->m_mtxOffset = cMath::MatrixMul(cMath::MatrixInverse(mtxSub),
pColl->m_mtxOffset);
// Create shape
iCollideShape *pShape = CreateCollideShapeFromCollider(pColl, apPhysicsWorld);
vShapes.push_back(pShape);
// Log("Created shape size: %s offset: %s\n",pShape->GetSize().ToString().c_str(),pShape->);
pColl->m_mtxOffset = mtxOldOffset;
}
}
// Create the compound shape if needed.
iCollideShape *pShape;
if (vShapes.size() > 1) {
pShape = apPhysicsWorld->CreateCompundShape(vShapes);
} else if (vShapes.size() == 1) {
pShape = vShapes[0];
} else {
Warning("No shapes for sub mesh '%s' with group: '%s'\n", pSubMesh->GetName().c_str(),
pSubMesh->GetGroup().c_str());
// return;
continue;
}
// Create body and set mass to 0 since these bodies are animated and
// can therefore be considered static.
iPhysicsBody *pBody = apPhysicsWorld->CreateBody(apEntity->GetName() + "_" + pSubMesh->GetName(),
pShape);
pBody->SetMass(0);
pBody->SetGravity(false);
pSubEntity->SetBody(pBody);
pSubEntity->SetUpdateBody(true);
apBodyVec->push_back(pBody);
}
///////////////////////////////////
// Create bodies for root
tCollideShapeVec vShapes;
for (int shape = 0; shape < GetColliderNum(); shape++) {
cMeshCollider *pColl = GetCollider(shape);
if (pColl->msGroup == "") {
// Create shape
iCollideShape *pShape = CreateCollideShapeFromCollider(pColl, apPhysicsWorld);
vShapes.push_back(pShape);
/*cMatrixf mtxOffset = */pShape->GetOffset();
// Log("Created shape size: %s at %s. Mtx: %s\n",pShape->GetSize().ToString().c_str(),
// pShape->GetOffset().GetTranslation().ToString().c_str(),
// mtxOffset.ToString().c_str());
}
}
bool bHasRoot = false;
iCollideShape *pShape;
if (vShapes.size() > 1) {
pShape = apPhysicsWorld->CreateCompundShape(vShapes);
bHasRoot = true;
} else if (vShapes.size() == 1) {
pShape = vShapes[0];
bHasRoot = true;
} else {
return;
}
if (bHasRoot) {
// Log("Creating root body!\n");
iPhysicsBody *pBody = apPhysicsWorld->CreateBody(apEntity->GetName(),
pShape);
pBody->CreateNode()->AddEntity(apEntity);
pBody->SetMass(0);
apEntity->SetBody(pBody);
pBody->SetMatrix(a_mtxTransform);
apBodyVec->push_back(pBody);
}
}
//-----------------------------------------------------------------------
void cMesh::CreateJointsAndBodies(Common::Array<iPhysicsBody *> *apBodyVec, cMeshEntity *apEntity,
Common::Array<iPhysicsJoint *> *apJointVec,
const cMatrixf &a_mtxOffset, iPhysicsWorld *apPhysicsWorld) {
Common::Array<iPhysicsBody *> vBodies;
//////////////////////////////////
// If the mesh has a skeleton, attach the bodies to the bones
// in the skeleton.
if (mpSkeleton) {
// TODO: Set root node to identity matrix
for (int bone = 0; bone < apEntity->GetBoneStateNum(); ++bone) {
cBoneState *pBoneState = apEntity->GetBoneState(bone);
/////////////////////////////////////////////////////
// Iterate the colliders and get the sum of offsets.
cVector3f vShapeWorldCenter(0, 0, 0);
float fColliderNum = 0;
for (int shape = 0; shape < GetColliderNum(); shape++) {
cMeshCollider *pColl = GetCollider(shape);
if (pColl->msGroup == pBoneState->GetName()) {
vShapeWorldCenter += pColl->m_mtxOffset.GetTranslation();
fColliderNum += 1;
}
}
vShapeWorldCenter = vShapeWorldCenter / fColliderNum;
cMatrixf mtxBodyWorld = cMath::MatrixTranslate(vShapeWorldCenter);
cMatrixf mtxInvBodyWorld = cMath::MatrixInverse(mtxBodyWorld);
cMatrixf mtxBone = pBoneState->GetWorldMatrix();
cMatrixf mtxInvBone = cMath::MatrixInverse(mtxBone);
cMatrixf mtxBoneToBody = cMath::MatrixMul(mtxInvBone, mtxBodyWorld);
///////////////////////////////////////////////////////////
// Iterate the colliders and search for the colliders for each object.
cMatrixf mtxOldOffset;
tCollideShapeVec vShapes;
for (int shape = 0; shape < GetColliderNum(); shape++) {
cMeshCollider *pColl = GetCollider(shape);
if (pColl->msGroup == pBoneState->GetName()) {
mtxOldOffset = pColl->m_mtxOffset;
cMatrixf mtxBodyToCollider = cMath::MatrixMul(mtxInvBodyWorld, pColl->m_mtxOffset);
pColl->m_mtxOffset = mtxBodyToCollider;
iCollideShape *pShape = CreateCollideShapeFromCollider(pColl, apPhysicsWorld);
vShapes.push_back(pShape);
// Setting old offset
pColl->m_mtxOffset = mtxOldOffset;
}
}
////////////////////////////////
// Create body
if (vShapes.size() > 0) {
// Create the compound shape if needed.
iCollideShape *pShape = nullptr;
if (vShapes.size() > 1) {
pShape = apPhysicsWorld->CreateCompundShape(vShapes);
} else if (vShapes.size() == 1) {
pShape = vShapes[0];
}
//////////////////////////////////////////
// Create normal body and set mass to 1 for now.
iPhysicsBody *pBody = apPhysicsWorld->CreateBody(apEntity->GetName() + "_" + pBoneState->GetName(),
pShape);
pBody->SetMass(1);
pBody->SetActive(false);
pBody->SetIsRagDoll(true);
pBody->SetCollideRagDoll(false);
pBody->SetMatrix(cMath::MatrixMul(a_mtxOffset, mtxBodyWorld));
pBoneState->SetBody(pBody);
pBoneState->SetBodyMatrix(mtxBoneToBody);
if (apBodyVec)
apBodyVec->push_back(pBody);
vBodies.push_back(pBody);
/////////////////////////////////////
// Create collider body
iPhysicsBody *pColliderBody = apPhysicsWorld->CreateBody(apEntity->GetName() + "_collider_" + pBoneState->GetName(),
pShape);
pColliderBody->SetMass(0);
pColliderBody->SetActive(false);
pColliderBody->SetCollideCharacter(false);
pBoneState->SetColliderBody(pColliderBody);
if (apBodyVec)
apBodyVec->push_back(pColliderBody);
}
}
// TODO: Reset root node matrix
}
///////////////////////////////////
// Create bodies for the sub meshes.
else {
for (int sub = 0; sub < GetSubMeshNum(); sub++) {
cSubMesh *pSubMesh = GetSubMesh(sub);
cSubMeshEntity *pSubEntity = apEntity->GetSubMeshEntity(sub);
bool bGroupShare = false;
// Check if the submesh is a child of another mesh,
// if so skip it.
for (int i = 0; i < GetSubMeshNum(); ++i) {
if (i == sub)
continue;
cSubMesh *pExtraSub = GetSubMesh(i);
cSubMeshEntity *pExtraEntity = apEntity->GetSubMeshEntity(i);
if (pSubMesh->GetGroup() == pExtraSub->GetNodeName()) {
pExtraEntity->AddChild(pSubEntity);
pSubEntity->SetMatrix(pSubMesh->GetLocalTransform());
bGroupShare = true;
break;
}
}
if (bGroupShare)
continue;
// Extra check to see if any other sub object chairs the group.
for (int i = 0; i < GetSubMeshNum(); ++i) {
if (i == sub)
continue;
cSubMesh *pExtraSub = GetSubMesh(i);
if (pExtraSub->GetGroup() == pSubMesh->GetGroup()) {
Error("SubMesh %s shares group with %s\n", pSubMesh->GetName().c_str(),
pExtraSub->GetName().c_str());
bGroupShare = true;
}
}
if (bGroupShare)
continue;
cMatrixf mtxOldOffset;
// Log("Sub: %s group: '%s'\n",pSubMesh->GetName().c_str(),pSubMesh->GetGroup().c_str());
// Iterate the colliders and search for the colliders for each object.
tCollideShapeVec vShapes;
for (int shape = 0; shape < GetColliderNum(); shape++) {
cMeshCollider *pColl = GetCollider(shape);
if (pColl->msGroup == pSubMesh->GetGroup()) {
mtxOldOffset = pColl->m_mtxOffset;
// Remove the scale
cMatrixf mtxSub = pSubEntity->GetWorldMatrix();
// Log("SubEntity '%s' : %s\n",pSubEntity->GetName().c_str(),mtxSub.ToString().c_str());
// if(pSubEntity->GetParent())
// Log("Node parent: %s\n",static_cast<cNode3D*>(pSubEntity->GetParent())->GetName());
// The scale should allready been removed.
/*cMatrixf mtxScale = cMath::MatrixScale(pSubMesh->GetModelScale());
mtxSub = cMath::MatrixMul(mtxSub, cMath::MatrixInverse(mtxScale));*/
// Get the local offset of the collider, relative to the sub mesh
pColl->m_mtxOffset = cMath::MatrixMul(cMath::MatrixInverse(mtxSub),
pColl->m_mtxOffset);
iCollideShape *pShape = CreateCollideShapeFromCollider(pColl, apPhysicsWorld);
vShapes.push_back(pShape);
// Log("Created shapes!\n");
// Setting old offset
pColl->m_mtxOffset = mtxOldOffset;
}
}
// Create the compound shape if needed.
iCollideShape *pShape;
if (vShapes.size() > 1) {
pShape = apPhysicsWorld->CreateCompundShape(vShapes);
} else if (vShapes.size() == 1) {
pShape = vShapes[0];
} else {
Error("No shapes for submesh '%s' with group: '%s' in mesh '%s'\n", pSubMesh->GetName().c_str(),
pSubMesh->GetGroup().c_str(), msName.c_str());
continue;
}
// Create body and set mass to 1 for now.
iPhysicsBody *pBody = apPhysicsWorld->CreateBody(apEntity->GetName() + "_" + pSubMesh->GetName(),
pShape);
pBody->CreateNode()->AddEntity(pSubEntity);
pBody->SetMass(1);
pBody->SetMatrix(cMath::MatrixMul(a_mtxOffset, pSubEntity->GetWorldMatrix()));
pSubEntity->SetMatrix(cMatrixf::Identity);
pSubEntity->SetBody(pBody);
if (apBodyVec)
apBodyVec->push_back(pBody);
vBodies.push_back(pBody);
}
}
/////////////////////////////////////////////////////
// Iterate the mesh joints and create physics joints
for (int joint = 0; joint < GetPhysicsJointNum(); joint++) {
cMeshJoint *pMeshJoint = GetPhysicsJoint(joint);
// Convert name to global
tString sChildBody = apEntity->GetName() + "_" + pMeshJoint->msChildBody;
tString sParentBody = apEntity->GetName() + "_" + pMeshJoint->msParentBody;
// Get Parent and Child body
iPhysicsBody *pChildBody = NULL;
iPhysicsBody *pParentBody = NULL;
for (int body = 0; body < (int)vBodies.size(); body++) {
iPhysicsBody *pBody = vBodies[body];
if (pBody->GetName() == sChildBody) {
pChildBody = pBody;
} else if (pBody->GetName() == sParentBody) {
pParentBody = pBody;
}
}
if (pParentBody == NULL && pMeshJoint->msParentBody != "") {
Warning("Parent body '%s' for joint '%s' in mesh '%s' does not exist!\n", pMeshJoint->msParentBody.c_str(),
pMeshJoint->msName.c_str(), msName.c_str());
continue;
}
if (pChildBody == NULL) {
Error("Child body '%s' for joint '%s' in mesh '%s' does not exist!\n", pMeshJoint->msChildBody.c_str(),
pMeshJoint->msName.c_str(), msName.c_str());
continue;
}
iPhysicsJoint *pJoint = CreateJointInWorld(apEntity->GetName() + "_", pMeshJoint,
pParentBody, pChildBody,
a_mtxOffset, apPhysicsWorld);
if (apJointVec)
apJointVec->push_back(pJoint);
}
if (GetSkeleton())
apEntity->SetMatrix(a_mtxOffset);
}
//-----------------------------------------------------------------------
bool cMesh::HasSeveralBodies() {
if (GetColliderNum() <= 0)
return false;
tString sPrevGroup = GetCollider(0)->msGroup;
for (int shape = 1; shape < GetColliderNum(); shape++) {
cMeshCollider *pColl = GetCollider(shape);
if (pColl->msGroup != sPrevGroup)
return true;
}
return false;
}
//-----------------------------------------------------------------------
cMeshCollider *cMesh::CreateCollider(eCollideShapeType aType) {
cMeshCollider *pColl = hplNew(cMeshCollider, ());
pColl->mType = aType;
mvColliders.push_back(pColl);
return pColl;
}
cMeshCollider *cMesh::GetCollider(int alIdx) {
return mvColliders[alIdx];
}
int cMesh::GetColliderNum() {
return (int)mvColliders.size();
}
iCollideShape *cMesh::CreateCollideShapeFromCollider(cMeshCollider *pCollider, iPhysicsWorld *apWorld) {
switch (pCollider->mType) {
case eCollideShapeType_Box:
return apWorld->CreateBoxShape(pCollider->mvSize, &pCollider->m_mtxOffset);
case eCollideShapeType_Sphere:
return apWorld->CreateSphereShape(pCollider->mvSize, &pCollider->m_mtxOffset);
case eCollideShapeType_Cylinder:
return apWorld->CreateCylinderShape(pCollider->mvSize.x, pCollider->mvSize.y, &pCollider->m_mtxOffset);
case eCollideShapeType_Capsule:
return apWorld->CreateCapsuleShape(pCollider->mvSize.x, pCollider->mvSize.y, &pCollider->m_mtxOffset);
default:
return NULL;
}
}
iCollideShape *cMesh::CreateCollideShape(iPhysicsWorld *apWorld) {
if (mvColliders.empty())
return NULL;
// Create a single object
if (mvColliders.size() == 1) {
return CreateCollideShapeFromCollider(mvColliders[0], apWorld);
}
// Create compound object
else {
tCollideShapeVec vShapes;
vShapes.reserve(mvColliders.size());
for (size_t i = 0; i < mvColliders.size(); ++i) {
vShapes.push_back(CreateCollideShapeFromCollider(mvColliders[i], apWorld));
}
return apWorld->CreateCompundShape(vShapes);
}
}
//-----------------------------------------------------------------------
cMeshLight *cMesh::CreateLight(eLight3DType aType) {
cMeshLight *pLight = hplNew(cMeshLight, ());
mvLights.push_back(pLight);
return pLight;
}
cMeshLight *cMesh::GetLight(int alIdx) {
return mvLights[alIdx];
}
int cMesh::GetLightNum() {
return (int)mvLights.size();
}
iLight3D *cMesh::CreateLightInWorld(const tString &sNamePrefix, cMeshLight *apMeshLight,
cMeshEntity *apMeshEntity, cWorld3D *apWorld) {
iLight3D *pLight = NULL;
////////////////////////////////
// Spot
if (apMeshLight->mType == eLight3DType_Spot) {
cLight3DSpot *pLightSpot = apWorld->CreateLightSpot(sNamePrefix + "_" + apMeshLight->msName);
pLightSpot->SetDiffuseColor(apMeshLight->mColor);
pLightSpot->SetFarAttenuation(apMeshLight->mfRadius);
pLightSpot->SetFOV(apMeshLight->mfFOV);
if (apMeshLight->msFile != "")
pLightSpot->LoadXMLProperties(apMeshLight->msFile);
pLight = pLightSpot;
}
////////////////////////////////
// Point
else if (apMeshLight->mType == eLight3DType_Point) {
cLight3DPoint *pLightPoint = apWorld->CreateLightPoint(sNamePrefix + "_" + apMeshLight->msName);
pLightPoint->SetDiffuseColor(apMeshLight->mColor);
pLightPoint->SetFarAttenuation(apMeshLight->mfRadius);
pLightPoint->SetCastShadows(apMeshLight->mbCastShadows);
if (apMeshLight->msFile != "")
pLightPoint->LoadXMLProperties(apMeshLight->msFile);
pLight = pLightPoint;
} else {
return NULL;
}
pLight->SetMatrix(apMeshLight->m_mtxTransform);
apMeshEntity->AttachEntityToParent(pLight, apMeshLight->msParent);
return pLight;
}
//-----------------------------------------------------------------------
cMeshBillboard *cMesh::CreateBillboard() {
cMeshBillboard *pBillboard = hplNew(cMeshBillboard, ());
mvBillboards.push_back(pBillboard);
return pBillboard;
}
cMeshBillboard *cMesh::GetBillboard(int alIdx) {
return mvBillboards[alIdx];
}
int cMesh::GetBillboardNum() {
return (int)mvBillboards.size();
}
cBillboard *cMesh::CreateBillboardInWorld(const tString &sNamePrefix, cMeshBillboard *apMeshBillboard,
cMeshEntity *apMeshEntity, cWorld3D *apWorld) {
cBillboard *pBillboard = apWorld->CreateBillboard(sNamePrefix + "_" + apMeshBillboard->msName,
apMeshBillboard->mvSize);
pBillboard->SetAxis(apMeshBillboard->mvAxis);
pBillboard->SetPosition(apMeshBillboard->mvPosition);
pBillboard->SetForwardOffset(apMeshBillboard->mfOffset);
pBillboard->LoadXMLProperties(apMeshBillboard->msFile);
apMeshEntity->AttachEntityToParent(pBillboard, apMeshBillboard->msParent);
return pBillboard;
}
//-----------------------------------------------------------------------
cMeshBeam *cMesh::CreateBeam() {
cMeshBeam *pBeam = hplNew(cMeshBeam, ());
mvBeams.push_back(pBeam);
return pBeam;
}
cMeshBeam *cMesh::GetBeam(int alIdx) {
return mvBeams[alIdx];
}
int cMesh::GetBeamNum() {
return (int)mvBeams.size();
}
cBeam *cMesh::CreateBeamInWorld(const tString &sNamePrefix, cMeshBeam *apMeshBeam,
cMeshEntity *apMeshEntity, cWorld3D *apWorld) {
cBeam *pBeam = apWorld->CreateBeam(sNamePrefix + "_" + apMeshBeam->msName);
pBeam->SetPosition(apMeshBeam->mvStartPosition);
pBeam->GetEnd()->SetPosition(apMeshBeam->mvEndPosition);
pBeam->LoadXMLProperties(apMeshBeam->msFile);
apMeshEntity->AttachEntityToParent(pBeam, apMeshBeam->msStartParent);
apMeshEntity->AttachEntityToParent(pBeam->GetEnd(), apMeshBeam->msEndParent);
return pBeam;
}
//-----------------------------------------------------------------------
cMeshReference *cMesh::CreateReference() {
cMeshReference *pRef = hplNew(cMeshReference, ());
mvReferences.push_back(pRef);
return pRef;
}
cMeshReference *cMesh::GetReference(int alIdx) {
return mvReferences[alIdx];
}
int cMesh::GetReferenceNum() {
return (int)mvReferences.size();
}
iEntity3D *cMesh::CreateReferenceInWorld(const tString &sNamePrefix,
cMeshReference *apMeshRef,
cMeshEntity *apMeshEntity, cWorld3D *apWorld,
const cMatrixf &a_mtxOffset) {
if (apMeshRef->msParent != "") {
tString sName = sNamePrefix + "_" + apMeshRef->msName;
iEntity3D *pEntity = apWorld->CreateEntity(sName,
apMeshRef->m_mtxTransform,
apMeshRef->msFile, true);
if (pEntity)
apMeshEntity->AttachEntityToParent(pEntity, apMeshRef->msParent);
return pEntity;
} else {
tString sName = sNamePrefix + "_" + apMeshRef->msName;
iEntity3D *pEntity = apWorld->CreateEntity(sName,
cMath::MatrixMul(a_mtxOffset, apMeshRef->m_mtxTransform),
apMeshRef->msFile, true);
// Log("Created ref: %s\n",sName.c_str());
return pEntity;
}
}
//-----------------------------------------------------------------------
cMeshParticleSystem *cMesh::CreateParticleSystem() {
cMeshParticleSystem *pPS = hplNew(cMeshParticleSystem, ());
mvParticleSystems.push_back(pPS);
return pPS;
}
cMeshParticleSystem *cMesh::GetParticleSystem(int alIdx) {
return mvParticleSystems[alIdx];
}
int cMesh::GetParticleSystemNum() {
return (int)mvParticleSystems.size();
}
cParticleSystem3D *cMesh::CreateParticleSystemInWorld(const tString &sNamePrefix,
cMeshParticleSystem *apMeshPS,
cMeshEntity *apMeshEntity, cWorld3D *apWorld) {
cParticleSystem3D *pPS = apWorld->CreateParticleSystem(sNamePrefix + "_" + apMeshPS->msName,
apMeshPS->msType, apMeshPS->mvSize, apMeshPS->m_mtxTransform);
if (pPS == NULL) {
Error("Couldn't create particle system '%s'\n", apMeshPS->msType.c_str());
return NULL;
}
apMeshEntity->AttachEntityToParent(pPS, apMeshPS->msParent);
return pPS;
}
//-----------------------------------------------------------------------
cMeshSoundEntity *cMesh::CreateSoundEntity() {
cMeshSoundEntity *pSound = hplNew(cMeshSoundEntity, ());
mvSoundEntities.push_back(pSound);
return pSound;
}
cMeshSoundEntity *cMesh::GetSoundEntity(int alIdx) {
return mvSoundEntities[alIdx];
}
int cMesh::GetSoundEntityNum() {
return (int)mvSoundEntities.size();
}
cSoundEntity *cMesh::CreateSoundEntityInWorld(const tString &sNamePrefix, cMeshSoundEntity *apMeshSound,
cMeshEntity *apMeshEntity, cWorld3D *apWorld) {
tString sName = sNamePrefix + "_" + apMeshSound->msName;
cSoundEntity *pSound = apWorld->CreateSoundEntity(sName,
apMeshSound->msType, false);
// Log("Created sound entity: '%s'\n",sName.c_str());
if (pSound == NULL) {
Error("Couldn't create sound entity '%s'\n", apMeshSound->msType.c_str());
return NULL;
}
pSound->SetPosition(apMeshSound->mvPosition);
apMeshEntity->AttachEntityToParent(pSound, apMeshSound->msParent);
return pSound;
}
//-----------------------------------------------------------------------
cNode3D *cMesh::GetRootNode() {
return mpRootNode;
}
void cMesh::AddNode(cNode3D *apNode) {
mvNodes.push_back(apNode);
}
int cMesh::GetNodeNum() {
return (int)mvNodes.size();
}
cNode3D *cMesh::GetNode(int alIdx) {
return mvNodes[alIdx];
}
//-----------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////
// PRIAVTE METHODS
//////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
} // namespace hpl
Reference in New Issue View Git Blame Copy Permalink