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

Cleanup & refactoring

Browse Source
This commit is contained in:
Aruki
2018-12-16 14:00:40 -07:00
parent 2287b05bc3
commit c4829f5fda
197 changed files with 2461 additions and 2345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -12,7 +12,7 @@ CCharacterNode::CCharacterNode(CScene *pScene, uint32 NodeID, CAnimSet *pChar /*
ENodeType CCharacterNode::NodeType()
{
return eCharacterNode;
return ENodeType::Character;
}
void CCharacterNode::PostLoad()
@@ -34,13 +34,13 @@ void CCharacterNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkView
CModel *pModel = mpCharacter->Character(mActiveCharSet)->pModel;
CSkeleton *pSkel = mpCharacter->Character(mActiveCharSet)->pSkeleton;
if (pModel && rkViewInfo.ShowFlags.HasFlag(eShowObjectGeometry))
if (pModel && rkViewInfo.ShowFlags.HasFlag(EShowFlag::ObjectGeometry))
AddModelToRenderer(pRenderer, pModel, 0);
if (pSkel)
{
if (rkViewInfo.ShowFlags.HasFlag(eShowSkeletons))
pRenderer->AddMesh(this, 0, AABox(), false, eDrawMesh, eForeground);
if (rkViewInfo.ShowFlags.HasFlag(EShowFlag::Skeletons))
pRenderer->AddMesh(this, 0, AABox(), false, ERenderCommand::DrawMesh, EDepthGroup::Foreground);
}
}
@@ -81,7 +81,7 @@ void CCharacterNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCom
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))
if (mpCharacter && rkViewInfo.ShowFlags.HasFlag(EShowFlag::Skeletons))
{
CSkeleton *pSkel = mpCharacter->Character(mActiveCharSet)->pSkeleton;

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

@@ -13,7 +13,7 @@ CCollisionNode::CCollisionNode(CScene *pScene, uint32 NodeID, CSceneNode *pParen
ENodeType CCollisionNode::NodeType()
{
return eCollisionNode;
return ENodeType::Collision;
}
void CCollisionNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo)
@@ -22,10 +22,10 @@ void CCollisionNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkView
if (!rkViewInfo.ViewFrustum.BoxInFrustum(AABox())) return;
if (rkViewInfo.GameMode) return;
pRenderer->AddMesh(this, -1, AABox(), false, eDrawMesh);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawMesh);
if (mSelected)
pRenderer->AddMesh(this, -1, AABox(), false, eDrawSelection);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawSelection);
}
void CCollisionNode::Draw(FRenderOptions /*Options*/, int /*ComponentIndex*/, ERenderCommand /*Command*/, const SViewInfo& rkViewInfo)
@@ -86,7 +86,7 @@ void CCollisionNode::Draw(FRenderOptions /*Options*/, int /*ComponentIndex*/, ER
// Draw collision bounds for area collision
// note: right now checking parent is the best way to check whether this node is area collision instead of actor collision
// actor collision will have a script node parent whereas area collision will have a root node parent
if (rkViewInfo.CollisionSettings.DrawAreaCollisionBounds && Parent()->NodeType() == eRootNode && Game != EGame::DKCReturns)
if (rkViewInfo.CollisionSettings.DrawAreaCollisionBounds && Parent()->NodeType() == ENodeType::Root && Game != EGame::DKCReturns)
CDrawUtil::DrawWireCube( mpCollision->MeshByIndex(0)->BoundingBox(), CColor::skRed );
}

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

@@ -13,16 +13,16 @@ CLightNode::CLightNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CLigh
switch (pLight->Type())
{
case eLocalAmbient: SetName("Ambient Light"); break;
case eDirectional: SetName("Directional Light"); break;
case eSpot: SetName("Spot Light"); break;
case eCustom: SetName("Custom Light"); break;
case ELightType::LocalAmbient: SetName("Ambient Light"); break;
case ELightType::Directional: SetName("Directional Light"); break;
case ELightType::Spot: SetName("Spot Light"); break;
case ELightType::Custom: SetName("Custom Light"); break;
}
}
ENodeType CLightNode::NodeType()
{
return eLightNode;
return ENodeType::Light;
}
void CLightNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo)
@@ -30,14 +30,14 @@ void CLightNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo
if (rkViewInfo.GameMode) return;
if (rkViewInfo.ViewFrustum.BoxInFrustum(AABox()))
pRenderer->AddMesh(this, -1, AABox(), false, eDrawMesh);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawMesh);
if (IsSelected() && mpLight->Type() == eCustom)
if (IsSelected() && mpLight->Type() == ELightType::Custom)
{
CAABox RadiusBox = (CAABox::skOne * 2.f * mpLight->GetRadius()) + mPosition;
if (rkViewInfo.ViewFrustum.BoxInFrustum(RadiusBox))
pRenderer->AddMesh(this, -1, AABox(), false, eDrawSelection);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawSelection);
}
}

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

