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

Mass code cleanup

Browse Source
This commit is contained in:
parax0
2016-03-27 13:09:38 -06:00
parent 6b79ef2f3f
commit 82ad4fb5c8
279 changed files with 5702 additions and 7227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
src/Core/Render/CCamera.cpp
View File

@@ -5,33 +5,31 @@
#include <gtc/matrix_transform.hpp>
CCamera::CCamera()
: mMode(eFreeCamera)
, mPosition(0)
, mAspectRatio(1.7777777f)
, mYaw(-Math::skHalfPi)
, mPitch(0.f)
, mMoveSpeed(1.f)
, mLookSpeed(1.f)
, mTransformDirty(true)
, mViewDirty(true)
, mProjectionDirty(true)
, mFrustumPlanesDirty(true)
{
mMode = eFreeCamera;
mPosition = CVector3f(0);
mAspectRatio = 1.7777777f;
mYaw = -Math::skHalfPi;
mPitch = 0.0f;
SetOrbit(CVector3f(0), 5.f);
mMoveSpeed = 1.f;
mLookSpeed = 1.f;
mTransformDirty = true;
mViewDirty = true;
mProjectionDirty = true;
mFrustumPlanesDirty = true;
}
// todo: make it actually look at the target!
// don't actually use this constructor, it's unfinished and won't work properly
CCamera::CCamera(CVector3f Position, CVector3f /*Target*/)
: mMode(eFreeCamera)
, mMoveSpeed(1.f)
, mLookSpeed(1.f)
, mPosition(Position)
, mYaw(-Math::skHalfPi)
, mPitch(0.f)
{
// todo: make it actually look at the target!
// don't actually use this constructor, it's unfinished and won't work properly
mMode = eFreeCamera;
mMoveSpeed = 1.f;
mLookSpeed = 1.f;
mPosition = Position;
mYaw = -Math::skHalfPi;
mPitch = 0.0f;
}
void CCamera::Pan(float XAmount, float YAmount)
@@ -123,8 +121,8 @@ CRay CCamera::CastRay(CVector2f DeviceCoords) const
{
CMatrix4f InverseVP = (ViewMatrix().Transpose() * ProjectionMatrix().Transpose()).Inverse();
CVector3f RayOrigin = CVector3f(DeviceCoords.x, DeviceCoords.y, -1.f) * InverseVP;
CVector3f RayTarget = CVector3f(DeviceCoords.x, DeviceCoords.y, 0.f) * InverseVP;
CVector3f RayOrigin = CVector3f(DeviceCoords.X, DeviceCoords.Y, -1.f) * InverseVP;
CVector3f RayTarget = CVector3f(DeviceCoords.X, DeviceCoords.Y, 0.f) * InverseVP;
CVector3f RayDir = (RayTarget - RayOrigin).Normalized();
CRay Ray;
@@ -167,9 +165,9 @@ void CCamera::SetOrbit(const CAABox& OrbitTarget, float DistScale /*= 4.f*/)
CVector3f Extent = (Max - Min) / 2.f;
float Dist = 0.f;
if (Extent.x >= Extent.y && Extent.x >= Extent.z) Dist = Extent.x;
else if (Extent.y >= Extent.x && Extent.y >= Extent.z) Dist = Extent.y;
else Dist = Extent.z;
if (Extent.X >= Extent.Y && Extent.X >= Extent.Z) Dist = Extent.X;
else if (Extent.Y >= Extent.X && Extent.Y >= Extent.Z) Dist = Extent.Y;
else Dist = Extent.Z;
mOrbitDistance = Dist * DistScale;
@@ -200,100 +198,6 @@ void CCamera::LoadMatrices() const
CGraphics::UpdateMVPBlock();
}
// ************ GETTERS ************
CVector3f CCamera::Position() const
{
UpdateTransform();
return mPosition;
}
CVector3f CCamera::Direction() const
{
UpdateTransform();
return mDirection;
}
CVector3f CCamera::UpVector() const
{
UpdateTransform();
return mUpVector;
}
CVector3f CCamera::RightVector() const
{
UpdateTransform();
return mRightVector;
}
float CCamera::Yaw() const
{
return mYaw;
}
float CCamera::Pitch() const
{
return mPitch;
}
float CCamera::FieldOfView() const
{
return 55.f;
}
ECameraMoveMode CCamera::MoveMode() const
{
return mMode;
}
const CMatrix4f& CCamera::ViewMatrix() const
{
UpdateView();
return mViewMatrix;
}
const CMatrix4f& CCamera::ProjectionMatrix() const
{
UpdateProjection();
return mProjectionMatrix;
}
const CFrustumPlanes& CCamera::FrustumPlanes() const
{
UpdateFrustum();
return mFrustumPlanes;
}
// ************ SETTERS ************
void CCamera::SetYaw(float Yaw)
{
mYaw = Yaw;
mTransformDirty = true;
}
void CCamera::SetPitch(float Pitch)
{
mPitch = Pitch;
ValidatePitch();
mTransformDirty = true;
}
void CCamera::SetMoveSpeed(float MoveSpeed)
{
mMoveSpeed = MoveSpeed;
}
void CCamera::SetLookSpeed(float LookSpeed)
{
mLookSpeed = LookSpeed;
}
void CCamera::SetAspectRatio(float AspectRatio)
{
mAspectRatio = AspectRatio;
mProjectionDirty = true;
mFrustumPlanesDirty = true;
}
// ************ PRIVATE ************
void CCamera::ValidatePitch()
{
@@ -341,9 +245,9 @@ void CCamera::UpdateView() const
if (mViewDirty)
{
glm::vec3 glmpos(mPosition.x, mPosition.y, mPosition.z);
glm::vec3 glmdir(mDirection.x, mDirection.y, mDirection.z);
glm::vec3 glmup(mUpVector.x, mUpVector.y, mUpVector.z);
glm::vec3 glmpos(mPosition.X, mPosition.Y, mPosition.Z);
glm::vec3 glmdir(mDirection.X, mDirection.Y, mDirection.Z);
glm::vec3 glmup(mUpVector.X, mUpVector.Y, mUpVector.Z);
mViewMatrix = CMatrix4f::FromGlmMat4(glm::lookAt(glmpos, glmpos + glmdir, glmup)).Transpose();
mViewDirty = false;
}

39
src/Core/Render/CCamera.h
View File

@@ -63,29 +63,28 @@ public:
void LoadMatrices() const;
void SetMoveMode(ECameraMoveMode Mode);
void SetOrbit(const CVector3f& OrbitTarget, float Distance);
void SetOrbit(const CAABox& OrbitTarget, float DistScale = 4.f);
void SetOrbit(const CVector3f& rkOrbitTarget, float Distance);
void SetOrbit(const CAABox& rkOrbitTarget, float DistScale = 4.f);
void SetOrbitDistance(float Distance);
// Getters
CVector3f Position() const;
CVector3f Direction() const;
CVector3f UpVector() const;
CVector3f RightVector() const;
float Yaw() const;
float Pitch() const;
float FieldOfView() const;
ECameraMoveMode MoveMode() const;
const CMatrix4f& ViewMatrix() const;
const CMatrix4f& ProjectionMatrix() const;
const CFrustumPlanes& FrustumPlanes() const;
// Inline Accessors
inline CVector3f Position() const { UpdateTransform(); return mPosition; }
inline CVector3f Direction() const { UpdateTransform(); return mDirection; }
inline CVector3f UpVector() const { UpdateTransform(); return mUpVector; }
inline CVector3f RightVector() const { UpdateTransform(); return mRightVector; }
inline float Yaw() const { return mYaw; }
inline float Pitch() const { return mPitch; }
inline float FieldOfView() const { return 55.f; }
inline ECameraMoveMode MoveMode() const { return mMode; }
inline const CMatrix4f& ViewMatrix() const { UpdateView(); return mViewMatrix; }
inline const CMatrix4f& ProjectionMatrix() const { UpdateProjection(); return mProjectionMatrix; }
inline const CFrustumPlanes& FrustumPlanes() const { UpdateFrustum(); return mFrustumPlanes; }
// Setters
void SetYaw(float Yaw);
void SetPitch(float Pitch);
void SetMoveSpeed(float MoveSpeed);
void SetLookSpeed(float LookSpeed);
void SetAspectRatio(float AspectRatio);
inline void SetYaw(float Yaw) { mYaw = Yaw; mTransformDirty = true; }
inline void SetPitch(float Pitch) { mPitch = Pitch; ValidatePitch(); mTransformDirty = true; }
inline void SetMoveSpeed(float MoveSpeed) { mMoveSpeed = MoveSpeed; }
inline void SetLookSpeed(float LookSpeed) { mLookSpeed = LookSpeed; }
inline void SetAspectRatio(float AspectRatio) { mAspectRatio = AspectRatio; mProjectionDirty = true; mFrustumPlanesDirty = true; }
// Private
private:

26
src/Core/Render/CDrawUtil.cpp
View File

@@ -67,7 +67,7 @@ void CDrawUtil::DrawSquare()
{
// Overload with default tex coords
CVector2f TexCoords[4] = { CVector2f(0.f, 1.f), CVector2f(1.f, 1.f), CVector2f(1.f, 0.f), CVector2f(0.f, 0.f) };
DrawSquare(&TexCoords[0].x);
DrawSquare(&TexCoords[0].X);
}
void CDrawUtil::DrawSquare(const CVector2f& TexUL, const CVector2f& TexUR, const CVector2f& TexBR, const CVector2f& TexBL)
@@ -75,7 +75,7 @@ void CDrawUtil::DrawSquare(const CVector2f& TexUL, const CVector2f& TexUR, const
// Overload with tex coords specified via parameters
// I don't think that parameters are guaranteed to be contiguous in memory, so:
CVector2f TexCoords[4] = { TexUL, TexUR, TexBR, TexBL };
DrawSquare(&TexCoords[0].x);
DrawSquare(&TexCoords[0].X);
}
void CDrawUtil::DrawSquare(const float *pTexCoords)
@@ -103,7 +103,7 @@ void CDrawUtil::DrawLine(const CVector3f& PointA, const CVector3f& PointB)
void CDrawUtil::DrawLine(const CVector2f& PointA, const CVector2f& PointB)
{
// Overload for 2D lines
DrawLine(CVector3f(PointA.x, PointA.y, 0.f), CVector3f(PointB.x, PointB.y, 0.f), CColor::skWhite);
DrawLine(CVector3f(PointA.X, PointA.Y, 0.f), CVector3f(PointB.X, PointB.Y, 0.f), CColor::skWhite);
}
void CDrawUtil::DrawLine(const CVector3f& PointA, const CVector3f& PointB, const CColor& LineColor)
@@ -124,7 +124,7 @@ void CDrawUtil::DrawLine(const CVector3f& PointA, const CVector3f& PointB, const
void CDrawUtil::DrawLine(const CVector2f& PointA, const CVector2f& PointB, const CColor& LineColor)
{
// Overload for 2D lines
DrawLine(CVector3f(PointA.x, PointA.y, 0.f), CVector3f(PointB.x, PointB.y, 0.f), LineColor);
DrawLine(CVector3f(PointA.X, PointA.Y, 0.f), CVector3f(PointB.X, PointB.Y, 0.f), LineColor);
}
void CDrawUtil::DrawCube()
@@ -230,10 +230,10 @@ void CDrawUtil::DrawBillboard(CTexture* pTexture, const CVector3f& Position, con
mpBillboardShader->SetCurrent();
GLuint ScaleLoc = mpBillboardShader->GetUniformLocation("BillboardScale");
glUniform2f(ScaleLoc, Scale.x, Scale.y);
glUniform2f(ScaleLoc, Scale.X, Scale.Y);
GLuint TintLoc = mpBillboardShader->GetUniformLocation("TintColor");
glUniform4f(TintLoc, Tint.r, Tint.g, Tint.b, Tint.a);
glUniform4f(TintLoc, Tint.R, Tint.G, Tint.B, Tint.A);
pTexture->Bind(0);
@@ -259,13 +259,13 @@ void CDrawUtil::DrawLightBillboard(ELightType Type, const CColor& LightColor, co
mpLightBillboardShader->SetCurrent();
GLuint ScaleLoc = mpLightBillboardShader->GetUniformLocation("BillboardScale");
glUniform2f(ScaleLoc, Scale.x, Scale.y);
glUniform2f(ScaleLoc, Scale.X, Scale.Y);
GLuint ColorLoc = mpLightBillboardShader->GetUniformLocation("LightColor");
glUniform4f(ColorLoc, LightColor.r, LightColor.g, LightColor.b, LightColor.a);
glUniform4f(ColorLoc, LightColor.R, LightColor.G, LightColor.B, LightColor.A);
GLuint TintLoc = mpLightBillboardShader->GetUniformLocation("TintColor");
glUniform4f(TintLoc, Tint.r, Tint.g, Tint.b, Tint.a);
glUniform4f(TintLoc, Tint.R, Tint.G, Tint.B, Tint.A);
CTexture *pTexA = GetLightTexture(Type);
CTexture *pTexB = GetLightMask(Type);
@@ -294,7 +294,7 @@ void CDrawUtil::UseColorShader(const CColor& kColor)
mpColorShader->SetCurrent();
GLuint ColorLoc = mpColorShader->GetUniformLocation("ColorIn");
glUniform4f(ColorLoc, kColor.r, kColor.g, kColor.b, kColor.a);
glUniform4f(ColorLoc, kColor.R, kColor.G, kColor.B, kColor.A);
CMaterial::KillCachedMaterial();
}
@@ -308,7 +308,7 @@ void CDrawUtil::UseColorShaderLighting(const CColor& kColor)
glUniform1i(NumLightsLoc, CGraphics::sNumLights);
GLuint ColorLoc = mpColorShaderLighting->GetUniformLocation("ColorIn");
glUniform4f(ColorLoc, kColor.r, kColor.g, kColor.b, kColor.a);
glUniform4f(ColorLoc, kColor.R, kColor.G, kColor.B, kColor.A);
CMaterial::KillCachedMaterial();
}
@@ -324,7 +324,7 @@ void CDrawUtil::UseTextureShader(const CColor& TintColor)
mpTextureShader->SetCurrent();
GLuint TintColorLoc = mpTextureShader->GetUniformLocation("TintColor");
glUniform4f(TintColorLoc, TintColor.r, TintColor.g, TintColor.b, TintColor.a);
glUniform4f(TintColorLoc, TintColor.R, TintColor.G, TintColor.B, TintColor.A);
CMaterial::KillCachedMaterial();
}
@@ -336,7 +336,7 @@ void CDrawUtil::UseCollisionShader(const CColor& TintColor /*= CColor::skWhite*/
LoadCheckerboardTexture(0);
GLuint TintColorLoc = mpCollisionShader->GetUniformLocation("TintColor");
glUniform4f(TintColorLoc, TintColor.r, TintColor.g, TintColor.b, TintColor.a);
glUniform4f(TintColorLoc, TintColor.R, TintColor.G, TintColor.B, TintColor.A);
CMaterial::KillCachedMaterial();
}

99
src/Core/Render/CRenderBucket.cpp
View File

@@ -4,65 +4,54 @@
#include "CRenderer.h"
#include <algorithm>
CRenderBucket::CRenderBucket()
{
mEstSize = 0;
mSize = 0;
}
void CRenderBucket::SetSortType(ESortType Type)
{
mSortType = Type;
}
void CRenderBucket::Add(const SRenderablePtr& ptr)
void CRenderBucket::Add(const SRenderablePtr& rkPtr)
{
if (mSize >= mEstSize)
mRenderables.push_back(ptr);
mRenderables.push_back(rkPtr);
else
mRenderables[mSize] = ptr;
mRenderables[mSize] = rkPtr;
mSize++;
}
void CRenderBucket::Sort(CCamera* pCamera)
{
struct {
CCamera *pCamera;
bool operator()(SRenderablePtr left, SRenderablePtr right) {
CVector3f cPos = pCamera->Position();
CVector3f cDir = pCamera->Direction();
CVector3f distL = left.AABox.ClosestPointAlongVector(cDir) - cPos;
float dotL = distL.Dot(cDir);
CVector3f distR = right.AABox.ClosestPointAlongVector(cDir) - cPos;
float dotR = distR.Dot(cDir);
return (dotL > dotR);
}
} backToFront;
backToFront.pCamera = pCamera;
if (mSortType == BackToFront)
std::stable_sort(mRenderables.begin(), mRenderables.begin() + mSize, backToFront);
// Test: draw node bounding boxes + vertices used for sorting
/*for (u32 iNode = 0; iNode < mNodes.size(); iNode++)
if (mEnableDepthSort)
{
SMeshPointer *pNode = &mNodes[iNode];
CVector3f Vert = pNode->AABox.ClosestPointAlongVector(Camera.GetDirection());
CDrawUtil::DrawWireCube(pNode->AABox, CColor::skWhite);
std::stable_sort(mRenderables.begin(), mRenderables.begin() + mSize,
[&, pCamera](const SRenderablePtr& rkLeft, const SRenderablePtr& rkRight) -> bool
{
CVector3f CamPos = pCamera->Position();
CVector3f CamDir = pCamera->Direction();
CVector3f Dist = Vert - Camera.GetPosition();
float Dot = Dist.Dot(Camera.GetDirection());
if (Dot < 0.f) Dot = -Dot;
if (Dot > 50.f) Dot = 50.f;
float Intensity = 1.f - (Dot / 50.f);
CColor CubeColor(Intensity, Intensity, Intensity, 1.f);
CVector3f DistL = rkLeft.AABox.ClosestPointAlongVector(CamDir) - CamPos;
CVector3f DistR = rkRight.AABox.ClosestPointAlongVector(CamDir) - CamPos;
float DotL = DistL.Dot(CamDir);
float DotR = DistR.Dot(CamDir);
return (DotL > DotR);
});
CGraphics::sMVPBlock.ModelMatrix = CTransform4f::TranslationMatrix(Vert).ToMatrix4f();
CGraphics::UpdateMVPBlock();
CDrawUtil::DrawCube(CubeColor);
}*/
if (mEnableDepthSortDebugVisualization)
{
for (u32 iPtr = 0; iPtr < mSize; iPtr++)
{
SRenderablePtr *pPtr = &mRenderables[iPtr];
CVector3f Point = pPtr->AABox.ClosestPointAlongVector(pCamera->Direction());
CDrawUtil::DrawWireCube(pPtr->AABox, CColor::skWhite);
CVector3f Dist = Point - pCamera->Position();
float Dot = Dist.Dot(pCamera->Direction());
if (Dot < 0.f) Dot = -Dot;
if (Dot > 50.f) Dot = 50.f;
float Intensity = 1.f - (Dot / 50.f);
CColor CubeColor(Intensity, Intensity, Intensity, 1.f);
CGraphics::sMVPBlock.ModelMatrix = CTransform4f::TranslationMatrix(Point).ToMatrix4f();
CGraphics::UpdateMVPBlock();
CDrawUtil::DrawCube(CubeColor);
}
}
}
}
void CRenderBucket::Clear()
@@ -72,18 +61,16 @@ void CRenderBucket::Clear()
mSize = 0;
}
void CRenderBucket::Draw(const SViewInfo& ViewInfo)
void CRenderBucket::Draw(const SViewInfo& rkViewInfo)
{
FRenderOptions Options = ViewInfo.pRenderer->RenderOptions();
FRenderOptions Options = rkViewInfo.pRenderer->RenderOptions();
for (u32 n = 0; n < mSize; n++)
for (u32 iPtr = 0; iPtr < mSize; iPtr++)
{
if (mRenderables[n].Command == eDrawMesh)
mRenderables[n].pRenderable->Draw(Options, mRenderables[n].ComponentIndex, ViewInfo);
if (mRenderables[iPtr].Command == eDrawMesh)
mRenderables[iPtr].pRenderable->Draw(Options, mRenderables[iPtr].ComponentIndex, rkViewInfo);
else if (mRenderables[n].Command == eDrawSelection)
mRenderables[n].pRenderable->DrawSelection();
// todo: implementation for eDrawExtras
else if (mRenderables[iPtr].Command == eDrawSelection)
mRenderables[iPtr].pRenderable->DrawSelection();
}
}

