AxioDL/PrimeWorldEditor
2
0
Fork 0
mirror of https://github.com/AxioDL/PrimeWorldEditor.git synced 2025-12-13 15:16:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor so PWE compiles with the newly externalized LibCommon

Browse Source
This commit is contained in:
Aruki
2018-12-11 22:50:46 -07:00
parent dacd21d7fc
commit 2287b05bc3
298 changed files with 3192 additions and 3184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/Core/Scene/CCharacterNode.cpp
View File

@@ -2,7 +2,7 @@
#include "Core/Render/CRenderer.h"
#include <Common/CTimer.h>
CCharacterNode::CCharacterNode(CScene *pScene, u32 NodeID, CAnimSet *pChar /*= 0*/, CSceneNode *pParent /*= 0*/)
CCharacterNode::CCharacterNode(CScene *pScene, uint32 NodeID, CAnimSet *pChar /*= 0*/, CSceneNode *pParent /*= 0*/)
: CSceneNode(pScene, NodeID, pParent)
, mAnimated(true)
, mAnimTime(0.f)
@@ -19,7 +19,7 @@ void CCharacterNode::PostLoad()
{
if (mpCharacter)
{
for (u32 iChar = 0; iChar < mpCharacter->NumCharacters(); iChar++)
for (uint32 iChar = 0; iChar < mpCharacter->NumCharacters(); iChar++)
mpCharacter->Character(iChar)->pModel->BufferGL();
}
}
@@ -78,7 +78,7 @@ void CCharacterNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCom
}
}
SRayIntersection CCharacterNode::RayNodeIntersectTest(const CRay& rkRay, u32 /*AssetID*/, const SViewInfo& rkViewInfo)
SRayIntersection CCharacterNode::RayNodeIntersectTest(const CRay& rkRay, uint32 /*AssetID*/, const SViewInfo& rkViewInfo)
{
// Check for bone under ray. Doesn't check for model intersections atm
if (mpCharacter && rkViewInfo.ShowFlags.HasFlag(eShowSkeletons))
@@ -88,7 +88,7 @@ SRayIntersection CCharacterNode::RayNodeIntersectTest(const CRay& rkRay, u32 /*A
if (pSkel)
{
UpdateTransformData();
std::pair<s32,float> Hit = pSkel->RayIntersect(rkRay, mTransformData);
std::pair<int32,float> Hit = pSkel->RayIntersect(rkRay, mTransformData);
if (Hit.first != -1)
{
@@ -106,7 +106,7 @@ SRayIntersection CCharacterNode::RayNodeIntersectTest(const CRay& rkRay, u32 /*A
return SRayIntersection();
}
CVector3f CCharacterNode::BonePosition(u32 BoneID)
CVector3f CCharacterNode::BonePosition(uint32 BoneID)
{
UpdateTransformData();
CSkeleton *pSkel = (mpCharacter ? mpCharacter->Character(mActiveCharSet)->pSkeleton : nullptr);
@@ -128,7 +128,7 @@ void CCharacterNode::SetCharSet(CAnimSet *pChar)
mLocalAABox = CAABox::skOne;
}
void CCharacterNode::SetActiveChar(u32 CharIndex)
void CCharacterNode::SetActiveChar(uint32 CharIndex)
{
mActiveCharSet = CharIndex;
ConditionalSetDirty();
@@ -142,7 +142,7 @@ void CCharacterNode::SetActiveChar(u32 CharIndex)
}
}
void CCharacterNode::SetActiveAnim(u32 AnimIndex)
void CCharacterNode::SetActiveAnim(uint32 AnimIndex)
{
mActiveAnim = AnimIndex;
ConditionalSetDirty();

18
src/Core/Scene/CCharacterNode.h
View File

@@ -9,30 +9,30 @@ class CCharacterNode : public CSceneNode
{
TResPtr<CAnimSet> mpCharacter;
CBoneTransformData mTransformData;
u32 mActiveCharSet;
u32 mActiveAnim;
uint32 mActiveCharSet;
uint32 mActiveAnim;
bool mAnimated;
float mAnimTime;
mutable bool mTransformDataDirty;
public:
explicit CCharacterNode(CScene *pScene, u32 NodeID, CAnimSet *pChar = 0, CSceneNode *pParent = 0);
explicit CCharacterNode(CScene *pScene, uint32 NodeID, CAnimSet *pChar = 0, CSceneNode *pParent = 0);
virtual ENodeType NodeType();
virtual void PostLoad();
virtual void AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo);
virtual void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
virtual SRayIntersection RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo);
virtual SRayIntersection RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo);
CVector3f BonePosition(u32 BoneID);
CVector3f BonePosition(uint32 BoneID);
void SetCharSet(CAnimSet *pChar);
void SetActiveChar(u32 CharIndex);
void SetActiveAnim(u32 AnimIndex);
void SetActiveChar(uint32 CharIndex);
void SetActiveAnim(uint32 AnimIndex);
inline CAnimSet* Character() const { return mpCharacter; }
inline u32 ActiveCharIndex() const { return mActiveCharSet; }
inline u32 ActiveAnimIndex() const { return mActiveAnim; }
inline uint32 ActiveCharIndex() const { return mActiveCharSet; }
inline uint32 ActiveAnimIndex() const { return mActiveAnim; }
inline CAnimation* CurrentAnim() const { return (mAnimated && mpCharacter ? mpCharacter->FindAnimationAsset(mActiveAnim) : nullptr); }
inline bool IsAnimated() const { return (mAnimated && CurrentAnim() != nullptr); }

8
src/Core/Scene/CCollisionNode.cpp
View File

@@ -4,7 +4,7 @@
#include "Core/Render/CGraphics.h"
#include "Core/Render/CRenderer.h"
CCollisionNode::CCollisionNode(CScene *pScene, u32 NodeID, CSceneNode *pParent, CCollisionMeshGroup *pCollision)
CCollisionNode::CCollisionNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CCollisionMeshGroup *pCollision)
: CSceneNode(pScene, NodeID, pParent)
{
SetCollision(pCollision);
@@ -47,11 +47,11 @@ void CCollisionNode::Draw(FRenderOptions /*Options*/, int /*ComponentIndex*/, ER
CColor BaseTint = TintColor(rkViewInfo);
for (u32 iMesh = 0; iMesh < mpCollision->NumMeshes(); iMesh++)
for (uint32 iMesh = 0; iMesh < mpCollision->NumMeshes(); iMesh++)
{
CCollisionMesh *pMesh = mpCollision->MeshByIndex(iMesh);
for (u32 iMat = 0; iMat < pMesh->NumMaterials(); iMat++)
for (uint32 iMat = 0; iMat < pMesh->NumMaterials(); iMat++)
{
CCollisionMaterial& rMat = pMesh->GetMaterial(iMat);
@@ -95,7 +95,7 @@ void CCollisionNode::RayAABoxIntersectTest(CRayCollisionTester& /*rTester*/, con
// todo
}
SRayIntersection CCollisionNode::RayNodeIntersectTest(const CRay& /*rkRay*/, u32 /*AssetID*/, const SViewInfo& /*rkViewInfo*/)
SRayIntersection CCollisionNode::RayNodeIntersectTest(const CRay& /*rkRay*/, uint32 /*AssetID*/, const SViewInfo& /*rkViewInfo*/)
{
// todo
SRayIntersection Result;

4
src/Core/Scene/CCollisionNode.h
View File

@@ -9,12 +9,12 @@ class CCollisionNode : public CSceneNode
TResPtr<CCollisionMeshGroup> mpCollision;
public:
CCollisionNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0, CCollisionMeshGroup *pCollision = 0);
CCollisionNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0, CCollisionMeshGroup *pCollision = 0);
ENodeType NodeType();
void AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo);
void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
void RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo);
void SetCollision(CCollisionMeshGroup *pCollision);
};