@@ -17,7 +17,7 @@ CModelNode::CModelNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CMode
ENodeType CModelNode::NodeType()
{
return eModelNode;
return ENodeType::Model;
}
void CModelNode::PostLoad()
@@ -38,12 +38,12 @@ void CModelNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo
// Transparent world models should have each surface processed separately
if (mWorldModel && mpModel->HasTransparency(mActiveMatSet))
{
pRenderer->AddMesh(this, -1, AABox(), false, eDrawOpaqueParts);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawOpaqueParts);
for (uint32 iSurf = 0; iSurf < mpModel->GetSurfaceCount(); iSurf++)
{
if (mpModel->IsSurfaceTransparent(iSurf, mActiveMatSet))
pRenderer->AddMesh(this, iSurf, mpModel->GetSurfaceAABox(iSurf).Transformed(Transform()), true, eDrawTransparentParts);
pRenderer->AddMesh(this, iSurf, mpModel->GetSurfaceAABox(iSurf).Transformed(Transform()), true, ERenderCommand::DrawTransparentParts);
}
}
@@ -52,13 +52,13 @@ void CModelNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo
AddModelToRenderer(pRenderer, mpModel, mActiveMatSet);
if (mSelected)
pRenderer->AddMesh(this, -1, AABox(), false, eDrawSelection);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawSelection);
}
void CModelNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo)
{
if (!mpModel) return;
if (mForceAlphaOn) Options = (FRenderOptions) (Options & ~eNoAlpha);
if (mForceAlphaOn) Options = (FRenderOptions) (Options & ~ERenderOption::NoAlpha);
if (!mWorldModel)
{
@@ -70,7 +70,7 @@ void CModelNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand
}
else
{
bool IsLightingEnabled = CGraphics::sLightMode == CGraphics::eWorldLighting || rkViewInfo.GameMode;
bool IsLightingEnabled = CGraphics::sLightMode == CGraphics::ELightingMode::World || rkViewInfo.GameMode;
if (IsLightingEnabled)
{
@@ -83,7 +83,7 @@ void CModelNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand
else
{
LoadLights(rkViewInfo);
if (CGraphics::sLightMode == CGraphics::eNoLighting)
if (CGraphics::sLightMode == CGraphics::ELightingMode::None)
CGraphics::sVertexBlock.COLOR0_Amb = CColor::skWhite;
}
@@ -106,7 +106,7 @@ void CModelNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand
{
CDrawUtil::UseColorShader(mScanOverlayColor);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ZERO);
Options |= eNoMaterialSetup;
Options |= ERenderOption::NoMaterialSetup;
DrawModelParts(mpModel, Options, 0, Command);
}
}
@@ -115,7 +115,7 @@ void CModelNode::DrawSelection()
{
if (!mpModel) return;
LoadModelMatrix();
mpModel->DrawWireframe(eNoRenderOptions, WireframeColor());
mpModel->DrawWireframe(ERenderOption::None, WireframeColor());
}
void CModelNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& /*rkViewInfo*/)
@@ -137,7 +137,7 @@ SRayIntersection CModelNode::RayNodeIntersectTest(const CRay& rkRay, uint32 Asse
CRay TransformedRay = rkRay.Transformed(Transform().Inverse());
FRenderOptions Options = rkViewInfo.pRenderer->RenderOptions();
std::pair<bool,float> Result = mpModel->GetSurface(AssetID)->IntersectsRay(TransformedRay, ((Options & eEnableBackfaceCull) == 0));
std::pair<bool,float> Result = mpModel->GetSurface(AssetID)->IntersectsRay(TransformedRay, ((Options & ERenderOption::EnableBackfaceCull) == 0));
if (Result.first)
{

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

@@ -14,7 +14,7 @@ public:
ENodeType NodeType()
{
return eRootNode;
return ENodeType::Root;
}
inline void RayAABoxIntersectTest(CRayCollisionTester&, const SViewInfo&) {}

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

@@ -58,7 +58,7 @@ CModelNode* CScene::CreateModelNode(CModel *pModel, uint32 NodeID /*= -1*/)
uint32 ID = CreateNodeID(NodeID);
CModelNode *pNode = new CModelNode(this, ID, mpAreaRootNode, pModel);
mNodes[eModelNode].push_back(pNode);
mNodes[ENodeType::Model].push_back(pNode);
mNodeMap[ID] = pNode;
mNumNodes++;
return pNode;
@@ -70,7 +70,7 @@ CStaticNode* CScene::CreateStaticNode(CStaticModel *pModel, uint32 NodeID /*= -1
uint32 ID = CreateNodeID(NodeID);
CStaticNode *pNode = new CStaticNode(this, ID, mpAreaRootNode, pModel);
mNodes[eStaticNode].push_back(pNode);
mNodes[ENodeType::Static].push_back(pNode);
mNodeMap[ID] = pNode;
mNumNodes++;
return pNode;
@@ -82,7 +82,7 @@ CCollisionNode* CScene::CreateCollisionNode(CCollisionMeshGroup *pMesh, uint32 N
uint32 ID = CreateNodeID(NodeID);
CCollisionNode *pNode = new CCollisionNode(this, ID, mpAreaRootNode, pMesh);
mNodes[eCollisionNode].push_back(pNode);
mNodes[ENodeType::Collision].push_back(pNode);
mNodeMap[ID] = pNode;
mNumNodes++;
return pNode;
@@ -96,7 +96,7 @@ CScriptNode* CScene::CreateScriptNode(CScriptObject *pObj, uint32 NodeID /*= -1*
uint32 InstanceID = pObj->InstanceID();
CScriptNode *pNode = new CScriptNode(this, ID, mpAreaRootNode, pObj);
mNodes[eScriptNode].push_back(pNode);
mNodes[ENodeType::Script].push_back(pNode);
mNodeMap[ID] = pNode;
mScriptMap[InstanceID] = pNode;
pNode->BuildLightList(mpArea);
@@ -104,8 +104,8 @@ CScriptNode* CScene::CreateScriptNode(CScriptObject *pObj, uint32 NodeID /*= -1*
// AreaAttributes check
switch (pObj->ObjectTypeID())
{
case 0x4E: // MP1 AreaAttributes ID
case 0x52454141: // MP2/MP3/DKCR AreaAttributes ID ("REAA")
case 0x4E: // MP1 AreaAttributes ID
case FOURCC('REAA'): // MP2/MP3/DKCR AreaAttributes ID
mAreaAttributesObjects.emplace_back( CAreaAttributes(pObj) );
break;
}
@@ -120,7 +120,7 @@ CLightNode* CScene::CreateLightNode(CLight *pLight, uint32 NodeID /*= -1*/)
uint32 ID = CreateNodeID(NodeID);
CLightNode *pNode = new CLightNode(this, ID, mpAreaRootNode, pLight);
mNodes[eLightNode].push_back(pNode);
mNodes[ENodeType::Light].push_back(pNode);
mNodeMap[ID] = pNode;
mNumNodes++;
return pNode;
@@ -143,7 +143,7 @@ void CScene::DeleteNode(CSceneNode *pNode)
if (MapIt != mNodeMap.end())
mNodeMap.erase(MapIt);
if (Type == eScriptNode)
if (Type == ENodeType::Script)
{
CScriptNode *pScript = static_cast<CScriptNode*>(pNode);
@@ -154,7 +154,7 @@ void CScene::DeleteNode(CSceneNode *pNode)
switch (pScript->Instance()->ObjectTypeID())
{
case 0x4E:
case 0x52454141:
case FOURCC('REAA'):
for (auto it = mAreaAttributesObjects.begin(); it != mAreaAttributesObjects.end(); it++)
{
if ((*it).Instance() == pScript->Instance())
@@ -210,7 +210,7 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
{
CScriptLayer *pLayer = mpArea->ScriptLayer(iLyr);
uint32 NumObjects = pLayer->NumInstances();
mNodes[eScriptNode].reserve(mNodes[eScriptNode].size() + NumObjects);
mNodes[ENodeType::Script].reserve(mNodes[ENodeType::Script].size() + NumObjects);
for (uint32 iObj = 0; iObj < NumObjects; iObj++)
{
@@ -220,7 +220,7 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
}
// Ensure script nodes have valid positions + build light lists
for (CSceneIterator It(this, eScriptNode, true); It; ++It)
for (CSceneIterator It(this, ENodeType::Script, true); It; ++It)
{
CScriptNode *pScript = static_cast<CScriptNode*>(*It);
pScript->GeneratePosition();
@@ -238,7 +238,7 @@ void CScene::SetActiveArea(CWorld *pWorld, CGameArea *pArea)
{
CLight *pLight = mpArea->Light(iLyr, iLit);
if (pLight->Type() == eLocalAmbient)
if (pLight->Type() == ELightType::LocalAmbient)
CGraphics::sAreaAmbientColor += pLight->Color();
CreateLightNode(pLight);
@@ -330,7 +330,7 @@ CScriptNode* CScene::NodeForInstance(CScriptObject *pObj)
CLightNode* CScene::NodeForLight(CLight *pLight)
{
// Slow. Is there a better way to do this?
std::vector<CSceneNode*>& rLights = mNodes[eLightNode];
std::vector<CSceneNode*>& rLights = mNodes[ENodeType::Light];
for (auto it = rLights.begin(); it != rLights.end(); it++)
{
@@ -374,21 +374,21 @@ CGameArea* CScene::ActiveArea()
FShowFlags CScene::ShowFlagsForNodeFlags(FNodeFlags NodeFlags)
{
FShowFlags Out;
if (NodeFlags & eModelNode) Out |= eShowSplitWorld;
if (NodeFlags & eStaticNode) Out |= eShowMergedWorld;
if (NodeFlags & eScriptNode) Out |= eShowObjects;
if (NodeFlags & eCollisionNode) Out |= eShowWorldCollision;
if (NodeFlags & eLightNode) Out |= eShowLights;
if (NodeFlags & ENodeType::Model) Out |= EShowFlag::SplitWorld;
if (NodeFlags & ENodeType::Static) Out |= EShowFlag::MergedWorld;
if (NodeFlags & ENodeType::Script) Out |= EShowFlag::Objects;
if (NodeFlags & ENodeType::Collision) Out |= EShowFlag::WorldCollision;
if (NodeFlags & ENodeType::Light) Out |= EShowFlag::Lights;
return Out;
}
FNodeFlags CScene::NodeFlagsForShowFlags(FShowFlags ShowFlags)
{
FNodeFlags Out = eRootNode;
if (ShowFlags & eShowSplitWorld) Out |= eModelNode;
if (ShowFlags & eShowMergedWorld) Out |= eStaticNode;
if (ShowFlags & eShowWorldCollision) Out |= eCollisionNode;
if (ShowFlags & eShowObjects) Out |= eScriptNode | eScriptExtraNode;
if (ShowFlags & eShowLights) Out |= eLightNode;
FNodeFlags Out = ENodeType::Root;
if (ShowFlags & EShowFlag::SplitWorld) Out |= ENodeType::Model;
if (ShowFlags & EShowFlag::MergedWorld) Out |= ENodeType::Static;
if (ShowFlags & EShowFlag::WorldCollision) Out |= ENodeType::Collision;
if (ShowFlags & EShowFlag::Objects) Out |= ENodeType::Script | ENodeType::ScriptExtra;
if (ShowFlags & EShowFlag::Lights) Out |= ENodeType::Light;
return Out;
}

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

@@ -20,6 +20,7 @@
#include <unordered_map>
#include <vector>
/** Needs lots of changes, see CSceneNode for most of my thoughts on this */
class CScene
{
friend class CSceneIterator;

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

@@ -18,7 +18,7 @@ class CSceneIterator
std::vector<CSceneNode*>::iterator mVectorIterator;
public:
CSceneIterator(CScene *pScene, FNodeFlags AllowedNodeTypes = eAllNodeTypes, bool AllowHiddenNodes = false);
CSceneIterator(CScene *pScene, FNodeFlags AllowedNodeTypes = ENodeType::All, bool AllowHiddenNodes = false);
inline CSceneNode* Next()
{

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

@@ -159,7 +159,7 @@ void CSceneNode::BuildLightList(CGameArea *pArea)
CLight* pLight = pArea->Light(Index, iLight);
// Ambient lights should only be present one per layer; need to check how the game deals with multiple ambients
if (pLight->Type() == eLocalAmbient)
if (pLight->Type() == ELightType::LocalAmbient)
mAmbientColor = pLight->Color();
// Other lights will be used depending which are closest to the node
@@ -186,22 +186,22 @@ void CSceneNode::BuildLightList(CGameArea *pArea)
void CSceneNode::LoadLights(const SViewInfo& rkViewInfo)
{
CGraphics::sNumLights = 0;
CGraphics::ELightingMode Mode = (rkViewInfo.GameMode ? CGraphics::eWorldLighting : CGraphics::sLightMode);
CGraphics::ELightingMode Mode = (rkViewInfo.GameMode ? CGraphics::ELightingMode::World : CGraphics::sLightMode);
switch (Mode)
{
case CGraphics::eNoLighting:
case CGraphics::ELightingMode::None:
// No lighting: full white ambient, no dynamic lights
CGraphics::sVertexBlock.COLOR0_Amb = CColor::skWhite;
break;
case CGraphics::eBasicLighting:
case CGraphics::ELightingMode::Basic:
// Basic lighting: default ambient color, default dynamic lights
CGraphics::SetDefaultLighting();
CGraphics::sVertexBlock.COLOR0_Amb = CGraphics::skDefaultAmbientColor;
break;
case CGraphics::eWorldLighting:
case CGraphics::ELightingMode::World:
// World lighting: world ambient color, node dynamic lights
CGraphics::sVertexBlock.COLOR0_Amb = mAmbientColor;
@@ -210,7 +210,7 @@ void CSceneNode::LoadLights(const SViewInfo& rkViewInfo)
break;
}
CGraphics::sPixelBlock.LightmapMultiplier = (Mode == CGraphics::eWorldLighting ? 1.f : 0.f);
CGraphics::sPixelBlock.LightmapMultiplier = (Mode == CGraphics::ELightingMode::World ? 1.f : 0.f);
CGraphics::UpdateLightBlock();
}
@@ -219,25 +219,25 @@ void CSceneNode::AddModelToRenderer(CRenderer *pRenderer, CModel *pModel, uint32
ASSERT(pModel);
if (!pModel->HasTransparency(MatSet))
pRenderer->AddMesh(this, -1, AABox(), false, eDrawMesh);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawMesh);
else
{
pRenderer->AddMesh(this, -1, AABox(), false, eDrawOpaqueParts);
pRenderer->AddMesh(this, -1, AABox(), true, eDrawTransparentParts);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawOpaqueParts);
pRenderer->AddMesh(this, -1, AABox(), true, ERenderCommand::DrawTransparentParts);
}
}
void CSceneNode::DrawModelParts(CModel *pModel, FRenderOptions Options, uint32 MatSet, ERenderCommand RenderCommand)
{
// Common rendering functionality
if (RenderCommand == eDrawMesh)
if (RenderCommand == ERenderCommand::DrawMesh)
pModel->Draw(Options, MatSet);
else
{
bool DrawOpaque = (RenderCommand == eDrawMesh || RenderCommand == eDrawOpaqueParts);
bool DrawTransparent = (RenderCommand == eDrawMesh || RenderCommand == eDrawTransparentParts);
bool DrawOpaque = (RenderCommand == ERenderCommand::DrawMesh || RenderCommand == ERenderCommand::DrawOpaqueParts);
bool DrawTransparent = (RenderCommand == ERenderCommand::DrawMesh || RenderCommand == ERenderCommand::DrawTransparentParts);
for (uint32 iSurf = 0; iSurf < pModel->GetSurfaceCount(); iSurf++)
{
@@ -259,7 +259,7 @@ void CSceneNode::DrawBoundingBox() const
void CSceneNode::DrawRotationArrow() const
{
static TResPtr<CModel> spArrowModel = gpEditorStore->LoadResource("RotationArrow.CMDL");
spArrowModel->Draw(eNoRenderOptions, 0);
spArrowModel->Draw(ERenderOption::None, 0);
}
// ************ TRANSFORM ************
@@ -267,10 +267,10 @@ void CSceneNode::Translate(const CVector3f& rkTranslation, ETransformSpace Trans
{
switch (TransformSpace)
{
case eWorldTransform:
case ETransformSpace::World:
mPosition += rkTranslation;
break;
case eLocalTransform:
case ETransformSpace::Local:
mPosition += mRotation * rkTranslation;
break;
}
@@ -281,10 +281,10 @@ void CSceneNode::Rotate(const CQuaternion& rkRotation, ETransformSpace Transform
{
switch (TransformSpace)
{
case eWorldTransform:
case ETransformSpace::World:
mRotation = rkRotation * mRotation;
break;
case eLocalTransform:
case ETransformSpace::Local:
mRotation *= rkRotation;
break;
}
@@ -295,10 +295,10 @@ void CSceneNode::Rotate(const CQuaternion& rkRotation, const CVector3f& rkPivot,
{
switch (TransformSpace)
{
case eWorldTransform:
case ETransformSpace::World:
mPosition = rkPivot + (rkRotation * (mPosition - rkPivot));
break;
case eLocalTransform:
case ETransformSpace::Local:
mPosition = rkPivot + ((rkPivotRotation * rkRotation * rkPivotRotation.Inverse()) * (mPosition - rkPivot));
break;
}

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

@@ -19,6 +19,53 @@
class CRenderer;
class CScene;
/**
* @todo so like a lot of this needs to be completely rewritten for various reasons
* but basically currently there is a layer of abstraction between a real game object
* and its scene representation (its node). This would normally be ok except in our
* case there is not really any good reason for this abstraction to exist, it's just
* an extra layer that needs to be kept in sync with the real object or else bugs
* happen. It would make sense if we did rendering on another thread (which would give
* us a legitimate reason to need multiple representations of an object), but we don't.
* Splitting off into a graphics thread may be an option, but might not be worth it
* unless it could be shown to have very significant performance benefits, considering
* that we don't really do that much performance-intensive stuff other than rendering.
* So barring that, the abstraction layer should just be removed entirely and objects
* should be able to directly represent themselves in the scene, which would ultimately
* end up simplifying quite a lot of things in the codebase. But then a lot of objects
* like to have their own method of storing stuff like transform data (for example,
* script objects might store it within a property data blob) so that might necessitate
* a rewrite in how nodes store & access this kind of data in general... or maybe
* objects shouldn't even directly have scene representations but instead their
* primitive components (3D model, billboard, etc whatever) should.
*
* Another significant problem is that there is no generalized code for dealing with
* rendering of different types of graphics priimitives (sprites, models, skinned
* models, etc) which results in a lot of node subclasses containing duplicated code,
* as there is no real place where this code can be centralized. There probably needs
* to be some type of component system implemented. This is also partly a symptom of
* a different problem where nodes simply have too much control over how they render
* whereas the renderer doesn't have enough; it would be preferable if nodes simply
* submitted geometry for rendering and the renderer handled it from there, rather than
* nodes also being directly responsible for actually rendering that geometry. Also
* nodes really really shouldn't be responsible for culling themselves; that's something
* that really should be handled in a more generic way by the renderer.
*
* I'm also not a fan of the reliance on raycasting for detecting mouse input from the
* user; the raycasting code kinda works, but it tends to be very performance-intensive
* (especially when we currently don't have any type of octree support for the scene) and
* requires a lot of specialized code for every type of primitive, which again gets duplicated
* everywhere. Additionally this means you can't raycast against animated models because we do
* all skinning on the GPU, and likewise if we had support for particles you wouldn't be able
* to raycast against those either. So I feel it'd make sense to move to a system where we do
* object picking via a separate rendering pass to a render target and then check which node
* is under the mouse, which would work straight out of the box for every primitive type that
* can be rendered, and would generally be simpler and more accurate than the raycast (which
* in some cases can calculate different results than what object is visually under the mouse).
*
* Lots of text but hopefully communicates my thoughts on the current implementation and
* what I think needs to be changed in the future.
*/
class CSceneNode : public IRenderable
{
private:

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

@@ -31,7 +31,7 @@ void CScriptAttachNode::AttachPropertyModified()
CModel* pModel = Model();
if (pModel && pModel->Type() == eModel)
if (pModel && pModel->Type() == EResourceType::Model)
mLocalAABox = pModel->AABox();
else
mLocalAABox = CAABox::skInfinite;
@@ -42,7 +42,7 @@ void CScriptAttachNode::AttachPropertyModified()
void CScriptAttachNode::ParentDisplayAssetChanged(CResource* pNewDisplayAsset)
{
if (pNewDisplayAsset->Type() == eAnimSet)
if (pNewDisplayAsset->Type() == EResourceType::AnimSet)
{
CSkeleton* pSkel = mpScriptNode->ActiveSkeleton();
mpLocator = pSkel->BoneByName(mLocatorName);
@@ -60,10 +60,10 @@ CModel* CScriptAttachNode::Model() const
{
if (mpAttachAsset)
{
if (mpAttachAsset->Type() == eModel)
if (mpAttachAsset->Type() == EResourceType::Model)
return static_cast<CModel*>(mpAttachAsset.RawPointer());
else if (mpAttachAsset->Type() == eAnimSet)
else if (mpAttachAsset->Type() == EResourceType::AnimSet)
return mAttachAnimSetRef.Get().GetCurrentModel();
}
@@ -80,7 +80,7 @@ void CScriptAttachNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkV
AddModelToRenderer(pRenderer, pModel, 0);
if (mpParent->IsSelected() && !rkViewInfo.GameMode)
pRenderer->AddMesh(this, -1, AABox(), false, eDrawSelection);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawSelection);
}
}
@@ -102,7 +102,7 @@ void CScriptAttachNode::DrawSelection()
{
LoadModelMatrix();
glBlendFunc(GL_ONE, GL_ZERO);
Model()->DrawWireframe(eNoRenderOptions, mpParent->WireframeColor());
Model()->DrawWireframe(ERenderOption::None, mpParent->WireframeColor());
}
void CScriptAttachNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& /*rkViewInfo*/)
@@ -126,7 +126,7 @@ SRayIntersection CScriptAttachNode::RayNodeIntersectTest(const CRay& rkRay, uint
Out.ComponentIndex = AssetID;
CRay TransformedRay = rkRay.Transformed(Transform().Inverse());
std::pair<bool,float> Result = Model()->GetSurface(AssetID)->IntersectsRay(TransformedRay, Options.HasFlag(eEnableBackfaceCull));
std::pair<bool,float> Result = Model()->GetSurface(AssetID)->IntersectsRay(TransformedRay, Options.HasFlag(ERenderOption::EnableBackfaceCull));
if (Result.first)
{

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

@@ -26,7 +26,7 @@ public:
void ParentDisplayAssetChanged(CResource *pNewDisplayAsset);
CModel* Model() const;
ENodeType NodeType() { return eScriptAttachNode; }
ENodeType NodeType() { return ENodeType::ScriptAttach; }
void AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInfo);
void Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand Command, const SViewInfo& rkViewInfo);
void DrawSelection();

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

@@ -13,7 +13,7 @@
CScriptNode::CScriptNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CScriptObject *pInstance)
: CSceneNode(pScene, NodeID, pParent)
, mGameModeVisibility(eUntested)
, mGameModeVisibility(EGameModeVisibility::Untested)
, mpVolumePreviewNode(nullptr)
, mHasVolumePreview(false)
, mpInstance(pInstance)
@@ -46,13 +46,13 @@ CScriptNode::CScriptNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CSc
// Create preview volume node
mpVolumePreviewNode = new CModelNode(pScene, -1, this, nullptr);
if (pTemp->ScaleType() == CScriptTemplate::eScaleVolume)
if (pTemp->ScaleType() == CScriptTemplate::EScaleType::ScaleVolume)
{
UpdatePreviewVolume();
if (mHasVolumePreview)
{
mpVolumePreviewNode->SetInheritance(true, (mpInstance->VolumeShape() != eAxisAlignedBoxShape), true);
mpVolumePreviewNode->SetInheritance(true, (mpInstance->VolumeShape() != EVolumeShape::AxisAlignedBoxShape), true);
mpVolumePreviewNode->ForceAlphaEnabled(true);
}
}
@@ -81,7 +81,7 @@ CScriptNode::CScriptNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CSc
ENodeType CScriptNode::NodeType()
{
return eScriptNode;
return ENodeType::Script;
}
void CScriptNode::PostLoad()
@@ -123,10 +123,10 @@ void CScriptNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
// If we're in game mode, then override other visibility settings.
if (rkViewInfo.GameMode)
{
if (mGameModeVisibility == eUntested)
if (mGameModeVisibility == EGameModeVisibility::Untested)
TestGameModeVisibility();
if (mGameModeVisibility != eVisible)
if (mGameModeVisibility != EGameModeVisibility::Visible)
return;
}
@@ -136,10 +136,10 @@ void CScriptNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
if (ShouldDraw)
{
// Otherwise, we proceed as normal
if ((rkViewInfo.ShowFlags & eShowObjectCollision) && (!rkViewInfo.GameMode))
if ((rkViewInfo.ShowFlags & EShowFlag::ObjectCollision) && (!rkViewInfo.GameMode))
mpCollisionNode->AddToRenderer(pRenderer, rkViewInfo);
if (rkViewInfo.ShowFlags & eShowObjectGeometry || rkViewInfo.GameMode)
if (rkViewInfo.ShowFlags & EShowFlag::ObjectGeometry || rkViewInfo.GameMode)
{
for (uint32 iAttach = 0; iAttach < mAttachments.size(); iAttach++)
mAttachments[iAttach]->AddToRenderer(pRenderer, rkViewInfo);
@@ -149,7 +149,7 @@ void CScriptNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
CModel *pModel = ActiveModel();
if (!pModel)
pRenderer->AddMesh(this, -1, AABox(), false, eDrawMesh);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawMesh);
else
AddModelToRenderer(pRenderer, pModel, 0);
}
@@ -161,7 +161,7 @@ void CScriptNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
// Script nodes always draw their selections regardless of frustum planes
// in order to ensure that script connection lines don't get improperly culled.
if (ShouldDraw)
pRenderer->AddMesh(this, -1, AABox(), false, eDrawSelection);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawSelection);
if (mHasVolumePreview && (!mpExtra || mpExtra->ShouldDrawVolume()))
mpVolumePreviewNode->AddToRenderer(pRenderer, rkViewInfo);
@@ -177,7 +177,7 @@ void CScriptNode::Draw(FRenderOptions Options, int /*ComponentIndex*/, ERenderCo
{
EWorldLightingOptions LightingOptions = (mpLightParameters ? mpLightParameters->WorldLightingOptions() : eNormalLighting);
if (CGraphics::sLightMode == CGraphics::eWorldLighting && LightingOptions == eDisableWorldLighting)
if (CGraphics::sLightMode == CGraphics::ELightingMode::World && LightingOptions == eDisableWorldLighting)
{
CGraphics::sNumLights = 0;
CGraphics::sVertexBlock.COLOR0_Amb = CColor::skBlack;
@@ -188,7 +188,7 @@ void CScriptNode::Draw(FRenderOptions Options, int /*ComponentIndex*/, ERenderCo
else
{
// DKCR doesn't support world lighting yet, so light nodes that don't have ingame models with default lighting
if (Template()->Game() == EGame::DKCReturns && !mpInstance->HasInGameModel() && CGraphics::sLightMode == CGraphics::eWorldLighting)
if (Template()->Game() == EGame::DKCReturns && !mpInstance->HasInGameModel() && CGraphics::sLightMode == CGraphics::ELightingMode::World)
{
CGraphics::SetDefaultLighting();
CGraphics::sVertexBlock.COLOR0_Amb = CGraphics::skDefaultAmbientColor;
@@ -227,7 +227,7 @@ void CScriptNode::Draw(FRenderOptions Options, int /*ComponentIndex*/, ERenderCo
}
// Draw billboard
else if (mpDisplayAsset->Type() == eTexture)
else if (mpDisplayAsset->Type() == EResourceType::Texture)
{
CDrawUtil::DrawBillboard(ActiveBillboard(), mPosition, BillboardScale(), TintColor(rkViewInfo));
}
@@ -243,7 +243,7 @@ void CScriptNode::DrawSelection()
{
CModel *pModel = ActiveModel();
if (!pModel) pModel = CDrawUtil::GetCubeModel();
pModel->DrawWireframe(eNoRenderOptions, WireframeColor());
pModel->DrawWireframe(ERenderOption::None, WireframeColor());
}
// Draw rotation arrow for billboards
@@ -267,17 +267,17 @@ void CScriptNode::DrawSelection()
CGraphics::sMVPBlock.ModelMatrix = CMatrix4f::skIdentity;
CGraphics::UpdateMVPBlock();
for (uint32 iIn = 0; iIn < mpInstance->NumLinks(eIncoming); iIn++)
for (uint32 iIn = 0; iIn < mpInstance->NumLinks(ELinkType::Incoming); iIn++)
{
// Don't draw in links if the other object is selected.
CLink *pLink = mpInstance->Link(eIncoming, iIn);
CLink *pLink = mpInstance->Link(ELinkType::Incoming, iIn);
CScriptNode *pLinkNode = mpScene->NodeForInstanceID(pLink->SenderID());
if (pLinkNode && !pLinkNode->IsSelected()) CDrawUtil::DrawLine(CenterPoint(), pLinkNode->CenterPoint(), CColor::skTransparentRed);
}
for (uint32 iOut = 0; iOut < mpInstance->NumLinks(eOutgoing); iOut++)
for (uint32 iOut = 0; iOut < mpInstance->NumLinks(ELinkType::Outgoing); iOut++)
{
CLink *pLink = mpInstance->Link(eOutgoing, iOut);
CLink *pLink = mpInstance->Link(ELinkType::Outgoing, iOut);
CScriptNode *pLinkNode = mpScene->NodeForInstanceID(pLink->ReceiverID());
if (pLinkNode) CDrawUtil::DrawLine(CenterPoint(), pLinkNode->CenterPoint(), CColor::skTransparentGreen);
}
@@ -302,10 +302,10 @@ void CScriptNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SVie
// If we're in game mode, then check whether we're visible before proceeding with the ray test.
if (rkViewInfo.GameMode)
{
if (mGameModeVisibility == eUntested)
if (mGameModeVisibility == EGameModeVisibility::Untested)
TestGameModeVisibility();
if (mGameModeVisibility != eVisible)
if (mGameModeVisibility != EGameModeVisibility::Visible)
return;
}
@@ -359,7 +359,7 @@ SRayIntersection CScriptNode::RayNodeIntersectTest(const CRay& rkRay, uint32 Ass
if (!pModel) pModel = CDrawUtil::GetCubeModel();
CRay TransformedRay = rkRay.Transformed(Transform().Inverse());
std::pair<bool,float> Result = pModel->GetSurface(AssetID)->IntersectsRay(TransformedRay, ((Options & eEnableBackfaceCull) == 0));
std::pair<bool,float> Result = pModel->GetSurface(AssetID)->IntersectsRay(TransformedRay, ((Options & ERenderOption::EnableBackfaceCull) == 0));
if (Result.first)
{
@@ -428,12 +428,12 @@ SRayIntersection CScriptNode::RayNodeIntersectTest(const CRay& rkRay, uint32 Ass
bool CScriptNode::AllowsRotate() const
{
return (Template()->RotationType() == CScriptTemplate::eRotationEnabled);
return (Template()->RotationType() == CScriptTemplate::ERotationType::RotationEnabled);
}
bool CScriptNode::AllowsScale() const
{
return (Template()->ScaleType() != CScriptTemplate::eScaleDisabled);
return (Template()->ScaleType() != CScriptTemplate::EScaleType::ScaleDisabled);
}
bool CScriptNode::IsVisible() const
@@ -483,12 +483,13 @@ void CScriptNode::PropertyModified(IProperty* pProp)
CAssetProperty* pAssetProperty = TPropCast<CAssetProperty>(pProp);
const CResTypeFilter& rkFilter = pAssetProperty->GetTypeFilter();
if (rkFilter.Accepts(eModel) || rkFilter.Accepts(eTexture) || rkFilter.Accepts(eAnimSet) || rkFilter.Accepts(eCharacter))
if (rkFilter.Accepts(EResourceType::Model) || rkFilter.Accepts(EResourceType::Texture) ||
rkFilter.Accepts(EResourceType::AnimSet) || rkFilter.Accepts(EResourceType::Character))
{
mpInstance->EvaluateDisplayAsset();
SetDisplayAsset(mpInstance->DisplayAsset());
}
else if (rkFilter.Accepts(eDynamicCollision))
else if (rkFilter.Accepts(EResourceType::DynamicCollision))
{
mpInstance->EvaluateCollisionModel();
mpCollisionNode->SetCollision(mpInstance->Collision());
@@ -537,16 +538,16 @@ void CScriptNode::UpdatePreviewVolume()
switch (Shape)
{
case eAxisAlignedBoxShape:
case eBoxShape:
case EVolumeShape::AxisAlignedBoxShape:
case EVolumeShape::BoxShape:
pVolumeModel = gpEditorStore->LoadResource("VolumeBox.CMDL");
break;
case eEllipsoidShape:
case EVolumeShape::EllipsoidShape:
pVolumeModel = gpEditorStore->LoadResource("VolumeSphere.CMDL");
break;
case eCylinderShape:
case EVolumeShape::CylinderShape:
pVolumeModel = gpEditorStore->LoadResource("VolumeCylinder.CMDL");
break;
}
@@ -572,12 +573,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.
uint32 NumLinks = mpInstance->NumLinks(eIncoming) + mpInstance->NumLinks(eOutgoing);
uint32 NumLinks = mpInstance->NumLinks(ELinkType::Incoming) + mpInstance->NumLinks(ELinkType::Outgoing);
// 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)
{
uint32 LinkedID = (mpInstance->NumLinks(eIncoming) > 0 ? mpInstance->Link(eIncoming, 0)->SenderID() : mpInstance->Link(eOutgoing, 0)->ReceiverID());
uint32 LinkedID = (mpInstance->NumLinks(ELinkType::Incoming) > 0 ? mpInstance->Link(ELinkType::Incoming, 0)->SenderID() : mpInstance->Link(ELinkType::Outgoing, 0)->ReceiverID());
CScriptNode *pNode = mpScene->NodeForInstanceID(LinkedID);
pNode->GeneratePosition();
mPosition = pNode->AbsolutePosition();
@@ -591,9 +592,9 @@ void CScriptNode::GeneratePosition()
{
CVector3f NewPos = CVector3f::skZero;
for (uint32 iIn = 0; iIn < mpInstance->NumLinks(eIncoming); iIn++)
for (uint32 iIn = 0; iIn < mpInstance->NumLinks(ELinkType::Incoming); iIn++)
{
CScriptNode *pNode = mpScene->NodeForInstanceID(mpInstance->Link(eIncoming, iIn)->SenderID());
CScriptNode *pNode = mpScene->NodeForInstanceID(mpInstance->Link(ELinkType::Incoming, iIn)->SenderID());
if (pNode)
{
@@ -602,9 +603,9 @@ void CScriptNode::GeneratePosition()
}
}
for (uint32 iOut = 0; iOut < mpInstance->NumLinks(eOutgoing); iOut++)
for (uint32 iOut = 0; iOut < mpInstance->NumLinks(ELinkType::Outgoing); iOut++)
{
CScriptNode *pNode = mpScene->NodeForInstanceID(mpInstance->Link(eOutgoing, iOut)->ReceiverID());
CScriptNode *pNode = mpScene->NodeForInstanceID(mpInstance->Link(ELinkType::Outgoing, iOut)->ReceiverID());
if (pNode)
{
@@ -625,11 +626,11 @@ void CScriptNode::TestGameModeVisibility()
{
// Don't render if we don't have an ingame model, or if this is the Prime series and the instance is not active.
if ((Template()->Game() < EGame::DKCReturns && !mpInstance->IsActive()) || !mpInstance->HasInGameModel())
mGameModeVisibility = eNotVisible;
mGameModeVisibility = EGameModeVisibility::NotVisible;
// If this is Returns, only render if the instance is active OR if it has a near visible activation.
else
mGameModeVisibility = (mpInstance->IsActive() || mpInstance->HasNearVisibleActivation()) ? eVisible : eNotVisible;
mGameModeVisibility = (mpInstance->IsActive() || mpInstance->HasNearVisibleActivation()) ? EGameModeVisibility::Visible : EGameModeVisibility::NotVisible;
}
CColor CScriptNode::WireframeColor() const
@@ -656,9 +657,9 @@ CModel* CScriptNode::ActiveModel() const
{
if (mpDisplayAsset)
{
if (mpDisplayAsset->Type() == eModel)
if (mpDisplayAsset->Type() == EResourceType::Model)
return static_cast<CModel*>(mpDisplayAsset.RawPointer());
else if (mpDisplayAsset->Type() == eAnimSet || mpDisplayAsset->Type() == eCharacter)
else if (mpDisplayAsset->Type() == EResourceType::AnimSet || mpDisplayAsset->Type() == EResourceType::Character)
return static_cast<CAnimSet*>(mpDisplayAsset.RawPointer())->Character(mCharIndex)->pModel;
}
@@ -667,7 +668,7 @@ CModel* CScriptNode::ActiveModel() const
CAnimSet* CScriptNode::ActiveAnimSet() const
{
if (mpDisplayAsset && (mpDisplayAsset->Type() == eAnimSet || mpDisplayAsset->Type() == eCharacter))
if (mpDisplayAsset && (mpDisplayAsset->Type() == EResourceType::AnimSet || mpDisplayAsset->Type() == EResourceType::Character))
return static_cast<CAnimSet*>(mpDisplayAsset.RawPointer());
else
return nullptr;
@@ -688,7 +689,7 @@ CAnimation* CScriptNode::ActiveAnimation() const
CTexture* CScriptNode::ActiveBillboard() const
{
if (mpDisplayAsset && mpDisplayAsset->Type() == eTexture)
if (mpDisplayAsset && mpDisplayAsset->Type() == EResourceType::Texture)
return static_cast<CTexture*>(mpDisplayAsset.RawPointer());
else
return nullptr;
@@ -714,7 +715,7 @@ CAABox CScriptNode::PreviewVolumeAABox() const
CVector2f CScriptNode::BillboardScale() const
{
CVector2f Out = (Template()->ScaleType() == CScriptTemplate::eScaleEnabled ? AbsoluteScale().XZ() : CVector2f(1.f));
CVector2f Out = (Template()->ScaleType() == CScriptTemplate::EScaleType::ScaleEnabled ? AbsoluteScale().XZ() : CVector2f(1.f));
return Out * 0.5f * Template()->PreviewScale();
}
@@ -742,7 +743,7 @@ void CScriptNode::SetDisplayAsset(CResource *pRes)
{
mpDisplayAsset = pRes;
bool IsAnimSet = (pRes && (pRes->Type() == eAnimSet || pRes->Type() == eCharacter));
bool IsAnimSet = (pRes && (pRes->Type() == EResourceType::AnimSet || pRes->Type() == EResourceType::Character));
mCharIndex = (IsAnimSet ? mpInstance->ActiveCharIndex() : -1);
mAnimIndex = (IsAnimSet ? mpInstance->ActiveAnimIndex() : -1);
@@ -761,13 +762,13 @@ void CScriptNode::CalculateTransform(CTransform4f& rOut) const
{
CScriptTemplate *pTemp = Template();
if (pTemp->ScaleType() != CScriptTemplate::eScaleDisabled)
if (pTemp->ScaleType() != CScriptTemplate::EScaleType::ScaleDisabled)
{
CVector3f Scale = (HasPreviewVolume() ? CVector3f::skOne : AbsoluteScale());
rOut.Scale(Scale * pTemp->PreviewScale());
}
if (pTemp->RotationType() == CScriptTemplate::eRotationEnabled)
if (pTemp->RotationType() == CScriptTemplate::ERotationType::RotationEnabled)
rOut.Rotate(AbsoluteRotation());
rOut.Translate(AbsolutePosition());

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

@@ -27,9 +27,9 @@ class CScriptNode : public CSceneNode
CLightParameters *mpLightParameters;
enum EGameModeVisibility
enum class EGameModeVisibility
{
eVisible, eNotVisible, eUntested
Visible, NotVisible, Untested
} mGameModeVisibility;
public:

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

@@ -15,7 +15,7 @@ CStaticNode::CStaticNode(CScene *pScene, uint32 NodeID, CSceneNode *pParent, CSt
ENodeType CStaticNode::NodeType()
{
return eStaticNode;
return ENodeType::Static;
}
void CStaticNode::PostLoad()
@@ -34,7 +34,7 @@ void CStaticNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
if (!rkViewInfo.ViewFrustum.BoxInFrustum(AABox())) return;
if (!mpModel->IsTransparent())
pRenderer->AddMesh(this, -1, AABox(), false, eDrawMesh);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawMesh);
else
{
@@ -44,20 +44,20 @@ void CStaticNode::AddToRenderer(CRenderer *pRenderer, const SViewInfo& rkViewInf
CAABox TransformedBox = mpModel->GetSurfaceAABox(iSurf).Transformed(Transform());
if (rkViewInfo.ViewFrustum.BoxInFrustum(TransformedBox))
pRenderer->AddMesh(this, iSurf, TransformedBox, true, eDrawMesh);
pRenderer->AddMesh(this, iSurf, TransformedBox, true, ERenderCommand::DrawMesh);
}
}
if (mSelected && !rkViewInfo.GameMode)
pRenderer->AddMesh(this, -1, AABox(), false, eDrawSelection);
pRenderer->AddMesh(this, -1, AABox(), false, ERenderCommand::DrawSelection);
}
void CStaticNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderCommand /*Command*/, const SViewInfo& rkViewInfo)
{
if (!mpModel) return;
bool IsLightingEnabled = CGraphics::sLightMode == CGraphics::eWorldLighting || rkViewInfo.GameMode;
bool UseWhiteAmbient = (mpModel->GetMaterial()->Options() & CMaterial::eDrawWhiteAmbientDKCR) != 0;
bool IsLightingEnabled = CGraphics::sLightMode == CGraphics::ELightingMode::World || rkViewInfo.GameMode;
bool UseWhiteAmbient = (mpModel->GetMaterial()->Options() & EMaterialOption::DrawWhiteAmbientDKCR) != 0;
if (IsLightingEnabled)
{
@@ -70,7 +70,7 @@ void CStaticNode::Draw(FRenderOptions Options, int ComponentIndex, ERenderComman
else
{
LoadLights(rkViewInfo);
if (CGraphics::sLightMode == CGraphics::eNoLighting || UseWhiteAmbient)
if (CGraphics::sLightMode == CGraphics::ELightingMode::None || UseWhiteAmbient)
CGraphics::sVertexBlock.COLOR0_Amb = CColor::skWhite;
}
@@ -89,7 +89,7 @@ void CStaticNode::DrawSelection()
{
if (!mpModel) return;
LoadModelMatrix();
mpModel->DrawWireframe(eNoRenderOptions, WireframeColor());
mpModel->DrawWireframe(ERenderOption::None, WireframeColor());
}
void CStaticNode::RayAABoxIntersectTest(CRayCollisionTester& rTester, const SViewInfo& /*rkViewInfo*/)
@@ -120,7 +120,7 @@ SRayIntersection CStaticNode::RayNodeIntersectTest(const CRay& rkRay, uint32 Ass
CRay TransformedRay = rkRay.Transformed(Transform().Inverse());
FRenderOptions Options = rkViewInfo.pRenderer->RenderOptions();
std::pair<bool,float> Result = mpModel->GetSurface(AssetID)->IntersectsRay(TransformedRay, ((Options & eEnableBackfaceCull) == 0));
std::pair<bool,float> Result = mpModel->GetSurface(AssetID)->IntersectsRay(TransformedRay, ((Options & ERenderOption::EnableBackfaceCull) == 0));
if (Result.first)
{

25
src/Core/Scene/ENodeType.h
View File

@@ -3,21 +3,22 @@
#include <Common/Flags.h>
enum ENodeType
enum class ENodeType : uint32
{
eRootNode = 0x0,
eModelNode = 0x1,
eCharacterNode = 0x2,
eStaticNode = 0x4,
eCollisionNode = 0x8,
eScriptNode = 0x10,
eScriptExtraNode = 0x20,
eScriptAttachNode = 0x40,
eLightNode = 0x80,
eAllNodeTypes = 0xFFFFFFFF
None = 0x0,
Root = 0x1,
Model = 0x2,
Character = 0x4,
Static = 0x8,
Collision = 0x10,
Script = 0x20,
ScriptExtra = 0x40,
ScriptAttach = 0x80,
Light = 0x100,
All = 0xFFFFFFFF
};
DECLARE_FLAGS(ENodeType, FNodeFlags)
DECLARE_FLAGS_ENUMCLASS(ENodeType, FNodeFlags)
#endif // ENODETYPE_H

2
src/Core/Scene/FShowFlags.cpp
View File

@@ -1,3 +1,3 @@
#include "FShowFlags.h"
const FShowFlags gkGameModeShowFlags = eShowMergedWorld | eShowObjectGeometry | eShowSky;
const FShowFlags gkGameModeShowFlags = EShowFlag::MergedWorld | EShowFlag::ObjectGeometry | EShowFlag::Sky;

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

@@ -3,21 +3,21 @@
#include <Common/Flags.h>
enum EShowFlag
enum class EShowFlag : uint32
{
eShowNone = 0x00,
eShowSplitWorld = 0x01,
eShowMergedWorld = 0x02,
eShowWorldCollision = 0x04,
eShowObjectGeometry = 0x08,
eShowObjectCollision = 0x10,
eShowObjects = 0x18,
eShowLights = 0x20,
eShowSky = 0x40,
eShowSkeletons = 0x80,
eShowAll = 0xFFFFFFFF
None = 0x00,
SplitWorld = 0x01,
MergedWorld = 0x02,
WorldCollision = 0x04,
ObjectGeometry = 0x08,
ObjectCollision = 0x10,
Objects = 0x18,
Lights = 0x20,
Sky = 0x40,
Skeletons = 0x80,
All = 0xFFFFFFFF
};
DECLARE_FLAGS(EShowFlag, FShowFlags)
DECLARE_FLAGS_ENUMCLASS(EShowFlag, FShowFlags)
extern const FShowFlags gkGameModeShowFlags;