31
src/Core/Render/CRenderBucket.h
View File

@@ -2,32 +2,39 @@
#define CRENDERBUCKET_H
#include "CCamera.h"
#include "CDrawUtil.h"
#include "CGraphics.h"
#include "FRenderOptions.h"
#include "SRenderablePtr.h"
#include <Common/types.h>
#include <algorithm>
#include <vector>
class CRenderBucket
{
public:
enum ESortType
{
BackToFront,
FrontToBack
};
private:
ESortType mSortType;
bool mEnableDepthSort;
bool mEnableDepthSortDebugVisualization;
std::vector<SRenderablePtr> mRenderables;
u32 mEstSize;
u32 mSize;
public:
CRenderBucket();
void SetSortType(ESortType Type);
void Add(const SRenderablePtr& ptr);
CRenderBucket()
: mEnableDepthSort(false)
, mEnableDepthSortDebugVisualization(false)
, mEstSize(0)
, mSize(0)
{}
inline void SetDepthSortingEnabled(bool Enabled)
{
mEnableDepthSort = Enabled;
}
void Add(const SRenderablePtr& rkPtr);
void Sort(CCamera* pCamera);
void Clear();
void Draw(const SViewInfo& ViewInfo);
void Draw(const SViewInfo& rkViewInfo);
};
#endif // CRENDERBUCKET_H