6
src/Core/Scene/CLightNode.cpp
View File

@@ -2,9 +2,9 @@
#include "Core/Render/CDrawUtil.h"
#include "Core/Render/CGraphics.h"
#include "Core/Render/CRenderer.h"
#include <Math/MathUtil.h>
#include <Common/Math/MathUtil.h>
CLightNode::CLightNode(CScene *pScene, u32 NodeID, CSceneNode *pParent, CLight *pLight)
CLightNode::CLightNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CLight *pLight)
: CSceneNode(pScene, NodeID, pParent)
, mpLight(pLight)
{
@@ -63,7 +63,7 @@ void CLightNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SView
if (BoxResult.first) rTester.AddNode(this, 0, BoxResult.second);
}
SRayIntersection CLightNode::RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo)
SRayIntersection CLightNode::RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo)
{
// todo: come up with a better way to share this code between CScriptNode and CLightNode
SRayIntersection Out;

4
src/Core/Scene/CLightNode.h
View File

@@ -8,13 +8,13 @@ class CLightNode : public CSceneNode
{
CLight *mpLight;
public:
CLightNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0, CLight *Light = 0);
CLightNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0, CLight *Light = 0);
ENodeType NodeType();
void AddToRenderer(CRenderer *pRenderer, const SViewInfo& ViewInfo);
void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& ViewInfo);
void DrawSelection();
void RayAABoxIntersectTest(CRayCollisionTester& Tester, const SViewInfo& ViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay &Ray, u32 AssetID, const SViewInfo& ViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay &Ray, uint32 AssetID, const SViewInfo& ViewInfo);
CStructRef GetProperties() const;
void PropertyModified(IProperty* pProperty);
bool AllowsRotate() const { return false; }

8
src/Core/Scene/CModelNode.cpp
View File

@@ -2,9 +2,9 @@
#include "Core/Render/CDrawUtil.h"
#include "Core/Render/CRenderer.h"
#include "Core/Render/CGraphics.h"
#include <Math/MathUtil.h>
#include <Common/Math/MathUtil.h>
CModelNode::CModelNode(CScene *pScene, u32 NodeID, CSceneNode *pParent, CModel *pModel)
CModelNode::CModelNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CModel *pModel)
: CSceneNode(pScene, NodeID, pParent)
, mWorldModel(false)
, mForceAlphaOn(false)
@@ -40,7 +40,7 @@ void CModelNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo
{
pRenderer->AddMesh(this, -1, AABox(), false, eDrawOpaqueParts);
for (u32 iSurf = 0; iSurf < mpModel->GetSurfaceCount(); iSurf++)
for (uint32 iSurf = 0; iSurf < mpModel->GetSurfaceCount(); iSurf++)
{
if (mpModel->IsSurfaceTransparent(iSurf, mActiveMatSet))
pRenderer->AddMesh(this, iSurf, mpModel->GetSurfaceAABox(iSurf).Transformed(Transform()), true, eDrawTransparentParts);
@@ -129,7 +129,7 @@ void CModelNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SView
rTester.AddNodeModel(this, mpModel);
}
SRayIntersection CModelNode::RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo)
SRayIntersection CModelNode::RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo)
{
SRayIntersection Out;
Out.pNode = this;

12
src/Core/Scene/CModelNode.h
View File

@@ -7,7 +7,7 @@
class CModelNode : public CSceneNode
{
TResPtr<CModel> mpModel;
u32 mActiveMatSet;
uint32 mActiveMatSet;
bool mWorldModel;
bool mForceAlphaOn;
CColor mTintColor;
@@ -15,7 +15,7 @@ class CModelNode : public CSceneNode
CColor mScanOverlayColor;
public:
explicit CModelNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0, CModel *pModel = 0);
explicit CModelNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0, CModel *pModel = 0);
virtual ENodeType NodeType();
virtual void PostLoad();
@@ -23,13 +23,13 @@ public:
virtual void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
virtual void DrawSelection();
virtual void RayAABoxIntersectTest(CRayCollisionTester& Tester, const SViewInfo& rkViewInfo);
virtual SRayIntersection RayNodeIntersectTest(const CRay &Ray, u32 AssetID, const SViewInfo& rkViewInfo);
virtual SRayIntersection RayNodeIntersectTest(const CRay &Ray, uint32 AssetID, const SViewInfo& rkViewInfo);
virtual CColor TintColor(const SViewInfo& rkViewInfo) const;
// Setters
void SetModel(CModel *pModel);
inline void SetMatSet(u32 MatSet) { mActiveMatSet = MatSet; }
inline void SetMatSet(uint32 MatSet) { mActiveMatSet = MatSet; }
inline void SetWorldModel(bool World) { mWorldModel = World; }
inline void ForceAlphaEnabled(bool Enable) { mForceAlphaOn = Enable; }
inline void SetTintColor(const CColor& rkTintColor) { mTintColor = rkTintColor; }
@@ -37,9 +37,9 @@ public:
inline void SetScanOverlayEnabled(bool Enable) { mEnableScanOverlay = Enable; }
inline void SetScanOverlayColor(const CColor& rkColor) { mScanOverlayColor = rkColor; }
inline CModel* Model() const { return mpModel; }
inline u32 MatSet() const { return mActiveMatSet; }
inline uint32 MatSet() const { return mActiveMatSet; }
inline bool IsWorldModel() const { return mWorldModel; }
inline u32 FindMeshID() const { return mpModel->GetSurface(0)->MeshID; }
inline uint32 FindMeshID() const { return mpModel->GetSurface(0)->MeshID; }
};
#endif // CMODELNODE_H

