AxioDL
/
PrimeWorldEditor
mirror of https://github.com/AxioDL/PrimeWorldEditor.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Renderer changes; render buckets now use new abstract class IRenderable instead of CSceneNode to allow rendering non-nodes, plus renderer modified to easily allow multiple rendering passes overlaid on each other

This commit is contained in:
parax0 2015-08-15 00:04:56 -04:00
parent 4d7774f19e
commit 928381f8e4
16 changed files with 166 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
Common/EnumUtil.h
View File

@ -1,18 +1,42 @@
#ifndef ENUMUTIL #ifndef ENUMUTIL
#define ENUMUTIL #define ENUMUTIL
#define DEFINE_ENUM_FLAGS(X) \ #define DEFINE_ENUM_FLAGS(X) \
inline X operator|(const X& A, const X& B) { \ inline X operator|(const X& A, const X& B) { \
return (X) ((int) A | (int) B); \ return (X) ((int) A | (int) B); \
} \ } \
inline void operator|= (X& A, X& B) { \ inline void operator|= (X& A, X& B) { \
A = A | B; \ A = A | B; \
} \ } \
inline X operator|(const X& A, const int B) { \ inline X operator|(const X& A, const int B) { \
return (X) ((int) A | B); \ return (X) ((int) A | B); \
} \ } \
inline void operator|= (X& A, int B) { \ inline void operator|= (X& A, int B) { \
A = A | B; \ A = A | B; \
} \
inline X operator|(const X& A, const unsigned int B) { \
return (X) ((int) A | B); \
} \
inline void operator|= (X& A, unsigned int B) { \
A = A | B; \
} \
inline X operator&(const X& A, const X& B) { \
return (X) ((int) A & (int) B); \
} \
inline void operator&= (X& A, X& B) { \
A = A & B; \
} \
inline X operator&(const X& A, const int B) { \
return (X) ((int) A & B); \
} \
inline void operator&= (X& A, int B) { \
A = A & B; \
} \
inline X operator&(const X& A, const unsigned int B) { \
return (X) ((int) A & B); \
} \
inline void operator&= (X& A, unsigned int B) { \
A = A & B; \
} }
#endif // ENUMUTIL #endif // ENUMUTIL

7
Core/CGraphics.cpp
View File

@ -157,3 +157,10 @@ void CGraphics::SetDefaultLighting()
sDefaultDirectionalLights[1].Load(); sDefaultDirectionalLights[1].Load();
sDefaultDirectionalLights[2].Load(); sDefaultDirectionalLights[2].Load();
} }
void CGraphics::SetIdentityMVP()
{
sMVPBlock.ModelMatrix = CMatrix4f::skIdentity;
sMVPBlock.ViewMatrix = CMatrix4f::skIdentity;
sMVPBlock.ProjectionMatrix = CMatrix4f::skIdentity;
}

1
Core/CGraphics.h
View File

@ -92,6 +92,7 @@ public:
static void ReleaseContext(u32 Index); static void ReleaseContext(u32 Index);
static void SetActiveContext(u32 Index); static void SetActiveContext(u32 Index);
static void SetDefaultLighting(); static void SetDefaultLighting();
static void SetIdentityMVP();
}; };
#endif // CGRAPHICS_H #endif // CGRAPHICS_H

24
Core/CRenderBucket.cpp
View File