96
src/Core/Render/CRenderer.cpp
View File

@@ -5,7 +5,6 @@
#include "Core/Resource/CResCache.h"
#include "Core/Resource/Factory/CTextureDecoder.h"
#include <Math/CTransform4f.h>
#include <Common/AnimUtil.h>
#include <algorithm>
#include <iostream>
@@ -19,14 +18,13 @@ u32 CRenderer::sNumRenderers = 0;
// ************ INITIALIZATION ************
CRenderer::CRenderer()
: mOptions(eEnableUVScroll | eEnableBackfaceCull)
, mBloomMode(eNoBloom)
, mDrawGrid(true)
, mInitialized(false)
, mContextIndex(-1)
{
mOptions = eEnableUVScroll | eEnableBackfaceCull;
mBloomMode = eNoBloom;
mDrawGrid = true;
mInitialized = false;
mContextIndex = -1;
mOpaqueBucket.SetSortType(CRenderBucket::FrontToBack);
mTransparentBucket.SetSortType(CRenderBucket::BackToFront);
mTransparentBucket.SetDepthSortingEnabled(true);
sNumRenderers++;
}
@@ -45,45 +43,45 @@ void CRenderer::Init()
{
if (!mInitialized)
{
glClearColor(mClearColor.r, mClearColor.g, mClearColor.b, mClearColor.a);
glClearColor(mClearColor.R, mClearColor.G, mClearColor.B, mClearColor.A);
mContextIndex = CGraphics::GetContextIndex();
mInitialized = true;
}
}
// ************ GETTERS/SETTERS ************
// ************ ACCESSORS ************
FRenderOptions CRenderer::RenderOptions() const
{
return mOptions;
}
void CRenderer::ToggleBackfaceCull(bool b)
void CRenderer::ToggleBackfaceCull(bool Enable)
{
if (b) mOptions |= eEnableBackfaceCull;
else mOptions &= ~eEnableBackfaceCull;
if (Enable) mOptions |= eEnableBackfaceCull;
else mOptions &= ~eEnableBackfaceCull;
}
void CRenderer::ToggleUVAnimation(bool b)
void CRenderer::ToggleUVAnimation(bool Enable)
{
if (b) mOptions |= eEnableUVScroll;
else mOptions &= ~eEnableUVScroll;
if (Enable) mOptions |= eEnableUVScroll;
else mOptions &= ~eEnableUVScroll;
}
void CRenderer::ToggleGrid(bool b)
void CRenderer::ToggleGrid(bool Enable)
{
mDrawGrid = b;
mDrawGrid = Enable;
}
void CRenderer::ToggleOccluders(bool b)
void CRenderer::ToggleOccluders(bool Enable)
{
if (b) mOptions |= eEnableOccluders;
else mOptions &= ~eEnableOccluders;
if (Enable) mOptions |= eEnableOccluders;
else mOptions &= ~eEnableOccluders;
}
void CRenderer::ToggleAlphaDisabled(bool b)
void CRenderer::ToggleAlphaDisabled(bool Enable)
{
if (b) mOptions |= eNoAlpha;
else mOptions &= ~eNoAlpha;
if (Enable) mOptions |= eNoAlpha;
else mOptions &= ~eNoAlpha;
}
void CRenderer::SetBloom(EBloomMode BloomMode)
@@ -96,11 +94,11 @@ void CRenderer::SetBloom(EBloomMode BloomMode)
mOptions &= ~eEnableBloom;
}
void CRenderer::SetClearColor(const CColor& Clear)
void CRenderer::SetClearColor(const CColor& rkClear)
{
mClearColor = Clear;
mClearColor.a = 0.f;
glClearColor(mClearColor.r, mClearColor.g, mClearColor.b, mClearColor.a);
mClearColor = rkClear;
mClearColor.A = 0.f;
glClearColor(mClearColor.R, mClearColor.G, mClearColor.B, mClearColor.A);
}
void CRenderer::SetViewportSize(u32 Width, u32 Height)
@@ -116,7 +114,7 @@ void CRenderer::SetViewportSize(u32 Width, u32 Height)
}
// ************ RENDER ************
void CRenderer::RenderBuckets(const SViewInfo& ViewInfo)
void CRenderer::RenderBuckets(const SViewInfo& rkViewInfo)
{
if (!mInitialized) Init();
mSceneFramebuffer.Bind();
@@ -129,10 +127,10 @@ void CRenderer::RenderBuckets(const SViewInfo& ViewInfo)
glDepthRange(0.f, 1.f);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
mOpaqueBucket.Draw(ViewInfo);
mOpaqueBucket.Draw(rkViewInfo);
mOpaqueBucket.Clear();
mTransparentBucket.Sort(ViewInfo.pCamera);
mTransparentBucket.Draw(ViewInfo);
mTransparentBucket.Sort(rkViewInfo.pCamera);
mTransparentBucket.Draw(rkViewInfo);
mTransparentBucket.Clear();
}
@@ -244,7 +242,7 @@ void CRenderer::RenderBloom()
glEnable(GL_DEPTH_TEST);
}
void CRenderer::RenderSky(CModel *pSkyboxModel, const SViewInfo& ViewInfo)
void CRenderer::RenderSky(CModel *pSkyboxModel, const SViewInfo& rkViewInfo)
{
if (!mInitialized) Init();
if (!pSkyboxModel) return;
@@ -261,31 +259,31 @@ void CRenderer::RenderSky(CModel *pSkyboxModel, const SViewInfo& ViewInfo)
CGraphics::UpdateLightBlock();
// Load rotation-only view matrix
CGraphics::sMVPBlock.ViewMatrix = ViewInfo.RotationOnlyViewMatrix;
CGraphics::sMVPBlock.ViewMatrix = rkViewInfo.RotationOnlyViewMatrix;
CGraphics::UpdateMVPBlock();
glDepthRange(1.f, 1.f);
pSkyboxModel->Draw(mOptions, 0);
}
void CRenderer::AddOpaqueMesh(IRenderable *pRenderable, int AssetID, CAABox& AABox, ERenderCommand Command)
void CRenderer::AddOpaqueMesh(IRenderable *pRenderable, int AssetID, const CAABox& rkAABox, ERenderCommand Command)
{
SRenderablePtr ptr;
ptr.pRenderable = pRenderable;
ptr.ComponentIndex = AssetID;
ptr.AABox = AABox;
ptr.Command = Command;
mOpaqueBucket.Add(ptr);
SRenderablePtr Ptr;
Ptr.pRenderable = pRenderable;
Ptr.ComponentIndex = AssetID;
Ptr.AABox = rkAABox;
Ptr.Command = Command;
mOpaqueBucket.Add(Ptr);
}
void CRenderer::AddTransparentMesh(IRenderable *pRenderable, int AssetID, CAABox& AABox, ERenderCommand Command)
void CRenderer::AddTransparentMesh(IRenderable *pRenderable, int AssetID, const CAABox& rkAABox, ERenderCommand Command)
{
SRenderablePtr ptr;
ptr.pRenderable = pRenderable;
ptr.ComponentIndex = AssetID;
ptr.AABox = AABox;
ptr.Command = Command;
mTransparentBucket.Add(ptr);
SRenderablePtr Ptr;
Ptr.pRenderable = pRenderable;
Ptr.ComponentIndex = AssetID;
Ptr.AABox = rkAABox;
Ptr.Command = Command;
mTransparentBucket.Add(Ptr);
}
void CRenderer::BeginFrame()
@@ -334,7 +332,7 @@ void CRenderer::ClearDepthBuffer()
// ************ PRIVATE ************
void CRenderer::InitFramebuffer()
{
glClearColor(mClearColor.r, mClearColor.g, mClearColor.b, mClearColor.a);
glClearColor(mClearColor.R, mClearColor.G, mClearColor.B, mClearColor.A);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

22
src/Core/Render/CRenderer.h
View File

@@ -53,23 +53,23 @@ public:
~CRenderer();
void Init();
// Getters/Setters
// Accessors
FRenderOptions RenderOptions() const;
void ToggleBackfaceCull(bool b);
void ToggleUVAnimation(bool b);
void ToggleGrid(bool b);
void ToggleOccluders(bool b);
void ToggleAlphaDisabled(bool b);
void ToggleBackfaceCull(bool Enable);
void ToggleUVAnimation(bool Enable);
void ToggleGrid(bool Enable);
void ToggleOccluders(bool Enable);
void ToggleAlphaDisabled(bool Enable);
void SetBloom(EBloomMode BloomMode);
void SetClearColor(const CColor& Clear);
void SetClearColor(const CColor& rkClear);
void SetViewportSize(u32 Width, u32 Height);
// Render
void RenderBuckets(const SViewInfo& ViewInfo);
void RenderBuckets(const SViewInfo& rkViewInfo);
void RenderBloom();
void RenderSky(CModel *pSkyboxModel, const SViewInfo& ViewInfo);
void AddOpaqueMesh(IRenderable *pRenderable, int AssetID, CAABox& AABox, ERenderCommand Command);
void AddTransparentMesh(IRenderable *pRenderable, int AssetID, CAABox& AABox, ERenderCommand Command);
void RenderSky(CModel *pSkyboxModel, const SViewInfo& rkViewInfo);
void AddOpaqueMesh(IRenderable *pRenderable, int AssetID, const CAABox& rkAABox, ERenderCommand Command);
void AddTransparentMesh(IRenderable *pRenderable, int AssetID, const CAABox& rkAABox, ERenderCommand Command);
void BeginFrame();
void EndFrame();
void ClearDepthBuffer();

4
src/Core/Render/IRenderable.h
View File

@@ -12,8 +12,8 @@ class IRenderable
public:
IRenderable() {}
virtual ~IRenderable() {}
virtual void AddToRenderer(CRenderer* pRenderer, const SViewInfo& ViewInfo) = 0;
virtual void Draw(FRenderOptions /*Options*/, int /*ComponentIndex*/, const SViewInfo& /*ViewInfo*/) {}
virtual void AddToRenderer(CRenderer* pRenderer, const SViewInfo& rkViewInfo) = 0;
virtual void Draw(FRenderOptions /*Options*/, int /*ComponentIndex*/, const SViewInfo& /*rkViewInfo*/) {}
virtual void DrawSelection() {}
};

3
src/Core/Render/SRenderablePtr.h
View File

@@ -2,8 +2,7 @@
#define SRENDERABLEPTR_H
#include "ERenderCommand.h"
#include "Core/Resource/CMaterial.h"
#include "Core/Scene/CSceneNode.h"
#include "IRenderable.h"
#include <Common/types.h>
#include <Math/CAABox.h>