4
src/Core/Scene/CRootNode.h
View File

@@ -8,7 +8,7 @@
class CRootNode : public CSceneNode
{
public:
explicit CRootNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0)
explicit CRootNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0)
: CSceneNode(pScene, NodeID, pParent) {}
~CRootNode() {}
@@ -19,7 +19,7 @@ public:
inline void RayAABoxIntersectTest(CRayCollisionTester&, const SViewInfo&) {}
inline SRayIntersection RayNodeIntersectTest(const CRay &, u32, const SViewInfo&)
inline SRayIntersection RayNodeIntersectTest(const CRay &, uint32, const SViewInfo&)
{
return SRayIntersection();
}

62
src/Core/Scene/CScene.cpp
View File

@@ -7,7 +7,7 @@
#include <Common/FileIO/CFileInStream.h>
#include <Common/TString.h>
#include <Math/CRay.h>
#include <Common/Math/CRay.h>
#include <list>
#include <string>
@@ -29,22 +29,22 @@ CScene::~CScene()
delete mpSceneRootNode;
}
bool CScene::IsNodeIDUsed(u32 ID) const
bool CScene::IsNodeIDUsed(uint32 ID) const
{
return (mNodeMap.find(ID) != mNodeMap.end());
}
u32 CScene::CreateNodeID(u32 SuggestedID /*= -1*/) const
uint32 CScene::CreateNodeID(uint32 SuggestedID /*= -1*/) const
{
if (SuggestedID != -1)
{
if (IsNodeIDUsed(SuggestedID))
Log::Error("Suggested node ID is already being used! New ID will be created.");
errorf("Suggested node ID is already being used! New ID will be created.");
else
return SuggestedID;
}
u32 ID = 0;
uint32 ID = 0;
while (IsNodeIDUsed(ID))
ID++;
@@ -52,11 +52,11 @@ u32 CScene::CreateNodeID(u32 SuggestedID /*= -1*/) const
return ID;
}
CModelNode* CScene::CreateModelNode(CModel *pModel, u32 NodeID /*= -1*/)
CModelNode* CScene::CreateModelNode(CModel *pModel, uint32 NodeID /*= -1*/)
{
if (pModel == nullptr) return nullptr;
u32 ID = CreateNodeID(NodeID);
uint32 ID = CreateNodeID(NodeID);
CModelNode *pNode = new CModelNode(this, ID, mpAreaRootNode, pModel);
mNodes[eModelNode].push_back(pNode);
mNodeMap[ID] = pNode;
@@ -64,11 +64,11 @@ CModelNode* CScene::CreateModelNode(CModel *pModel, u32 NodeID /*= -1*/)
return pNode;
}
CStaticNode* CScene::CreateStaticNode(CStaticModel *pModel, u32 NodeID /*= -1*/)
CStaticNode* CScene::CreateStaticNode(CStaticModel *pModel, uint32 NodeID /*= -1*/)
{
if (pModel == nullptr) return nullptr;
u32 ID = CreateNodeID(NodeID);
uint32 ID = CreateNodeID(NodeID);
CStaticNode *pNode = new CStaticNode(this, ID, mpAreaRootNode, pModel);
mNodes[eStaticNode].push_back(pNode);
mNodeMap[ID] = pNode;
@@ -76,11 +76,11 @@ CStaticNode* CScene::CreateStaticNode(CStaticModel *pModel, u32 NodeID /*= -1*/)
return pNode;
}
CCollisionNode* CScene::CreateCollisionNode(CCollisionMeshGroup *pMesh, u32 NodeID /*= -1*/)
CCollisionNode* CScene::CreateCollisionNode(CCollisionMeshGroup *pMesh, uint32 NodeID /*= -1*/)
{
if (pMesh == nullptr) return nullptr;
u32 ID = CreateNodeID(NodeID);
uint32 ID = CreateNodeID(NodeID);
CCollisionNode *pNode = new CCollisionNode(this, ID, mpAreaRootNode, pMesh);
mNodes[eCollisionNode].push_back(pNode);
mNodeMap[ID] = pNode;
@@ -88,12 +88,12 @@ CCollisionNode* CScene::CreateCollisionNode(CCollisionMeshGroup *pMesh, u32 Node
return pNode;
}
CScriptNode* CScene::CreateScriptNode(CScriptObject *pObj, u32 NodeID /*= -1*/)
CScriptNode* CScene::CreateScriptNode(CScriptObject *pObj, uint32 NodeID /*= -1*/)
{
if (pObj == nullptr) return nullptr;
u32 ID = CreateNodeID(NodeID);
u32 InstanceID = pObj->InstanceID();
uint32 ID = CreateNodeID(NodeID);
uint32 InstanceID = pObj->InstanceID();
CScriptNode *pNode = new CScriptNode(this, ID, mpAreaRootNode, pObj);
mNodes[eScriptNode].push_back(pNode);
@@ -114,11 +114,11 @@ CScriptNode* CScene::CreateScriptNode(CScriptObject *pObj, u32 NodeID /*= -1*/)
return pNode;
}
CLightNode* CScene::CreateLightNode(CLight *pLight, u32 NodeID /*= -1*/)
CLightNode* CScene::CreateLightNode(CLight *pLight, uint32 NodeID /*= -1*/)
{
if (pLight == nullptr) return nullptr;
u32 ID = CreateNodeID(NodeID);
uint32 ID = CreateNodeID(NodeID);
CLightNode *pNode = new CLightNode(this, ID, mpAreaRootNode, pLight);
mNodes[eLightNode].push_back(pNode);
mNodeMap[ID] = pNode;
@@ -183,9 +183,9 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
mpAreaRootNode = new CRootNode(this, -1, mpSceneRootNode);
// Create static nodes
u32 Count = mpArea->NumStaticModels();
uint32 Count = mpArea->NumStaticModels();
for (u32 iMdl = 0; iMdl < Count; iMdl++)
for (uint32 iMdl = 0; iMdl < Count; iMdl++)
{
CStaticNode *pNode = CreateStaticNode(mpArea->StaticModel(iMdl));
pNode->SetName("Static World Model " + TString::FromInt32(iMdl, 0, 10));
@@ -194,7 +194,7 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
// Create model nodes
Count = mpArea->NumWorldModels();
for (u32 iMdl = 0; iMdl < Count; iMdl++)
for (uint32 iMdl = 0; iMdl < Count; iMdl++)
{
CModel *pModel = mpArea->TerrainModel(iMdl);
CModelNode *pNode = CreateModelNode(pModel);
@@ -204,15 +204,15 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
CreateCollisionNode(mpArea->Collision());
u32 NumLayers = mpArea->NumScriptLayers();
uint32 NumLayers = mpArea->NumScriptLayers();
for (u32 iLyr = 0; iLyr < NumLayers; iLyr++)
for (uint32 iLyr = 0; iLyr < NumLayers; iLyr++)
{
CScriptLayer *pLayer = mpArea->ScriptLayer(iLyr);
u32 NumObjects = pLayer->NumInstances();
uint32 NumObjects = pLayer->NumInstances();
mNodes[eScriptNode].reserve(mNodes[eScriptNode].size() + NumObjects);
for (u32 iObj = 0; iObj < NumObjects; iObj++)
for (uint32 iObj = 0; iObj < NumObjects; iObj++)
{
CScriptObject *pObj = pLayer->InstanceByIndex(iObj);
CreateScriptNode(pObj);
@@ -227,14 +227,14 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
pScript->BuildLightList(mpArea);
}
u32 NumLightLayers = mpArea->NumLightLayers();
uint32 NumLightLayers = mpArea->NumLightLayers();
CGraphics::sAreaAmbientColor = CColor::skBlack;
for (u32 iLyr = 0; iLyr < NumLightLayers; iLyr++)
for (uint32 iLyr = 0; iLyr < NumLightLayers; iLyr++)
{
u32 NumLights = mpArea->NumLights(iLyr);
uint32 NumLights = mpArea->NumLights(iLyr);
for (u32 iLit = 0; iLit < NumLights; iLit++)
for (uint32 iLit = 0; iLit < NumLights; iLit++)
{
CLight *pLight = mpArea->Light(iLyr, iLit);
@@ -246,7 +246,7 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
}
mRanPostLoad = false;
Log::Write( TString::FromInt32(CSceneNode::NumNodes(), 0, 10) + " nodes" );
debugf("%d nodes", CSceneNode::NumNodes());
}
void CScene::PostLoad()
@@ -306,7 +306,7 @@ SRayIntersection CScene::SceneRayCast(const CRay& rkRay, const SViewInfo& rkView
return Tester.TestNodes(rkViewInfo);
}
CSceneNode* CScene::NodeByID(u32 NodeID)
CSceneNode* CScene::NodeByID(uint32 NodeID)
{
auto it = mNodeMap.find(NodeID);
@@ -314,7 +314,7 @@ CSceneNode* CScene::NodeByID(u32 NodeID)
else return nullptr;
}
CScriptNode* CScene::NodeForInstanceID(u32 InstanceID)
CScriptNode* CScene::NodeForInstanceID(uint32 InstanceID)
{
auto it = mScriptMap.find(InstanceID);
@@ -345,7 +345,7 @@ CModel* CScene::ActiveSkybox()
{
bool SkyEnabled = false;
for (u32 iAtt = 0; iAtt < mAreaAttributesObjects.size(); iAtt++)
for (uint32 iAtt = 0; iAtt < mAreaAttributesObjects.size(); iAtt++)
{
const CAreaAttributes& rkAttributes = mAreaAttributesObjects[iAtt];
if (rkAttributes.IsSkyEnabled()) SkyEnabled = true;

26
src/Core/Scene/CScene.h
View File

@@ -15,7 +15,7 @@
#include "Core/Resource/CWorld.h"
#include "Core/CAreaAttributes.h"
#include "Core/SRayIntersection.h"
#include <Common/types.h>
#include <Common/BasicTypes.h>
#include <unordered_map>
#include <vector>
@@ -27,7 +27,7 @@ class CScene
bool mSplitTerrain;
bool mRanPostLoad;
u32 mNumNodes;
uint32 mNumNodes;
CRootNode *mpSceneRootNode;
std::unordered_map<ENodeType, std::vector<CSceneNode*>> mNodes;
@@ -39,30 +39,30 @@ class CScene
std::vector<CAreaAttributes> mAreaAttributesObjects;
// Node Management
std::unordered_map<u32, CSceneNode*> mNodeMap;
std::unordered_map<u32, CScriptNode*> mScriptMap;
std::unordered_map<uint32, CSceneNode*> mNodeMap;
std::unordered_map<uint32, CScriptNode*> mScriptMap;
public:
CScene();
~CScene();
// Scene Management
bool IsNodeIDUsed(u32 ID) const;
u32 CreateNodeID(u32 SuggestedID = -1) const;
bool IsNodeIDUsed(uint32 ID) const;
uint32 CreateNodeID(uint32 SuggestedID = -1) const;
CModelNode* CreateModelNode(CModel *pModel, u32 NodeID = -1);
CStaticNode* CreateStaticNode(CStaticModel *pModel, u32 NodeID = -1);
CCollisionNode* CreateCollisionNode(CCollisionMeshGroup *pMesh, u32 NodeID = -1);
CScriptNode* CreateScriptNode(CScriptObject *pObj, u32 NodeID = -1);
CLightNode* CreateLightNode(CLight *pLight, u32 NodeID = -1);
CModelNode* CreateModelNode(CModel *pModel, uint32 NodeID = -1);
CStaticNode* CreateStaticNode(CStaticModel *pModel, uint32 NodeID = -1);
CCollisionNode* CreateCollisionNode(CCollisionMeshGroup *pMesh, uint32 NodeID = -1);
CScriptNode* CreateScriptNode(CScriptObject *pObj, uint32 NodeID = -1);
CLightNode* CreateLightNode(CLight *pLight, uint32 NodeID = -1);
void DeleteNode(CSceneNode *pNode);
void SetActiveArea(CWorld *pWorld, CGameArea *pArea);
void PostLoad();
void ClearScene();
void AddSceneToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo);
SRayIntersection SceneRayCast(const CRay& rkRay, const SViewInfo& rkViewInfo);
CSceneNode* NodeByID(u32 NodeID);
CScriptNode* NodeForInstanceID(u32 InstanceID);
CSceneNode* NodeByID(uint32 NodeID);
CScriptNode* NodeForInstanceID(uint32 InstanceID);
CScriptNode* NodeForInstance(CScriptObject *pObj);
CLightNode* NodeForLight(CLight *pLight);
CModel* ActiveSkybox();

24
src/Core/Scene/CSceneNode.cpp
View File

@@ -4,15 +4,15 @@
#include "Core/Render/CGraphics.h"
#include "Core/Render/CDrawUtil.h"
#include "Core/Resource/Area/CGameArea.h"
#include <Common/AssertMacro.h>
#include <Math/CTransform4f.h>
#include <Common/Macros.h>
#include <Common/Math/CTransform4f.h>
#include <algorithm>
u32 CSceneNode::smNumNodes = 0;
uint32 CSceneNode::smNumNodes = 0;
CColor CSceneNode::skSelectionTint = CColor::Integral(39, 154, 167);
CSceneNode::CSceneNode(CScene *pScene, u32 NodeID, CSceneNode *pParent)
CSceneNode::CSceneNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent)
: mpScene(pScene)
, mpParent(pParent)
, _mID(NodeID)
@@ -134,7 +134,7 @@ void CSceneNode::BuildLightList(CGameArea *pArea)
mLightCount = 0;
mAmbientColor = CColor::skBlack;
u32 Index = mLightLayerIndex;
uint32 Index = mLightLayerIndex;
if ((pArea->NumLightLayers() <= Index) || (pArea->NumLights(Index) == 0)) Index = 0;
struct SLightEntry {
@@ -151,10 +151,10 @@ void CSceneNode::BuildLightList(CGameArea *pArea)
std::vector<SLightEntry> LightEntries;
// Default ambient color to white if there are no lights on the selected layer
u32 NumLights = pArea->NumLights(Index);
uint32 NumLights = pArea->NumLights(Index);
if (NumLights == 0) mAmbientColor = CColor::skWhite;
for (u32 iLight = 0; iLight < NumLights; iLight++)
for (uint32 iLight = 0; iLight < NumLights; iLight++)
{
CLight* pLight = pArea->Light(Index, iLight);
@@ -179,7 +179,7 @@ void CSceneNode::BuildLightList(CGameArea *pArea)
std::sort(LightEntries.begin(), LightEntries.end());
mLightCount = (LightEntries.size() > 8) ? 8 : LightEntries.size();
for (u32 iLight = 0; iLight < mLightCount; iLight++)
for (uint32 iLight = 0; iLight < mLightCount; iLight++)
mLights[iLight] = LightEntries[iLight].pLight;
}
@@ -205,7 +205,7 @@ void CSceneNode::LoadLights(const SViewInfo& rkViewInfo)
// World lighting: world ambient color, node dynamic lights
CGraphics::sVertexBlock.COLOR0_Amb = mAmbientColor;
for (u32 iLight = 0; iLight < mLightCount; iLight++)
for (uint32 iLight = 0; iLight < mLightCount; iLight++)
mLights[iLight]->Load();
break;
}
@@ -214,7 +214,7 @@ void CSceneNode::LoadLights(const SViewInfo& rkViewInfo)
CGraphics::UpdateLightBlock();
}
void CSceneNode::AddModelToRenderer(CRenderer *pRenderer, CModel *pModel, u32 MatSet)
void CSceneNode::AddModelToRenderer(CRenderer *pRenderer, CModel *pModel, uint32 MatSet)
{
ASSERT(pModel);
@@ -228,7 +228,7 @@ void CSceneNode::AddModelToRenderer(CRenderer *pRenderer, CModel *pModel, u32 Ma
}
}
void CSceneNode::DrawModelParts(CModel *pModel, FRenderOptions Options, u32 MatSet, ERenderCommand RenderCommand)
void CSceneNode::DrawModelParts(CModel *pModel, FRenderOptions Options, uint32 MatSet, ERenderCommand RenderCommand)
{
// Common rendering functionality
if (RenderCommand == eDrawMesh)
@@ -239,7 +239,7 @@ void CSceneNode::DrawModelParts(CModel *pModel, FRenderOptions Options, u32 MatS
bool DrawOpaque = (RenderCommand == eDrawMesh || RenderCommand == eDrawOpaqueParts);
bool DrawTransparent = (RenderCommand == eDrawMesh || RenderCommand == eDrawTransparentParts);
for (u32 iSurf = 0; iSurf < pModel->GetSurfaceCount(); iSurf++)
for (uint32 iSurf = 0; iSurf < pModel->GetSurfaceCount(); iSurf++)
{
bool ShouldRender = ( (DrawOpaque && DrawTransparent) ||
(DrawOpaque && !pModel->IsSurfaceTransparent(iSurf, MatSet)) ||

36
src/Core/Scene/CSceneNode.h
View File

@@ -8,13 +8,13 @@
#include "Core/Resource/Area/CGameArea.h"
#include "Core/Resource/CLight.h"
#include "Core/CRayCollisionTester.h"
#include <Common/types.h>
#include <Math/CAABox.h>
#include <Math/CQuaternion.h>
#include <Math/CRay.h>
#include <Math/CTransform4f.h>
#include <Math/CVector3f.h>
#include <Math/ETransformSpace.h>
#include <Common/BasicTypes.h>
#include <Common/Math/CAABox.h>
#include <Common/Math/CQuaternion.h>
#include <Common/Math/CRay.h>
#include <Common/Math/CTransform4f.h>
#include <Common/Math/CVector3f.h>
#include <Common/Math/ETransformSpace.h>
class CRenderer;
class CScene;
@@ -30,10 +30,10 @@ private:
bool _mInheritsRotation;
bool _mInheritsScale;
u32 _mID;
uint32 _mID;
protected:
static u32 smNumNodes;
static uint32 smNumNodes;
TString mName;
CSceneNode *mpParent;
CScene *mpScene;
@@ -48,13 +48,13 @@ protected:
bool mVisible;
std::list<CSceneNode*> mChildren;
u32 mLightLayerIndex;
u32 mLightCount;
uint32 mLightLayerIndex;
uint32 mLightCount;
CLight* mLights[8];
CColor mAmbientColor;
public:
explicit CSceneNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0);
explicit CSceneNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0);
virtual ~CSceneNode();
virtual ENodeType NodeType() = 0;
virtual void PostLoad() {}
@@ -62,7 +62,7 @@ public:
virtual void AddToRenderer(CRenderer* /*pRenderer*/, const SViewInfo& /*rkViewInfo*/) {}
virtual void DrawSelection();
virtual void RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& rkViewInfo);
virtual SRayIntersection RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo) = 0;
virtual SRayIntersection RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo) = 0;
virtual bool AllowsTranslate() const { return true; }
virtual bool AllowsRotate() const { return true; }
virtual bool AllowsScale() const { return true; }
@@ -80,8 +80,8 @@ public:
void LoadModelMatrix();
void BuildLightList(CGameArea *pArea);
void LoadLights(const SViewInfo& rkViewInfo);
void AddModelToRenderer(CRenderer *pRenderer, CModel *pModel, u32 MatSet);
void DrawModelParts(CModel *pModel, FRenderOptions Options, u32 MatSet, ERenderCommand RenderCommand);
void AddModelToRenderer(CRenderer *pRenderer, CModel *pModel, uint32 MatSet);
void DrawModelParts(CModel *pModel, FRenderOptions Options, uint32 MatSet, ERenderCommand RenderCommand);
void DrawBoundingBox() const;
void DrawRotationArrow() const;
@@ -107,12 +107,12 @@ public:
TString Name() const { return mName; }
CSceneNode* Parent() const { return mpParent; }
CScene* Scene() const { return mpScene; }
u32 ID() const { return _mID; }
uint32 ID() const { return _mID; }
CVector3f LocalPosition() const { return mPosition; }
CQuaternion LocalRotation() const { return mRotation; }
CVector3f LocalScale() const { return mScale; }
CVector3f CenterPoint() const { return AABox().Center(); }
u32 LightLayerIndex() const { return mLightLayerIndex; }
uint32 LightLayerIndex() const { return mLightLayerIndex; }
bool MarkedVisible() const { return mVisible; }
bool IsMouseHovering() const { return mMouseHovering; }
bool IsSelected() const { return mSelected; }
@@ -126,7 +126,7 @@ public:
void SetRotation(const CQuaternion& rkRotation) { mRotation = rkRotation; MarkTransformChanged(); }
void SetRotation(const CVector3f& rkRotEuler) { mRotation = CQuaternion::FromEuler(rkRotEuler); MarkTransformChanged(); }
void SetScale(const CVector3f& rkScale) { mScale = rkScale; MarkTransformChanged(); }
void SetLightLayerIndex(u32 Index) { mLightLayerIndex = Index; }
void SetLightLayerIndex(uint32 Index) { mLightLayerIndex = Index; }
void SetMouseHovering(bool Hovering) { mMouseHovering = Hovering; }
void SetSelected(bool Selected) { mSelected = Selected; }
void SetVisible(bool Visible) { mVisible = Visible; }

4
src/Core/Scene/CScriptAttachNode.cpp
View File

@@ -2,7 +2,7 @@
#include "CScriptNode.h"
#include "Core/Render/CRenderer.h"
#include "Core/Resource/Script/Property/IProperty.h"
#include <Common/AssertMacro.h>
#include <Common/Macros.h>
CScriptAttachNode::CScriptAttachNode(CScene *pScene, const SAttachment& rkAttachment, CScriptNode *pParent)
: CSceneNode(pScene, -1, pParent)
@@ -117,7 +117,7 @@ void CScriptAttachNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, cons
rTester.AddNodeModel(this, pModel);
}
SRayIntersection CScriptAttachNode::RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo)
SRayIntersection CScriptAttachNode::RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo)
{
FRenderOptions Options = rkViewInfo.pRenderer->RenderOptions();

2
src/Core/Scene/CScriptAttachNode.h
View File

@@ -31,7 +31,7 @@ public:
void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
void DrawSelection();
void RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo);
inline IProperty* AttachProperty() const { return mpAttachAssetProp; }
inline TString LocatorName() const { return mLocatorName; }

32
src/Core/Scene/CScriptNode.cpp
View File

@@ -8,10 +8,10 @@
#include "Core/Resource/Script/CGameTemplate.h"
#include "Core/Resource/Script/CScriptLayer.h"
#include "Core/ScriptExtra/CScriptExtra.h"
#include <Common/AssertMacro.h>
#include <Math/MathUtil.h>
#include <Common/Macros.h>
#include <Common/Math/MathUtil.h>
CScriptNode::CScriptNode(CScene *pScene, u32 NodeID, CSceneNode *pParent, CScriptObject *pInstance)
CScriptNode::CScriptNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CScriptObject *pInstance)
: CSceneNode(pScene, NodeID, pParent)
, mGameModeVisibility(eUntested)
, mpVolumePreviewNode(nullptr)
@@ -58,7 +58,7 @@ CScriptNode::CScriptNode(CScene *pScene, u32 NodeID, CSceneNode *pParent, CScrip
}
// Create attachment nodes
for (u32 iAttach = 0; iAttach < pTemp->NumAttachments(); iAttach++)
for (uint32 iAttach = 0; iAttach < pTemp->NumAttachments(); iAttach++)
{
const SAttachment& rkAttach = pTemp->Attachment(iAttach);
CScriptAttachNode *pAttach = new CScriptAttachNode(pScene, rkAttach, this);
@@ -141,7 +141,7 @@ void CScriptNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
if (rkViewInfo.ShowFlags & eShowObjectGeometry || rkViewInfo.GameMode)
{
for (u32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
for (uint32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
mAttachments[iAttach]->AddToRenderer(pRenderer, rkViewInfo);
if (rkViewInfo.ViewFrustum.BoxInFrustum(AABox()))
@@ -267,7 +267,7 @@ void CScriptNode::DrawSelection()
CGraphics::sMVPBlock.ModelMatrix = CMatrix4f::skIdentity;
CGraphics::UpdateMVPBlock();
for (u32 iIn = 0; iIn < mpInstance->NumLinks(eIncoming); iIn++)
for (uint32 iIn = 0; iIn < mpInstance->NumLinks(eIncoming); iIn++)
{
// Don't draw in links if the other object is selected.
CLink *pLink = mpInstance->Link(eIncoming, iIn);
@@ -275,7 +275,7 @@ void CScriptNode::DrawSelection()
if (pLinkNode && !pLinkNode->IsSelected()) CDrawUtil::DrawLine(CenterPoint(), pLinkNode->CenterPoint(), CColor::skTransparentRed);
}
for (u32 iOut = 0; iOut < mpInstance->NumLinks(eOutgoing); iOut++)
for (uint32 iOut = 0; iOut < mpInstance->NumLinks(eOutgoing); iOut++)
{
CLink *pLink = mpInstance->Link(eOutgoing, iOut);
CScriptNode *pLinkNode = mpScene->NodeForInstanceID(pLink->ReceiverID());
@@ -340,11 +340,11 @@ void CScriptNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SVie
// Run ray check on child nodes as well
mpCollisionNode->RayAABoxIntersectTest(rTester, rkViewInfo);
for (u32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
for (uint32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
mAttachments[iAttach]->RayAABoxIntersectTest(rTester, rkViewInfo);
}
SRayIntersection CScriptNode::RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo)
SRayIntersection CScriptNode::RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo)
{
FRenderOptions Options = rkViewInfo.pRenderer->RenderOptions();
@@ -514,7 +514,7 @@ void CScriptNode::PropertyModified(IProperty* pProp)
SetLightLayerIndex(mpLightParameters->LightLayerIndex());
// Notify attachments
for (u32 AttachIdx = 0; AttachIdx < mAttachments.size(); AttachIdx++)
for (uint32 AttachIdx = 0; AttachIdx < mAttachments.size(); AttachIdx++)
{
CScriptAttachNode* pAttachNode = mAttachments[AttachIdx];
@@ -572,12 +572,12 @@ void CScriptNode::GeneratePosition()
// Ideal way to generate the position is to find a spot close to where it's being used.
// To do this I check the location of the objects that this one is linked to.
u32 NumLinks = mpInstance->NumLinks(eIncoming) + mpInstance->NumLinks(eOutgoing);
uint32 NumLinks = mpInstance->NumLinks(eIncoming) + mpInstance->NumLinks(eOutgoing);
// In the case of one link, apply an offset so the new position isn't the same place as the object it's linked to
if (NumLinks == 1)
{
u32 LinkedID = (mpInstance->NumLinks(eIncoming) > 0 ? mpInstance->Link(eIncoming, 0)->SenderID() : mpInstance->Link(eOutgoing, 0)->ReceiverID());
uint32 LinkedID = (mpInstance->NumLinks(eIncoming) > 0 ? mpInstance->Link(eIncoming, 0)->SenderID() : mpInstance->Link(eOutgoing, 0)->ReceiverID());
CScriptNode *pNode = mpScene->NodeForInstanceID(LinkedID);
pNode->GeneratePosition();
mPosition = pNode->AbsolutePosition();
@@ -591,7 +591,7 @@ void CScriptNode::GeneratePosition()
{
CVector3f NewPos = CVector3f::skZero;
for (u32 iIn = 0; iIn < mpInstance->NumLinks(eIncoming); iIn++)
for (uint32 iIn = 0; iIn < mpInstance->NumLinks(eIncoming); iIn++)
{
CScriptNode *pNode = mpScene->NodeForInstanceID(mpInstance->Link(eIncoming, iIn)->SenderID());
@@ -602,7 +602,7 @@ void CScriptNode::GeneratePosition()
}
}
for (u32 iOut = 0; iOut < mpInstance->NumLinks(eOutgoing); iOut++)
for (uint32 iOut = 0; iOut < mpInstance->NumLinks(eOutgoing); iOut++)
{
CScriptNode *pNode = mpScene->NodeForInstanceID(mpInstance->Link(eOutgoing, iOut)->ReceiverID());
@@ -718,7 +718,7 @@ CVector2f CScriptNode::BillboardScale() const
return Out * 0.5f * Template()->PreviewScale();
}
CTransform4f CScriptNode::BoneTransform(u32 BoneID, EAttachType AttachType, bool Absolute) const
CTransform4f CScriptNode::BoneTransform(uint32 BoneID, EAttachType AttachType, bool Absolute) const
{
CTransform4f Out;
CSkeleton *pSkel = ActiveSkeleton();
@@ -750,7 +750,7 @@ void CScriptNode::SetDisplayAsset(CResource *pRes)
mLocalAABox = (pModel ? pModel->AABox() : CAABox::skOne);
MarkTransformChanged();
for (u32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
for (uint32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
mAttachments[iAttach]->ParentDisplayAssetChanged(pRes);
if (mpExtra)

16
src/Core/Scene/CScriptNode.h
View File

@@ -16,8 +16,8 @@ class CScriptNode : public CSceneNode
CScriptExtra *mpExtra;
TResPtr<CResource> mpDisplayAsset;
u32 mCharIndex;
u32 mAnimIndex;
uint32 mCharIndex;
uint32 mAnimIndex;
CCollisionNode *mpCollisionNode;
std::vector<CScriptAttachNode*> mAttachments;
@@ -33,7 +33,7 @@ class CScriptNode : public CSceneNode
} mGameModeVisibility;
public:
CScriptNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0, CScriptObject *pObject = 0);
CScriptNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0, CScriptObject *pObject = 0);
ENodeType NodeType();
void PostLoad();
void OnTransformed();
@@ -41,7 +41,7 @@ public:
void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
void DrawSelection();
void RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo);
bool AllowsRotate() const;
bool AllowsScale() const;
bool IsVisible() const;
@@ -60,7 +60,7 @@ public:
bool HasPreviewVolume() const;
CAABox PreviewVolumeAABox() const;
CVector2f BillboardScale() const;
CTransform4f BoneTransform(u32 BoneID, EAttachType AttachType, bool Absolute) const;
CTransform4f BoneTransform(uint32 BoneID, EAttachType AttachType, bool Absolute) const;
CModel* ActiveModel() const;
CAnimSet* ActiveAnimSet() const;
@@ -69,9 +69,9 @@ public:
CTexture* ActiveBillboard() const;
bool UsesModel() const;
inline u32 NumAttachments() const { return mAttachments.size(); }
inline CScriptAttachNode* Attachment(u32 Index) const { return mAttachments[Index]; }
inline CResource* DisplayAsset() const { return mpDisplayAsset; }
inline uint32 NumAttachments() const { return mAttachments.size(); }
inline CScriptAttachNode* Attachment(uint32 Index) const { return mAttachments[Index]; }
inline CResource* DisplayAsset() const { return mpDisplayAsset; }
protected:
void SetDisplayAsset(CResource *pRes);

12
src/Core/Scene/CStaticNode.cpp
View File

@@ -2,9 +2,9 @@
#include "Core/Render/CGraphics.h"
#include "Core/Render/CDrawUtil.h"
#include "Core/Render/CRenderer.h"
#include <Math/MathUtil.h>
#include <Common/Math/MathUtil.h>
CStaticNode::CStaticNode(CScene *pScene, u32 NodeID, CSceneNode *pParent, CStaticModel *pModel)
CStaticNode::CStaticNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CStaticModel *pModel)
: CSceneNode(pScene, NodeID, pParent)
, mpModel(pModel)
{
@@ -38,8 +38,8 @@ void CStaticNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
else
{
u32 NumSurfaces = mpModel->GetSurfaceCount();
for (u32 iSurf = 0; iSurf < NumSurfaces; iSurf++)
uint32 NumSurfaces = mpModel->GetSurfaceCount();
for (uint32 iSurf = 0; iSurf < NumSurfaces; iSurf++)
{
CAABox TransformedBox = mpModel->GetSurfaceAABox(iSurf).Transformed(Transform());
@@ -102,7 +102,7 @@ void CStaticNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SVie
if (BoxResult.first)
{
for (u32 iSurf = 0; iSurf < mpModel->GetSurfaceCount(); iSurf++)
for (uint32 iSurf = 0; iSurf < mpModel->GetSurfaceCount(); iSurf++)
{
std::pair<bool,float> SurfResult = mpModel->GetSurfaceAABox(iSurf).Transformed(Transform()).IntersectsRay(rkRay);
@@ -112,7 +112,7 @@ void CStaticNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SVie
}
}
SRayIntersection CStaticNode::RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo)
SRayIntersection CStaticNode::RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo)
{
SRayIntersection Out;
Out.pNode = this;

4
src/Core/Scene/CStaticNode.h
View File

@@ -9,14 +9,14 @@ class CStaticNode : public CSceneNode
CStaticModel *mpModel;
public:
CStaticNode(CScene *pScene, u32 NodeID, CSceneNode *pParent = 0, CStaticModel *pModel = 0);
CStaticNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent = 0, CStaticModel *pModel = 0);
ENodeType NodeType();
void PostLoad();
void AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo);
void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
void DrawSelection();
void RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, u32 AssetID, const SViewInfo& rkViewInfo);
SRayIntersection RayNodeIntersectTest(const CRay& rkRay, uint32 AssetID, const SViewInfo& rkViewInfo);
};
#endif // CSTATICNODE_H