@ -14,12 +14,12 @@ void CRenderBucket::SetSortType(ESortType Type)
mSortType = Type; mSortType = Type;
} }
void CRenderBucket::Add(const SMeshPointer& Mesh) void CRenderBucket::Add(const SRenderablePtr& ptr)
{ {
if (mSize >= mEstSize) if (mSize >= mEstSize)
mNodes.push_back(Mesh); mRenderables.push_back(ptr);
else else
mNodes[mSize] = Mesh; mRenderables[mSize] = ptr;
mSize++; mSize++;
} }
@ -28,7 +28,7 @@ void CRenderBucket::Sort(CCamera& Camera)
{ {
struct { struct {
CCamera *pCamera; CCamera *pCamera;
bool operator()(SMeshPointer left, SMeshPointer right) { bool operator()(SRenderablePtr left, SRenderablePtr right) {
CVector3f cPos = pCamera->Position(); CVector3f cPos = pCamera->Position();
CVector3f cDir = pCamera->GetDirection(); CVector3f cDir = pCamera->GetDirection();
@ -42,7 +42,7 @@ void CRenderBucket::Sort(CCamera& Camera)
backToFront.pCamera = &Camera; backToFront.pCamera = &Camera;
if (mSortType == BackToFront) if (mSortType == BackToFront)
std::stable_sort(mNodes.begin(), mNodes.begin() + mSize, backToFront); std::stable_sort(mRenderables.begin(), mRenderables.begin() + mSize, backToFront);
// Test: draw node bounding boxes + vertices used for sorting // Test: draw node bounding boxes + vertices used for sorting
/*for (u32 iNode = 0; iNode < mNodes.size(); iNode++) /*for (u32 iNode = 0; iNode < mNodes.size(); iNode++)
@ -67,7 +67,7 @@ void CRenderBucket::Sort(CCamera& Camera)
void CRenderBucket::Clear() void CRenderBucket::Clear()
{ {
mEstSize = mSize; mEstSize = mSize;
if (mNodes.size() > mSize) mNodes.resize(mSize); if (mRenderables.size() > mSize) mRenderables.resize(mSize);
mSize = 0; mSize = 0;
} }
@ -75,14 +75,14 @@ void CRenderBucket::Draw(ERenderOptions Options)
{ {
for (u32 n = 0; n < mSize; n++) for (u32 n = 0; n < mSize; n++)
{ {
if (mNodes[n].Command == eDrawMesh) if (mRenderables[n].Command == eDrawMesh)
mNodes[n].pNode->Draw(Options); mRenderables[n].pRenderable->Draw(Options);
else if (mNodes[n].Command == eDrawAsset) else if (mRenderables[n].Command == eDrawAsset)
mNodes[n].pNode->DrawAsset(Options, mNodes[n].Asset); mRenderables[n].pRenderable->DrawAsset(Options, mRenderables[n].Asset);
else if (mNodes[n].Command == eDrawSelection) else if (mRenderables[n].Command == eDrawSelection)
mNodes[n].pNode->DrawSelection(); mRenderables[n].pRenderable->DrawSelection();
// todo: implementation for eDrawExtras // todo: implementation for eDrawExtras
} }

6
Core/CRenderBucket.h
View File

@ -3,8 +3,8 @@
#include "CCamera.h" #include "CCamera.h"
#include "ERenderOptions.h" #include "ERenderOptions.h"
#include "SRenderablePtr.h"
#include <Common/types.h> #include <Common/types.h>
#include <OpenGL/SMeshPointer.h>
#include <vector> #include <vector>
class CRenderBucket class CRenderBucket
@ -17,14 +17,14 @@ public:
}; };
private: private:
ESortType mSortType; ESortType mSortType;
std::vector<SMeshPointer> mNodes; std::vector<SRenderablePtr> mRenderables;
u32 mEstSize; u32 mEstSize;
u32 mSize; u32 mSize;
public: public:
CRenderBucket(); CRenderBucket();
void SetSortType(ESortType Type); void SetSortType(ESortType Type);
void Add(const SMeshPointer& Mesh); void Add(const SRenderablePtr& ptr);
void Sort(CCamera& Camera); void Sort(CCamera& Camera);
void Clear(); void Clear();
void Draw(ERenderOptions Options); void Draw(ERenderOptions Options);

109
Core/CRenderer.cpp
View File

@ -60,12 +60,14 @@ bool CRenderer::IsUVAnimationOn()
void CRenderer::ToggleBackfaceCull(bool b) void CRenderer::ToggleBackfaceCull(bool b)
{ {
mOptions = (ERenderOptions) ((mOptions & ~eEnableBackfaceCull) | (b << 1)); if (b) mOptions |= eEnableBackfaceCull;
else mOptions &= ~eEnableBackfaceCull;
} }
void CRenderer::ToggleUVAnimation(bool b) void CRenderer::ToggleUVAnimation(bool b)
{ {
mOptions = (ERenderOptions) ((mOptions & ~eEnableUVScroll) | b); if (b) mOptions |= eEnableUVScroll;
else mOptions &= ~eEnableUVScroll;
} }
void CRenderer::ToggleGrid(bool b) void CRenderer::ToggleGrid(bool b)
@ -75,12 +77,14 @@ void CRenderer::ToggleGrid(bool b)
void CRenderer::ToggleOccluders(bool b) void CRenderer::ToggleOccluders(bool b)
{ {
mOptions = (ERenderOptions) ((mOptions & ~eEnableOccluders) | (b << 2)); if (b) mOptions |= eEnableOccluders;
else mOptions &= ~eEnableOccluders;
} }
void CRenderer::ToggleAlphaDisabled(bool b) void CRenderer::ToggleAlphaDisabled(bool b)
{ {
mOptions = (ERenderOptions) ((mOptions & ~eNoAlpha) | (b << 5)); if (b) mOptions |= eNoAlpha;
else mOptions &= ~eNoAlpha;
} }
void CRenderer::SetBloom(EBloomMode BloomMode) void CRenderer::SetBloom(EBloomMode BloomMode)
@ -88,9 +92,9 @@ void CRenderer::SetBloom(EBloomMode BloomMode)
mBloomMode = BloomMode; mBloomMode = BloomMode;
if (BloomMode != eNoBloom) if (BloomMode != eNoBloom)
mOptions = (ERenderOptions) (mOptions | eEnableBloom); mOptions |= eEnableBloom;
else else
mOptions = (ERenderOptions) (mOptions & ~eEnableBloom); mOptions &= ~eEnableBloom;
} }
void CRenderer::SetFont(CFont *pFont) void CRenderer::SetFont(CFont *pFont)
@ -118,22 +122,33 @@ void CRenderer::SetViewportSize(u32 Width, u32 Height)
} }
// ************ RENDER ************ // ************ RENDER ************
void CRenderer::RenderScene(CCamera& Camera) void CRenderer::RenderBuckets(CCamera& Camera)
{ {
if (!mInitialized) Init(); if (!mInitialized) Init();
// Set backface culling
if (mOptions & eEnableBackfaceCull) glEnable(GL_CULL_FACE);
else glDisable(GL_CULL_FACE);
// Render scene to texture // Render scene to texture
glDepthRange(0.f, 1.f); glDepthRange(0.f, 1.f);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
mOpaqueBucket.Draw(mOptions); mOpaqueBucket.Draw(mOptions);
mOpaqueBucket.Clear(); mOpaqueBucket.Clear();
mTransparentBucket.Sort(Camera); mTransparentBucket.Sort(Camera);
mTransparentBucket.Draw(mOptions); mTransparentBucket.Draw(mOptions);
mTransparentBucket.Clear(); mTransparentBucket.Clear();
// Clear depth buffer to enable more rendering passes
glClear(GL_DEPTH_BUFFER_BIT);
} }
void CRenderer::RenderBloom() void CRenderer::RenderBloom()
{ {
// Check to ensure bloom is enabled
if (mBloomMode == eNoBloom) return;
// Setup // Setup
static const float skHOffset[6] = { -0.008595f, -0.005470f, -0.002345f, static const float skHOffset[6] = { -0.008595f, -0.005470f, -0.002345f,
0.002345f, 0.005470f, 0.008595f }; 0.002345f, 0.005470f, 0.008595f };
@ -158,9 +173,7 @@ void CRenderer::RenderBloom()
glClearColor(0.f, 0.f, 0.f, 0.f); glClearColor(0.f, 0.f, 0.f, 0.f);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
CGraphics::sMVPBlock.ModelMatrix = CMatrix4f::skIdentity; CGraphics::SetIdentityMVP();
CGraphics::sMVPBlock.ViewMatrix = CMatrix4f::skIdentity;
CGraphics::sMVPBlock.ProjectionMatrix = CMatrix4f::skIdentity;
CGraphics::UpdateMVPBlock(); CGraphics::UpdateMVPBlock();
// Pass 1: Alpha-blend the scene texture on a black background // Pass 1: Alpha-blend the scene texture on a black background
@ -211,6 +224,28 @@ void CRenderer::RenderBloom()
glBlendFunc(GL_ONE, GL_ONE); glBlendFunc(GL_ONE, GL_ONE);
CDrawUtil::DrawSquare(); CDrawUtil::DrawSquare();
} }
// Render result onto main scene framebuffer
mSceneFramebuffer.Bind();
glViewport(0, 0, mViewportWidth, mViewportHeight);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
CGraphics::SetIdentityMVP();
CGraphics::UpdateMVPBlock();
CDrawUtil::UseTextureShader();
glBlendFunc(GL_ONE, GL_ONE);
mBloomFramebuffers[2].Texture()->Bind(0);
CDrawUtil::DrawSquare();
if (mBloomMode == eBloomMaps)
{
// Bloom maps are in the framebuffer alpha channel.
// White * dst alpha = bloom map colors
CDrawUtil::UseColorShader(CColor::skWhite);
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
CDrawUtil::DrawSquare();
}
} }
void CRenderer::RenderSky(CModel *pSkyboxModel, CVector3f CameraPosition) void CRenderer::RenderSky(CModel *pSkyboxModel, CVector3f CameraPosition)
@ -236,24 +271,24 @@ void CRenderer::RenderSky(CModel *pSkyboxModel, CVector3f CameraPosition)
pSkyboxModel->Draw(mOptions, 0); pSkyboxModel->Draw(mOptions, 0);
} }
void CRenderer::AddOpaqueMesh(CSceneNode *pNode, u32 AssetID, CAABox& AABox, ERenderCommand Command) void CRenderer::AddOpaqueMesh(IRenderable *pRenderable, u32 AssetID, CAABox& AABox, ERenderCommand Command)
{ {
SMeshPointer mesh; SRenderablePtr ptr;
mesh.pNode = pNode; ptr.pRenderable = pRenderable;
mesh.Asset = AssetID; ptr.Asset = AssetID;
mesh.AABox = AABox; ptr.AABox = AABox;
mesh.Command = Command; ptr.Command = Command;
mOpaqueBucket.Add(mesh); mOpaqueBucket.Add(ptr);
} }
void CRenderer::AddTransparentMesh(CSceneNode *pNode, u32 AssetID, CAABox& AABox, ERenderCommand Command) void CRenderer::AddTransparentMesh(IRenderable *pRenderable, u32 AssetID, CAABox& AABox, ERenderCommand Command)
{ {
SMeshPointer mesh; SRenderablePtr ptr;
mesh.pNode = pNode; ptr.pRenderable = pRenderable;
mesh.Asset = AssetID; ptr.Asset = AssetID;
mesh.AABox = AABox; ptr.AABox = AABox;
mesh.Command = Command; ptr.Command = Command;
mTransparentBucket.Add(mesh); mTransparentBucket.Add(ptr);
} }
void CRenderer::BeginFrame() void CRenderer::BeginFrame()
@ -269,15 +304,12 @@ void CRenderer::BeginFrame()
glViewport(0, 0, mViewportWidth, mViewportHeight); glViewport(0, 0, mViewportWidth, mViewportHeight);
InitFramebuffer(); InitFramebuffer();
if (mOptions & eEnableBackfaceCull) glEnable(GL_CULL_FACE);
else glDisable(GL_CULL_FACE);
} }
void CRenderer::EndFrame() void CRenderer::EndFrame()
{ {
// Post-processing // Post-processing
if ((mBloomMode == eBloom) || (mBloomMode == eFakeBloom)) if (mBloomMode != eNoBloom)
RenderBloom(); RenderBloom();
// Render result to screen // Render result to screen
@ -285,9 +317,7 @@ void CRenderer::EndFrame()
InitFramebuffer(); InitFramebuffer();
glViewport(0, 0, mViewportWidth, mViewportHeight); glViewport(0, 0, mViewportWidth, mViewportHeight);
CGraphics::sMVPBlock.ModelMatrix = CMatrix4f::skIdentity; CGraphics::SetIdentityMVP();
CGraphics::sMVPBlock.ViewMatrix = CMatrix4f::skIdentity;
CGraphics::sMVPBlock.ProjectionMatrix = CMatrix4f::skIdentity;
CGraphics::UpdateMVPBlock(); CGraphics::UpdateMVPBlock();
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
@ -298,23 +328,6 @@ void CRenderer::EndFrame()
mSceneFramebuffer.Texture()->Bind(0); mSceneFramebuffer.Texture()->Bind(0);
CDrawUtil::DrawSquare(); CDrawUtil::DrawSquare();
if ((mBloomMode == eBloom) || (mBloomMode == eFakeBloom))
{
CDrawUtil::UseTextureShader();
glBlendFunc(GL_ONE, GL_ONE);
mBloomFramebuffers[2].Texture()->Bind(0);
CDrawUtil::DrawSquare();
}
else if (mBloomMode == eBloomMaps)
{
// Bloom maps are in the framebuffer alpha channel.
// White * dst alpha = bloom map colors
CDrawUtil::UseColorShader(CColor::skWhite);
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
CDrawUtil::DrawSquare();
}
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
gDrawCount = 0; gDrawCount = 0;
} }

8
Core/CRenderer.h
View File

@ -8,12 +8,12 @@
#include "CRenderBucket.h" #include "CRenderBucket.h"
#include "ERenderOptions.h" #include "ERenderOptions.h"
#include "ERenderCommand.h" #include "ERenderCommand.h"
#include "SRenderablePtr.h"
#include <Common/CAABox.h> #include <Common/CAABox.h>
#include <Common/CColor.h> #include <Common/CColor.h>
#include <Common/CMatrix4f.h> #include <Common/CMatrix4f.h>
#include <Common/types.h> #include <Common/types.h>
#include <OpenGL/CFramebuffer.h> #include <OpenGL/CFramebuffer.h>
#include <OpenGL/SMeshPointer.h>
#include <Resource/CFont.h> #include <Resource/CFont.h>
#include <Resource/CLight.h> #include <Resource/CLight.h>
#include <Resource/CTexture.h> #include <Resource/CTexture.h>
@ -65,11 +65,11 @@ public:
void SetViewportSize(u32 Width, u32 Height); void SetViewportSize(u32 Width, u32 Height);
// Render // Render
void RenderScene(CCamera& Camera); void RenderBuckets(CCamera& Camera);
void RenderBloom(); void RenderBloom();
void RenderSky(CModel *pSkyboxModel, CVector3f CameraPosition); void RenderSky(CModel *pSkyboxModel, CVector3f CameraPosition);
void AddOpaqueMesh(CSceneNode *pNode, u32 AssetID, CAABox& AABox, ERenderCommand Command); void AddOpaqueMesh(IRenderable *pRenderable, u32 AssetID, CAABox& AABox, ERenderCommand Command);
void AddTransparentMesh(CSceneNode *pNode, u32 AssetID, CAABox& AABox, ERenderCommand Command); void AddTransparentMesh(IRenderable *pRenderable, u32 AssetID, CAABox& AABox, ERenderCommand Command);
void BeginFrame(); void BeginFrame();
void EndFrame(); void EndFrame();

21
Core/IRenderable.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef IRENDERABLE_H
#define IRENDERABLE_H
#include "ERenderOptions.h"
#include <Common/CAABox.h>
#include <Common/types.h>
class CRenderer;
class IRenderable
{
public:
IRenderable() {}
virtual ~IRenderable() {}
virtual void AddToRenderer(CRenderer *pRenderer) = 0;
virtual void Draw(ERenderOptions options) = 0;
virtual void DrawAsset(ERenderOptions, u32) {}
virtual void DrawSelection() {}
};
#endif // IRENDERABLE_H

10
OpenGL/SMeshPointer.h → Core/SRenderablePtr.h
View File

@ -1,5 +1,5 @@
#ifndef SMESHPOINTER_H #ifndef SRENDERABLEPTR_H
#define SMESHPOINTER_H #define SRENDERABLEPTR_H
#include <Common/CAABox.h> #include <Common/CAABox.h>
#include <Common/types.h> #include <Common/types.h>
@ -7,12 +7,12 @@
#include <Scene/CSceneNode.h> #include <Scene/CSceneNode.h>
#include <Resource/CMaterial.h> #include <Resource/CMaterial.h>
struct SMeshPointer struct SRenderablePtr
{ {
CSceneNode *pNode; IRenderable *pRenderable;
u32 Asset; u32 Asset;
CAABox AABox; CAABox AABox;
ERenderCommand Command; ERenderCommand Command;
}; };
#endif // SMESHPOINTER_H #endif // SRENDERABLEPTR_H

4
OpenGL/CDynamicVertexBuffer.cpp
View File

@ -71,9 +71,9 @@ void CDynamicVertexBuffer::ClearBuffers()
{ {
for (u32 iAttrib = 0; iAttrib < 12; iAttrib++) for (u32 iAttrib = 0; iAttrib < 12; iAttrib++)
{ {
u8 Bit = 1 << iAttrib; int bit = 1 << iAttrib;
if (mBufferedFlags & Bit) if (mBufferedFlags & bit)
glDeleteBuffers(1, &mAttribBuffers[iAttrib]); glDeleteBuffers(1, &mAttribBuffers[iAttrib]);
} }

5
PrimeWorldEditor.pro
View File

@ -159,7 +159,6 @@ HEADERS += \
OpenGL/CShaderGenerator.h \ OpenGL/CShaderGenerator.h \
OpenGL/CVertexBuffer.h \ OpenGL/CVertexBuffer.h \
OpenGL/GLCommon.h \ OpenGL/GLCommon.h \
OpenGL/SMeshPointer.h \
UI/CWorldEditorWindow.h \ UI/CWorldEditorWindow.h \
UI/PWEMaterialEditor.h \ UI/PWEMaterialEditor.h \
UI/CStartWindow.h \ UI/CStartWindow.h \
@ -282,7 +281,9 @@ HEADERS += \
UI/WScanPreviewPanel.h \ UI/WScanPreviewPanel.h \
UI/WIntegralSpinBox.h \ UI/WIntegralSpinBox.h \
UI/CAboutDialog.h \ UI/CAboutDialog.h \
UI/CGizmo.h UI/CGizmo.h \
Core/IRenderable.h \
Core/SRenderablePtr.h
FORMS += \ FORMS += \
UI/CWorldEditorWindow.ui \ UI/CWorldEditorWindow.ui \

6
Resource/CMaterialPass.cpp
View File

@ -120,7 +120,7 @@ void CMaterialPass::SetAnimCurrent(ERenderOptions Options, u32 PassIndex)
case eUVScroll: // Mode 2 case eUVScroll: // Mode 2
{ {
if (Options & eUVScroll) if (Options & eEnableUVScroll)
{ {
TexMtx[0][3] = (s * mAnimParams[2]) + mAnimParams[0]; TexMtx[0][3] = (s * mAnimParams[2]) + mAnimParams[0];
TexMtx[1][3] = (s * mAnimParams[3]) + mAnimParams[1]; TexMtx[1][3] = (s * mAnimParams[3]) + mAnimParams[1];
@ -130,7 +130,7 @@ void CMaterialPass::SetAnimCurrent(ERenderOptions Options, u32 PassIndex)
case eUVRotation: // Mode 3 case eUVRotation: // Mode 3
{ {
if (Options & eUVScroll) if (Options & eEnableUVScroll)
{ {
float Angle = (s * mAnimParams[1]) + mAnimParams[0]; float Angle = (s * mAnimParams[1]) + mAnimParams[0];
@ -150,7 +150,7 @@ void CMaterialPass::SetAnimCurrent(ERenderOptions Options, u32 PassIndex)
case eHFilmstrip: // Mode 4 case eHFilmstrip: // Mode 4
case eVFilmstrip: // Mode 5 case eVFilmstrip: // Mode 5
{ {
if (Options & eUVScroll) if (Options & eEnableUVScroll)
{ {
float Offset = mAnimParams[2] * mAnimParams[0] * (mAnimParams[3] + s); float Offset = mAnimParams[2] * mAnimParams[0] * (mAnimParams[3] + s);
Offset = (float)(short)(float)(mAnimParams[1] * fmod(Offset, 1.0f)) * mAnimParams[2]; Offset = (float)(short)(float)(mAnimParams[1] * fmod(Offset, 1.0f)) * mAnimParams[2];

8
Scene/CSceneNode.h
View File

@ -1,6 +1,7 @@
#ifndef CSCENENODE_H #ifndef CSCENENODE_H
#define CSCENENODE_H #define CSCENENODE_H
#include <Core/IRenderable.h>
#include "ENodeType.h" #include "ENodeType.h"
#include <Common/CVector3f.h> #include <Common/CVector3f.h>
#include <Common/CQuaternion.h> #include <Common/CQuaternion.h>
@ -16,7 +17,7 @@
class CRenderer; class CRenderer;
class CSceneManager; class CSceneManager;
class CSceneNode class CSceneNode : public IRenderable
{ {
private: private:
CTransform4f _mCachedTransform; CTransform4f _mCachedTransform;
@ -50,9 +51,8 @@ public:
virtual ~CSceneNode(); virtual ~CSceneNode();
virtual ENodeType NodeType() = 0; virtual ENodeType NodeType() = 0;
virtual std::string PrefixedName() const; virtual std::string PrefixedName() const;
virtual void AddToRenderer(CRenderer *pRenderer) = 0; virtual void Draw(ERenderOptions options) = 0;
virtual void Draw(ERenderOptions Options) = 0; virtual void DrawAsset(ERenderOptions options, u32 asset) = 0;
virtual void DrawAsset(ERenderOptions Options, u32 Asset) = 0;
virtual void DrawSelection(); virtual void DrawSelection();
virtual void RayAABoxIntersectTest(CRayCollisionTester& Tester); virtual void RayAABoxIntersectTest(CRayCollisionTester& Tester);
virtual SRayIntersection RayNodeIntersectTest(const CRay& Ray, u32 AssetID) = 0; virtual SRayIntersection RayNodeIntersectTest(const CRay& Ray, u32 AssetID) = 0;

2
UI/CModelEditorWindow.cpp
View File

@ -587,7 +587,7 @@ void CModelEditorWindow::PaintViewport(CCamera& Camera)
{ {
CDrawUtil::DrawGrid(); CDrawUtil::DrawGrid();
mpCurrentModelNode->AddToRenderer(mpRenderer); mpCurrentModelNode->AddToRenderer(mpRenderer);
mpRenderer->RenderScene(Camera); mpRenderer->RenderBuckets(Camera);
} }
else if (mDrawMode == eDrawSphere) else if (mDrawMode == eDrawSphere)

3
UI/CWorldEditor.cpp
View File

@ -281,7 +281,8 @@ void CWorldEditor::ViewportRender(CCamera& Camera)
if (pSky) mpRenderer->RenderSky(pSky, Camera.Position()); if (pSky) mpRenderer->RenderSky(pSky, Camera.Position());
} }
mpRenderer->RenderScene(Camera); mpRenderer->RenderBuckets(Camera);
mpRenderer->RenderBloom();
mpRenderer->EndFrame(); mpRenderer->EndFrame();
mFrameTimer.Stop(); mFrameTimer.Stop();
mFrameCount++; mFrameCount++;

2
UI/CWorldEditorWindow.cpp
View File

@ -98,7 +98,7 @@ void CWorldEditorWindow::PaintViewport(double DeltaTime)
if (pSky) mpRenderer->RenderSky(pSky, mCamera.Position()); if (pSky) mpRenderer->RenderSky(pSky, mCamera.Position());
} }
mpRenderer->RenderScene(mCamera); mpRenderer->RenderBuckets(mCamera);
mpRenderer->EndFrame(); mpRenderer->EndFrame();
} }