celisej567/Nuake-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactoring scene rendering

Browse Source
This commit is contained in:
antopilo
2021-09-20 06:49:45 -04:00
parent 519d9165e1
commit 4d1e134eaa
44 changed files with 604 additions and 826 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Editor/Editor.cpp
View File

@@ -55,8 +55,8 @@ int main()
// Register Gizmo textures
Ref<Nuake::Texture> lightTexture = Nuake::TextureManager::Get()->GetTexture("resources/Icons/Gizmo/Light.png");
Ref<Nuake::Texture> camTexture = Nuake::TextureManager::Get()->GetTexture("resources/Icons/Gizmo/Camera.png");
Ref<Nuake::Shader> GuizmoShader = Nuake::ShaderManager::GetShader("resources/Shaders/gizmo.shader");
Ref<Nuake::Shader> ditherShader = Nuake::ShaderManager::GetShader("resources/Shaders/dither.shader");
Nuake::Shader* GuizmoShader = Nuake::ShaderManager::GetShader("resources/Shaders/gizmo.shader");
Nuake::Shader* ditherShader = Nuake::ShaderManager::GetShader("resources/Shaders/dither.shader");
//Nuake::NewEditor newEditor = Nuake::NewEditor();

2
Editor/resources/Scripts/Math.wren
View File

@@ -107,7 +107,7 @@ class Vector3 {
}
Normalize() {
var length = this.Sqrt()
var length = this.Length()
var x = _x / length
var y = _y / length
var z = _z / length

10
Editor/resources/Shaders/atmospheric_sky.shader
View File

@@ -136,8 +136,8 @@ vec3 scatter(vec3 o, vec3 d, float L, vec3 Lo) {
return vec3(1.0);
}
uniform mat4 InvProjection;
uniform mat4 InvView;
uniform mat4 Projection;
uniform mat4 View;
void main()
{
// Might add camera position in here.
@@ -145,7 +145,7 @@ void main()
vec2 NDC = UV * 2.0 - 1;
vec4 camSpace = inverse(InvProjection * InvView) * vec4(vec3(NDC, 1.0), 1.0);
vec4 camSpace = inverse(Projection * View) * vec4(vec3(NDC, 1.0), 1.0);
vec3 direction = normalize(camSpace.xyz);
vec3 D = direction;
@@ -153,9 +153,5 @@ void main()
vec3 col = vec3(1.0);
float L = escape(O, D, AtmosphereRadius);
col = scatter(O, D, L, col);
col = col / (col + vec3(1.0));
// gamma correct
col = pow(col, vec3(1.0 / u_Exposure));
FragColor = vec4(col, 1.);
}

4
Editor/resources/Shaders/bloom.shader
View File

@@ -151,9 +151,9 @@ void main()
vec3 color = outputColor.rgb;
color = acesOperator(color);
//color = acesOperator(color);
color = color / (color + vec3(1.0));
color = color / (color + vec3(2.0));
color = vec3(1.0) - exp(-color * 1.0);
color = pow(color, vec3(1.0 / 2.2));

27
Editor/resources/Shaders/copy.shader Normal file
View File

@@ -0,0 +1,27 @@
#shader vertex
#version 460 core
layout(location = 0) in vec3 VertexPosition;
layout(location = 1) in vec2 UVPosition;
out flat vec2 UV;
void main()
{
UV = UVPosition;
gl_Position = vec4(VertexPosition, 1.0f);
}
#shader fragment
#version 460 core
uniform sampler2D u_Source;
in vec2 UV;
out vec4 FragColor;
void main()
{
FragColor = texture(u_Source, UV);
}

11
Editor/resources/Shaders/deferred.shader
View File

@@ -302,16 +302,7 @@ void main()
vec3 kD = 1.0 - kS;
kD *= 1.0 - metallic;
vec3 irradiance = mix(texture(u_IrradianceMap, N).rgb, vec3(0.1f), 0.9f);
vec3 diffuse = irradiance * albedo;
// sample both the pre-filter map and the BRDF lut and combine them together as per the Split-Sum approximation to get the IBL specular part.
const float MAX_REFLECTION_LOD = 4.0;
vec3 prefilteredColor = textureLod(u_PrefilterMap, R, roughness * MAX_REFLECTION_LOD).rgb;
vec2 brdf = texture(u_BrdfLUT, vec2(max(dot(N, V), 0.0), roughness)).rg;
vec3 specular = prefilteredColor * (F * brdf.x + brdf.y);
vec3 ambient = (kD * diffuse + specular) * ao;
vec3 ambient = (kD * albedo) * ao;
vec3 color = ambient + Lo;
color += fog;

27
Editor/src/EditorInterface.cpp
View File

@@ -22,6 +22,7 @@
#include "Dependencies/GLEW/include/GL/glew.h"
#include "src/Scene/Scene.h"
#include "src/Scene/Components/Components.h"
#include "src/Scene/Components/BoxCollider.h"
#include "src/Scene/Components/LuaScriptComponent.h"
@@ -70,12 +71,9 @@ namespace Nuake {
ImVec2 regionAvail = ImGui::GetContentRegionAvail();
Vector2 viewportPanelSize = glm::vec2(regionAvail.x, regionAvail.y);
Ref<FrameBuffer> framebuffer = Engine::GetCurrentWindow()->GetDeferredBuffer();
Ref<FrameBuffer> framebuffer = Engine::GetCurrentWindow()->GetFrameBuffer();
if (framebuffer->GetSize() != viewportPanelSize)
{
Engine::GetCurrentWindow()->GetGBuffer()->QueueResize(viewportPanelSize);
framebuffer->QueueResize(viewportPanelSize);
}
Ref<Texture> texture = framebuffer->GetTexture();
ImGui::Image((void*)texture->GetID(), regionAvail, ImVec2(0, 1), ImVec2(1, 0));
@@ -341,7 +339,7 @@ namespace Nuake {
if (ImGui::Begin("Environnement"))
{
Ref<Environment> env = Engine::GetCurrentScene()->GetEnvironment();
const Ref<Environment> env = Engine::GetCurrentScene()->GetEnvironment();
if (ImGui::CollapsingHeader("Procedural Sky", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::DragFloat("Sun Intensity", &env->ProceduralSkybox->SunIntensity, 0.1f, 0.0f);
@@ -356,16 +354,23 @@ namespace Nuake {
}
if (ImGui::CollapsingHeader("Bloom", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::DragFloat("Threshold", &env->BloomThreshold, 0.01f, 0.0f, 300.0f);
ImGui::DragFloat("Blur", &env->BloomBlurAmount, 0.01f, 0.0f, 300.0f);
float threshold = env->mBloom->GetThreshold();
ImGui::DragFloat("Threshold", &threshold, 0.01f, 0.0f, 500.0f);
env->mBloom->SetThreshold(threshold);
int iteration = env->mBloom->GetIteration();
ImGui::DragInt("Iteration", &iteration, 1.0f, 0, 8);
env->mBloom->SetIteration(iteration);
}
if (ImGui::CollapsingHeader("Fog", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::DragFloat("Volumetric Scattering", &env->VolumetricFog, .01f, 0.0f, 1.0f);
ImGui::DragFloat("Volumetric Step Count", &env->VolumetricStepCount, 1.f, 0.0f);
}
if (ImGui::CollapsingHeader("Camera", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::DragFloat("Exposure", &Engine::GetCurrentScene()->m_EditorCamera->Exposure, .01f, 0.0f, 5.0f);
}
}
ImGui::End();
@@ -1515,10 +1520,6 @@ namespace Nuake {
}
if (ImGui::BeginMenu("View"))
{
if (ImGui::MenuItem("Reload Interfaces", NULL))
{
Engine::GetCurrentScene()->ReloadInterfaces();
}
if (ImGui::MenuItem("Lighting", NULL, true)) {}
if (ImGui::MenuItem("Draw grid", NULL, m_DrawGrid))
m_DrawGrid = !m_DrawGrid;

18
Nuake/Engine.cpp
View File

@@ -48,26 +48,22 @@ namespace Nuake
m_LastFrameTime = m_Time;
// Dont update if no scene is loaded.
if (CurrentWindow->GetScene())
{
if (CurrentWindow->GetScene()) {
CurrentWindow->Update(timestep);
// Play mode update all the entities, Editor does not.
if (Engine::IsPlayMode)
{
if (Engine::IsPlayMode) {
m_FixedUpdateDifference += timestep;
// Fixed update
if (m_FixedUpdateDifference >= m_FixedUpdateRate)
{
CurrentWindow->FixedUpdate(m_FixedUpdateRate);
m_FixedUpdateDifference = 0.f;
if (m_FixedUpdateDifference >= m_FixedUpdateRate) {
CurrentWindow->FixedUpdate(m_FixedUpdateDifference);
m_FixedUpdateDifference -= m_FixedUpdateRate;
}
}
else
{
GetCurrentScene()->EditorUpdate(timestep);
}
}
Input::Update();

13
Nuake/src/Core/Core.h
View File

@@ -4,14 +4,23 @@
#include <string>
#include <vector>
template<typename T>
using Scope = std::unique_ptr<T>;
#define ASSERT(x) if (!(x)) assert(false)
template<typename T>
using Ref = std::shared_ptr<T>;
template<typename T>
using Scope = std::unique_ptr<T>;
template<typename T, typename ... Args>
constexpr Ref<T> CreateRef(Args&& ... args)
{
return std::make_shared<T>(std::forward<Args>(args)...);
}
template<typename T, typename ... Args>
constexpr Scope<T> CreateScope(Args&& ... args)
{
return std::make_unique<T>(std::forward<Args>(args)...);
}

4
Nuake/src/Core/Maths.h
View File

@@ -5,13 +5,13 @@
#include <src/Vendors/glm/ext/vector_float2.hpp>
#include <src/Vendors/glm/ext/matrix_float4x4.hpp>
namespace Nuake
{
// Type definitions
using Vector3 = glm::vec3;
using Vector2 = glm::vec2;
using Vector4 = glm::vec4;
using Color = glm::vec4;
using Matrix4 = glm::mat4;
using Matrix3 = glm::mat3;
}

2
Nuake/src/Core/Physics/DynamicWorld.cpp
View File

@@ -96,7 +96,7 @@ namespace Nuake
void DynamicWorld::StepSimulation(Timestep ts)
{
dynamicsWorld->stepSimulation(ts, 10);
dynamicsWorld->stepSimulation(ts);
for (int j = dynamicsWorld->getNumCollisionObjects() - 1; j >= 0; j--)
{
btCollisionObject* obj = dynamicsWorld->getCollisionObjectArray()[j];

3
Nuake/src/Rendering/Buffers/Framebuffer.cpp
View File

@@ -84,6 +84,9 @@ namespace Nuake
void FrameBuffer::QueueResize(Vector2 size)
{
if (size == m_Size)
return;
ResizeQueued = true;
m_Size = size;
}

2
Nuake/src/Rendering/Mesh/Mesh.cpp
View File

@@ -55,7 +55,7 @@ namespace Nuake
m_VertexArray->Unbind();
}
void Mesh::Draw(Ref<Shader> shader, bool bindMaterial)
void Mesh::Draw(Shader* shader, bool bindMaterial)
{
if (bindMaterial)
m_Material->Bind(shader);

2
Nuake/src/Rendering/Mesh/Mesh.h
View File

@@ -21,7 +21,7 @@ namespace Nuake
Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, Ref<Material> material);
void Draw(Ref<Shader> shader, bool bindMaterial = true);
void Draw(Shader* shader, bool bindMaterial = true);
void DebugDraw();
inline AABB GetAABB() const { return m_AABB; }

12
Nuake/src/Rendering/Platforms/OGLRendererAPI.cpp
View File

@@ -2,6 +2,16 @@
#include "GL/glew.h"
namespace Nuake {
void OGLRendererAPI::Enable(const RendererEnum enumType)
{
glEnable(GetType(enumType));
}
void OGLRendererAPI::Disable(const RendererEnum enumType)
{
glDisable(GetType(enumType));
}
void OGLRendererAPI::Clear()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -86,6 +96,8 @@ namespace Nuake {
case RendererEnum::INT: return GL_INT;
case RendererEnum::UINT: return GL_UNSIGNED_INT;
case RendererEnum::TRIANGLES: return GL_TRIANGLES;
case RendererEnum::DEPTH_TEST: return GL_DEPTH_TEST;
case RendererEnum::FACE_CULL: return GL_CULL_FACE;
}
return 0;

3
Nuake/src/Rendering/Platforms/OGLRendererAPI.h
View File

@@ -8,6 +8,9 @@ namespace Nuake {
public:
OGLRendererAPI() {};
void Enable(const RendererEnum enumType) override;
void Disable(const RendererEnum enumType) override;
void Clear() override;
void SetClearColor(const Color& color) override;

6
Nuake/src/Rendering/Platforms/RendererAPI.h
View File

@@ -8,7 +8,8 @@ namespace Nuake {
ARRAY_BUFFER,
ELEMENT_ARRAY_BUFFER,
TRIANGLES,
DEPTH_ATTACHMENT, COLOR_ATTACHMENT0, COLOR_ATTACHMENT1
DEPTH_ATTACHMENT, COLOR_ATTACHMENT0, COLOR_ATTACHMENT1,
DEPTH_TEST, FACE_CULL
};
class RendererAPI
@@ -17,6 +18,9 @@ namespace Nuake {
virtual void Clear() = 0;
virtual void SetClearColor(const Color& color) = 0;
virtual void Enable(const RendererEnum enumType) = 0;
virtual void Disable(const RendererEnum enumType) = 0;
virtual void GenBuffer(unsigned int& bufferID) = 0;
virtual void BindBuffer(const RendererEnum bufferType, const unsigned int& bufferID) = 0;
virtual void SetBufferData(const RendererEnum bufferType, const void* data, unsigned int size) = 0;

57
Nuake/src/Rendering/PostFX/Bloom.cpp
View File

@@ -6,26 +6,38 @@
namespace Nuake
{
const float DownsamplingScale = 0.4f;
Bloom::Bloom(Ref<Texture> source, unsigned int iteration)
Bloom::Bloom(unsigned int iteration)
{
m_Iteration = iteration;
}
void Bloom::SetSource(Ref<Texture> source)
{
if (m_Source == source)
return;
m_Source = source;
m_Size = source->GetSize();
Init();
}
void Bloom::Init()
{
if (!m_Source)
return;
m_FinalFB = CreateRef<FrameBuffer>(false, Vector2(1920, 1080));
m_FinalFB->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGBA, GL_RGBA16F, GL_FLOAT));
m_FinalFB = CreateRef<FrameBuffer>(false, m_Size);
m_FinalFB->SetTexture(CreateRef<Texture>(m_Size, GL_RGBA, GL_RGBA16F, GL_FLOAT));
m_ThresholdFB = CreateRef<FrameBuffer>(false, m_Size);
m_ThresholdFB->SetTexture(CreateRef<Texture>(m_Size, GL_RGBA, GL_RGBA16F, GL_FLOAT));
m_ThresholdFB = CreateRef<FrameBuffer>(false, Vector2(1920, 1080));
m_ThresholdFB->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGBA, GL_RGBA16F, GL_FLOAT));
m_DownSampleFB = std::vector<Ref<FrameBuffer>>();
m_UpSampleFB = std::vector<Ref<FrameBuffer>>();
m_HBlurFB = std::vector<Ref<FrameBuffer>>();
m_VBlurFB = std::vector<Ref<FrameBuffer>>();
Vector2 originalTargetSize = Vector2(source->GetWidth(), source->GetHeight());
Vector2 currentSize = originalTargetSize;
Vector2 currentSize = m_Size / 2.0f;
for (int i = 0; i < m_Iteration; i++)
{
Ref<FrameBuffer> fb = CreateRef<FrameBuffer>(false, currentSize);
@@ -53,21 +65,20 @@ namespace Nuake
}
}
int downsampleMip = 0;
int upSampleMip = 0;
void Bloom::Draw()
{
Ref<Shader> shader = ShaderManager::GetShader("resources/Shaders/bloom.shader");
if (!m_Source) return;
Shader* shader = ShaderManager::GetShader("resources/Shaders/bloom.shader");
// Threshold
m_ThresholdFB->Bind();
{
m_ThresholdFB->Clear();
shader->Bind();
shader->SetUniform1i("u_Stage", 0);
shader->SetUniform1f("u_Threshold", Threshold);
shader->SetUniform1f("u_Threshold", m_Threshold);
m_Source->Bind(1);
shader->SetUniform1i("u_Source", 1);
@@ -82,13 +93,11 @@ namespace Nuake
shader->SetUniform1i("u_Stage", 1);
Ref<Texture> downsampleTexture = i == 0 ? m_ThresholdFB->GetTexture() : m_DownSampleFB[i - 1]->GetTexture();
downsampleTexture->Bind(1);
shader->SetUniform1i("u_Source", 1);
shader->SetUniformTex("u_Source", downsampleTexture.get(), 1);
Vector2 size = i == 0 ? downsampleTexture->GetSize() : m_DownSampleFB[i]->GetTexture()->GetSize();
shader->SetUniformVec2("u_SourceSize", size);
if(i == 0)
shader->SetUniform2f("u_SourceSize", downsampleTexture->GetWidth(), downsampleTexture->GetHeight());
else
shader->SetUniform2f("u_SourceSize", m_DownSampleFB[i]->GetTexture()->GetWidth(), m_DownSampleFB[i]->GetTexture()->GetHeight());
Renderer::DrawQuad(Matrix4());
m_DownSampleFB[i]->Unbind();
}
@@ -183,4 +192,12 @@ namespace Nuake
}
ImGui::End();
}
void Bloom::Resize(Vector2 size)
{
if (m_Size == size)
return;
m_Size = size;
Init();
}
}

57
Nuake/src/Rendering/PostFX/Bloom.h
View File

@@ -10,30 +10,55 @@
namespace Nuake {
class Bloom
{
public:
float Threshold = 0.3f;
float BlurAmount = 12.0f;
Bloom() {}
Bloom(Ref<Texture> source, unsigned int iteration = 4);
void Draw();
Ref<Texture> GetThreshold() const { return m_ThresholdFB->GetTexture(); }
const float MAX_THRESHOLD = 500.0f;
const float MIN_THRESHOLD = 0.0f;
const float MAX_BLUR = 50.0f;
const float MIN_BLUR = 0.0f;
const unsigned int MAX_ITERATION = 5;
const unsigned int MIN_ITERATION = 1;
private:
float m_Threshold = 0.3f;
float m_BlurAmount = 12.0f;
unsigned int m_Iteration;
Vector2 m_Size;
Ref<Texture> m_Source;
std::vector<Ref<Texture>> m_DownsampleMIP;
std::vector<Ref<Texture>> m_UpSampleMIP;
Ref<FrameBuffer> m_FinalFB;
Ref<Texture> m_Final;
Ref<FrameBuffer> m_ThresholdFB;
std::vector<Ref<FrameBuffer>> m_DownSampleFB;
std::vector<Ref<FrameBuffer>> m_HBlurFB;
std::vector<Ref<FrameBuffer>> m_VBlurFB;
std::vector<Ref<FrameBuffer>> m_UpSampleFB;
public:
Bloom() {}
Bloom(unsigned int iteration = 4);
void Init();
void Draw();
void Resize(Vector2 size);
inline float GetThreshold() const { return m_Threshold; }
void SetThreshold(float threshold)
{
if (threshold <= MAX_THRESHOLD && threshold >= MIN_THRESHOLD)
m_Threshold = threshold;
}
void SetIteration(unsigned int iteration)
{
if (iteration > MAX_ITERATION || iteration < MIN_ITERATION)
return;
m_Iteration = iteration;
Init();
};
inline unsigned int GetIteration() const { return m_Iteration; }
void SetSource(Ref<Texture> source);
Ref<Texture> GetOutput() const { return m_FinalFB->GetTexture(); }
};
}

10
Nuake/src/Rendering/RenderCommand.cpp
View File

@@ -19,6 +19,16 @@ namespace Nuake {
sRendererAPI->SetClearColor(color);
}
void RenderCommand::Enable(const RendererEnum enumType)
{
sRendererAPI->Enable(enumType);
}
void RenderCommand::Disable(const RendererEnum enumType)
{
sRendererAPI->Disable(enumType);
}
void RenderCommand::GenBuffer(unsigned int& bufferID)
{
sRendererAPI->GenBuffer(bufferID);

2
Nuake/src/Rendering/RenderCommand.h
View File

@@ -15,6 +15,8 @@ namespace Nuake {
static void Clear();
static void SetClearColor(const Color& color);
static void Enable(const RendererEnum enumType);
static void Disable(const RendererEnum enumType);
static void GenBuffer(unsigned int& bufferID);
static void BindBuffer(const RendererEnum bufferType, const unsigned int& bufferID);
static void SetBufferData(const RendererEnum bufferType, const void* data, unsigned int size);

2
Nuake/src/Rendering/RenderList.h
View File

@@ -30,7 +30,7 @@ namespace Nuake
m_RenderList[mesh->m_Material].push_back({mesh, transform});
}
void Flush(Ref<Shader> shader, bool depthOnly = false)
void Flush(Shader* shader, bool depthOnly = false)
{
shader->Bind();
for (auto& i : m_RenderList)

65
Nuake/src/Rendering/Renderer.cpp
View File

@@ -19,14 +19,14 @@ namespace Nuake
unsigned int depthTexture;
unsigned int depthFBO;
Ref<Shader> Renderer::m_Shader;
Ref<Shader> Renderer::m_SkyboxShader;
Ref<Shader> Renderer::m_BRDShader;
Ref<Shader> Renderer::m_GBufferShader;
Ref<Shader> Renderer::m_DeferredShader;
Ref<Shader> Renderer::m_ProceduralSkyShader;
Ref<Shader> Renderer::m_DebugShader;
Ref<Shader> Renderer::m_ShadowmapShader;
Shader* Renderer::m_Shader;
Shader* Renderer::m_SkyboxShader;
Shader* Renderer::m_BRDShader;
Shader* Renderer::m_GBufferShader;
Shader* Renderer::m_DeferredShader;
Shader* Renderer::m_ProceduralSkyShader;
Shader* Renderer::m_DebugShader;
Shader* Renderer::m_ShadowmapShader;
VertexArray* Renderer::QuadVertexArray;
VertexBuffer* Renderer::QuadVertexBuffer;
@@ -91,14 +91,6 @@ namespace Nuake
void Renderer::LoadShaders()
{
m_ShadowmapShader = ShaderManager::GetShader("resources/Shaders/shadowMap.shader");
m_SkyboxShader = ShaderManager::GetShader("resources/Shaders/skybox.shader");
m_BRDShader = ShaderManager::GetShader("resources/Shaders/BRD.shader");
m_GBufferShader = ShaderManager::GetShader("resources/Shaders/gbuffer.shader");
m_DeferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
m_ProceduralSkyShader = ShaderManager::GetShader("resources/Shaders/atmospheric_sky.shader");
m_DebugShader = ShaderManager::GetShader("resources/Shaders/debug.shader");
m_Shader = ShaderManager::GetShader("resources/Shaders/pbr.shader");
}
void Renderer::SubmitMesh(Ref<Mesh> mesh, Matrix4 transform)
@@ -106,7 +98,7 @@ namespace Nuake
m_RenderList.AddToRenderList(mesh, transform);
}
void Renderer::Flush(Ref<Shader> shader, bool depthOnly)
void Renderer::Flush(Shader* shader, bool depthOnly)
{
m_RenderList.Flush(shader, depthOnly);
}
@@ -127,49 +119,12 @@ namespace Nuake
// List of all lights queued to be used for rendering this frame.
std::vector<Light> Renderer::m_Lights;
void Renderer::RegisterLight(TransformComponent transform, LightComponent light)
{
if (m_Lights.size() == 20)
return;
m_Lights.push_back({ transform , light });
int idx = m_Lights.size();
Vector3 direction = light.GetDirection();
Vector3 pos = transform.GlobalTranslation;
Matrix4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
//light.m_Framebuffer->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(17);
if (light.CastShadows)
{
for (unsigned int i = 0; i < CSM_AMOUNT; i++)
{
light.m_Framebuffers[i]->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(17 + i);
m_Shader->SetUniform1i("Lights[" + std::to_string(idx - 1) + "].ShadowMaps[" + std::to_string(i) + "]", 17 + i);
m_Shader->SetUniform1f("Lights[" + std::to_string(idx - 1) + "].CascadeDepth[" + std::to_string(i) + "]", light.mCascadeSplitDepth[i]);
m_Shader->SetUniformMat4f("Lights[" + std::to_string(idx - 1) + "].LightTransforms[" + std::to_string(i) + "]", light.mViewProjections[i]);
}
}
m_Shader->SetUniform1i("LightCount", idx);
m_Shader->SetUniform1i("Lights[" + std::to_string(idx - 1) + "].Type", light.Type);
m_Shader->SetUniformMat4f("Lights[" + std::to_string(idx - 1) + "].LightTransform", light.GetProjection() * lightView);
m_Shader->SetUniform3f("Lights[" + std::to_string(idx - 1) + "].Position", transform.GlobalTranslation.x, transform.GlobalTranslation.y, transform.GlobalTranslation.z);
m_Shader->SetUniform3f("Lights[" + std::to_string(idx - 1) + "].Direction", direction.x, direction.y, direction.z);
m_Shader->SetUniform3f("Lights[" + std::to_string(idx - 1) + "].Color", light.Color.r * light.Strength, light.Color.g * light.Strength, light.Color.b * light.Strength);
m_Shader->SetUniform1i("Lights[" + std::to_string(idx - 1) + "].Volumetric", light.IsVolumetric);
}
void Renderer::RegisterDeferredLight(TransformComponent transform, LightComponent light)
{
if (m_Lights.size() == 20)
return;
Ref<Shader> deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
Shader* deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
deferredShader->Bind();
m_Lights.push_back({ transform , light });

20
Nuake/src/Rendering/Renderer.h
View File

@@ -43,14 +43,14 @@ namespace Nuake
static VertexArray* Renderer::CubeVertexArray;
static VertexBuffer* Renderer::CubeVertexBuffer;
static Ref<Shader> m_Shader;
static Ref<Shader> m_ShadowmapShader;
static Ref<Shader> m_SkyboxShader;
static Ref<Shader> m_BRDShader;
static Ref<Shader> m_GBufferShader;
static Ref<Shader> m_DeferredShader;
static Ref<Shader> m_ProceduralSkyShader;
static Ref<Shader> m_DebugShader;
static Shader* m_Shader;
static Shader* m_ShadowmapShader;
static Shader* m_SkyboxShader;
static Shader* m_BRDShader;
static Shader* m_GBufferShader;
static Shader* m_DeferredShader;
static Shader* m_ProceduralSkyShader;
static Shader* m_DebugShader;
static Ref<UniformBuffer> m_LightsUniformBuffer;
@@ -59,7 +59,7 @@ namespace Nuake
static void BeginScene();
static void SubmitMesh(Ref<Mesh> mesh, Matrix4 transform);
static void Flush(Ref<Shader> shader, bool depthOnly = false);
static void Flush(Shader* shader, bool depthOnly = false);
// Drawing states
static void BeginDraw(Ref<Camera> camera);
@@ -76,6 +76,6 @@ namespace Nuake
static void DrawDebugLine(glm::vec3 start, glm::vec3 end, glm::vec4 color);
static void DrawCube(TransformComponent transform, glm::vec4 color);
static void DrawSphere(TransformComponent transform, glm::vec4 color);
static void DrawQuad(Matrix4 transform);
static void DrawQuad(Matrix4 transform = Matrix4());
};
}

4
Nuake/src/Rendering/Renderer2D.cpp
View File

@@ -7,8 +7,8 @@
#include "src/Vendors/glm/gtx/matrix_decompose.hpp"
namespace Nuake
{
Ref<Shader> Renderer2D::UIShader;
Ref<Shader> Renderer2D::TextShader;
Shader* Renderer2D::UIShader;
Shader* Renderer2D::TextShader;
unsigned int Renderer2D::VAO;
unsigned int Renderer2D::VBO;

4
Nuake/src/Rendering/Renderer2D.h
View File

@@ -13,8 +13,8 @@ namespace Nuake
static unsigned int VAO;
static unsigned int VBO;
public:
static Ref<Shader> UIShader;
static Ref<Shader> TextShader;
static Shader* UIShader;
static Shader* TextShader;
static Matrix4 Projection;
static void Init();

208
Nuake/src/Rendering/SceneRenderer.cpp Normal file
View File

@@ -0,0 +1,208 @@
#include "SceneRenderer.h"
#include "src/Rendering/Shaders/ShaderManager.h"
#include <src/Scene/Components/BSPBrushComponent.h>
#include <GL\glew.h>
namespace Nuake {
void SceneRenderer::Init()
{
mGBuffer = CreateScope<FrameBuffer>(false, Vector2(1920, 1080));
mGBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_DEPTH_COMPONENT), GL_DEPTH_ATTACHMENT);
mGBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT0);
mGBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT1);
mGBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT2);
mGBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT3);
mShadingBuffer = CreateScope<FrameBuffer>(true, Vector2(1920, 1080));
Ref<Texture> shadedTexture = CreateRef<Texture>(Vector2(1920, 1080), GL_RGB, GL_RGB16F, GL_FLOAT);
mShadingBuffer->SetTexture(shadedTexture);
mBloom = CreateScope<Bloom>(4);
mBloom->SetSource(shadedTexture);
}
void SceneRenderer::Cleanup()
{
}
void SceneRenderer::BeginRenderScene(const Matrix4& projection, const Matrix4& view)
{
mProjection = projection;
mView = view;
}
void SceneRenderer::RenderScene(Scene& scene, FrameBuffer& framebuffer)
{
ShadowPass(scene);
mGBuffer->QueueResize(framebuffer.GetSize());
GBufferPass(scene);
mShadingBuffer->QueueResize(framebuffer.GetSize());
ShadingPass(scene);
scene.GetEnvironment()->mBloom->SetSource(mShadingBuffer->GetTexture());
scene.GetEnvironment()->mBloom->Resize(framebuffer.GetSize());
scene.GetEnvironment()->mBloom->Draw();
// Copy final output to target framebuffer
framebuffer.Bind();
{
Shader* shader = ShaderManager::GetShader("resources/Shaders/copy.shader");
shader->Bind();
shader->SetUniformTex("u_Source", scene.GetEnvironment()->mBloom->GetOutput().get());
Renderer::DrawQuad();
}
framebuffer.Unbind();
RenderCommand::Enable(RendererEnum::DEPTH_TEST);
Renderer::EndDraw();
}
void SceneRenderer::ShadowPass(Scene& scene)
{
RenderCommand::Enable(RendererEnum::DEPTH_TEST);
Shader* shader = ShaderManager::GetShader("resources/Shaders/shadowMap.shader");
shader->Bind();
glCullFace(GL_BACK);
auto meshView = scene.m_Registry.view<TransformComponent, MeshComponent>();
auto quakeView = scene.m_Registry.view<TransformComponent, BSPBrushComponent>();
auto view = scene.m_Registry.view<TransformComponent, LightComponent>();
for (auto l : view)
{
auto [lightTransform, light] = view.get<TransformComponent, LightComponent>(l);
if (light.Type != LightType::Directional || !light.CastShadows)
continue;
light.CalculateViewProjection(mView, mProjection);
for (int i = 0; i < CSM_AMOUNT; i++)
{
light.m_Framebuffers[i]->Bind();
light.m_Framebuffers[i]->Clear();
{
shader->SetUniformMat4f("u_LightTransform", light.mViewProjections[i]);
for (auto e : meshView)
{
auto [transform, mesh] = meshView.get<TransformComponent, MeshComponent>(e);
for (auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
for (auto e : quakeView)
{
auto [transform, model] = quakeView.get<TransformComponent, BSPBrushComponent>(e);
if (model.IsTransparent)
continue;
for (Ref<Mesh>& m : model.Meshes)
{
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
}
Renderer::Flush(shader, true);
}
light.m_Framebuffers[i]->Unbind();
}
}
}
void SceneRenderer::GBufferPass(Scene& scene)
{
mGBuffer->Bind();
mGBuffer->Clear();
{
RenderCommand::Enable(RendererEnum::FACE_CULL);
Shader* gBufferShader = ShaderManager::GetShader("resources/Shaders/gbuffer.shader");
gBufferShader->Bind();
gBufferShader->SetUniformMat4f("u_Projection", mProjection);
gBufferShader->SetUniformMat4f("u_View", mView);
auto view = scene.m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view)
{
auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
for (auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
glCullFace(GL_BACK);
Renderer::Flush(gBufferShader, false);
auto quakeView = scene.m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView)
{
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (model.IsTransparent)
continue;
for (auto& b : model.Meshes)
Renderer::SubmitMesh(b, transform.GetGlobalTransform());
}
glCullFace(GL_FRONT);
Renderer::Flush(gBufferShader, false);
}
mGBuffer->Unbind();
}
void SceneRenderer::ShadingPass(Scene& scene)
{
mShadingBuffer->Bind();
mShadingBuffer->Clear();
{
RenderCommand::Disable(RendererEnum::DEPTH_TEST);
RenderCommand::Disable(RendererEnum::FACE_CULL);
scene.GetEnvironment()->ProceduralSkybox->Draw(mProjection, mView);
RenderCommand::Enable(RendererEnum::FACE_CULL);
Shader* shadingShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
shadingShader->Bind();
shadingShader->SetUniformMat4f("u_Projection", mProjection);
shadingShader->SetUniformMat4f("u_View", mView);
shadingShader->SetUniformVec3("u_EyePosition", mView[3]);
Ref<Environment> env = scene.GetEnvironment();
shadingShader->SetUniform1f("u_FogAmount", env->VolumetricFog);
shadingShader->SetUniform1f("u_FogStepCount", env->VolumetricStepCount);
auto view = scene.m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view)
{
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
if (light.SyncDirectionWithSky)
light.Direction = env->ProceduralSkybox->GetSunDirection();
Renderer::RegisterDeferredLight(transform, light);
}
mGBuffer->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(5);
mGBuffer->GetTexture(GL_COLOR_ATTACHMENT0)->Bind(6);
mGBuffer->GetTexture(GL_COLOR_ATTACHMENT1)->Bind(7);
mGBuffer->GetTexture(GL_COLOR_ATTACHMENT2)->Bind(8);
shadingShader->SetUniform1i("m_Depth", 5);
shadingShader->SetUniform1i("m_Albedo", 6);
shadingShader->SetUniform1i("m_Normal", 7);
shadingShader->SetUniform1i("m_Material", 8);
RenderCommand::Disable(RendererEnum::FACE_CULL);
Renderer::DrawQuad(Matrix4());
}
mShadingBuffer->Unbind();
}
void SceneRenderer::PostProcessPass(const Scene& scene)
{
}
}

28
Nuake/src/Rendering/SceneRenderer.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include "Renderer.h"
#include "src/Core/Core.h"
#include "src/Core/Maths.h"
#include "src/Scene/Scene.h"
#include "src/Rendering/Buffers/Framebuffer.h"
#include "src/Rendering/PostFX/Bloom.h"
namespace Nuake {
class SceneRenderer {
public:
void Init();
void Cleanup();
void BeginRenderScene(const Matrix4& projection, const Matrix4& view);
void RenderScene(Scene& scene, FrameBuffer& framebuffer);
private:
Matrix4 mProjection, mView;
Scope<FrameBuffer> mGBuffer;
Scope<FrameBuffer> mShadingBuffer;
Scope<Bloom> mBloom;
void ShadowPass(Scene& scene);
void GBufferPass(Scene& scene);
void ShadingPass(Scene& scene);
void PostProcessPass(const Scene& scene);
};
}

31
Nuake/src/Rendering/Shaders/Shader.cpp
View File

@@ -1,9 +1,9 @@
#pragma once
#include "src/Core/Core.h"
#include "Shader.h"
#include <sstream>
#include <GL\glew.h>
#define ASSERT(x) if (!(x)) assert(false)
namespace Nuake
{
@@ -146,6 +146,22 @@ namespace Nuake
}
// Uniforms
void Shader::SetUniformVec4(const std::string& name, Vector4 vec)
{
SetUniform4f(name, vec.x, vec.y, vec.z, vec.w);
}
void Shader::SetUniformVec3(const std::string& name, Vector3 vec)
{
SetUniform3f(name, vec.x, vec.y, vec.z);
}
void Shader::SetUniformVec2(const std::string& name, Vector2 vec)
{
SetUniform2f(name, vec.x, vec.y);
}
void Shader::SetUniform4f(const std::string& name, float v0, float v1, float v2, float v3)
{
int addr = FindUniformLocation(name);
@@ -167,7 +183,7 @@ namespace Nuake
glUniform2f(addr, v0, v1);
}
void Shader::SetUniform1i(const std::string& name, int v0)
void Shader::SetUniform1i(const std::string& name, int v0)
{
int addr = FindUniformLocation(name);
ASSERT(addr != -1);
@@ -181,14 +197,14 @@ namespace Nuake
glUniform1iv(addr, size, value);
}
void Shader::SetUniformMat3f(const std::string& name, glm::mat3 mat)
void Shader::SetUniformMat3f(const std::string& name, Matrix3 mat)
{
int addr = FindUniformLocation(name);
ASSERT(addr != -1);
glUniformMatrix3fv(addr, 1, GL_FALSE, &mat[0][0]);
}
void Shader::SetUniformMat4f(const std::string& name, glm::mat4 mat)
void Shader::SetUniformMat4f(const std::string& name, Matrix4 mat)
{
int addr = FindUniformLocation(name);
ASSERT(addr != -1);
@@ -201,4 +217,11 @@ namespace Nuake
ASSERT(addr != -1);
glUniform1f(addr, v0);
}
void Shader::SetUniformTex(const std::string& name, Texture* texture, unsigned int slot)
{
ASSERT(texture != nullptr);
SetUniform1i(name, slot);
texture->Bind(slot);
}
}

10
Nuake/src/Rendering/Shaders/Shader.h
View File

@@ -4,6 +4,8 @@
#include <fstream>
#include <unordered_map>
#include "glm/gtc/matrix_transform.hpp"
#include "src/Core/Maths.h"
#include "src/Rendering/Textures/Texture.h"
namespace Nuake
{
@@ -28,15 +30,19 @@ namespace Nuake
// Todo: Other uniform types.
void SetUniformVec4(const std::string& name, Vector4 vec);
void SetUniformVec3(const std::string& name, Vector3 vec);
void SetUniformVec2(const std::string& name, Vector2 vec);
void SetUniform4f(const std::string& name, float v0, float v1, float v2, float v3);
void SetUniform3f(const std::string& name, float v0, float v1, float v2);
void SetUniform2f(const std::string& name, float v0, float v1);
void SetUniform1f(const std::string& name, float v0);
void SetUniformTex(const std::string& name, Texture* texture, unsigned int slot = 0);
void SetUniform1i(const std::string& name, int v0);
void SetUniform1iv(const std::string& name, int size, int* value);
void SetUniformMat3f(const std::string& name, glm::mat3 mat);
void SetUniformMat4f(const std::string& name, glm::mat4 mat);
void SetUniformMat3f(const std::string& name, Matrix3 mat);
void SetUniformMat4f(const std::string& name, Matrix4 mat);
private:
ShaderSource ParseShader(const std::string& filePath);

9
Nuake/src/Rendering/Shaders/ShaderManager.cpp
View File

@@ -3,15 +3,16 @@
namespace Nuake
{
std::map<std::string, Ref<Shader>> ShaderManager::m_Shaders = std::map<std::string, Ref<Shader>>();
std::map<std::string, Scope<Shader>> ShaderManager::m_Shaders = std::map<std::string, Scope<Shader>>();
Ref<Shader> ShaderManager::GetShader(const std::string& path)
Shader* ShaderManager::GetShader(const std::string& path)
{
if (m_Shaders.find(path) == m_Shaders.end())
{
m_Shaders[path] = CreateRef<Shader>(path);
m_Shaders[path] = CreateScope<Shader>(path);
}
return m_Shaders[path];
return m_Shaders[path].get();
}
}

5
Nuake/src/Rendering/Shaders/ShaderManager.h
View File

@@ -7,11 +7,12 @@
namespace Nuake
{
class ShaderManager {
private:
static std::map<std::string, Ref<Shader>> m_Shaders;
static std::map<std::string, Scope<Shader>> m_Shaders;
public:
static Ref<Shader> GetShader(const std::string& path);
static Shader* GetShader(const std::string& path);
};
}

2
Nuake/src/Rendering/Textures/Material.cpp
View File

@@ -84,7 +84,7 @@ namespace Nuake
Material::~Material() {}
void Material::Bind(Ref<Shader> shader)
void Material::Bind(Shader* shader)
{
//if (MaterialManager::Get()->CurrentlyBoundedMaterial == m_Name)
// return;

2
Nuake/src/Rendering/Textures/Material.h
View File

@@ -70,7 +70,7 @@ namespace Nuake
~Material();
void Bind(Ref<Shader> shader);
void Bind(Shader* shader);
void SetupUniformBuffer();

1
Nuake/src/Rendering/Textures/Texture.h
View File

@@ -42,5 +42,6 @@ namespace Nuake
inline std::string GetPath() { return m_FilePath; }
inline int GetWidth() const { return m_Width; }
inline int GetHeight() const { return m_Height; }
inline Vector2 GetSize() const { return Vector2(m_Width, m_Height); }
};
}

34
Nuake/src/Scene/Environment/ProceduralSky.cpp
View File

@@ -34,45 +34,35 @@ namespace Nuake
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
}
void ProceduralSky::Draw(Ref<Camera> cam) {
void ProceduralSky::Draw(Matrix4 projection, Matrix4 view) {
Shader* skyShader = ShaderManager::GetShader("resources/Shaders/atmospheric_sky.shader");
skyShader->Bind();
skyShader->SetUniform1f("SurfaceRadius", SurfaceRadius);
skyShader->SetUniform1f("AtmosphereRadius", AtmosphereRadius);
skyShader->SetUniform1f("SunIntensity", SunIntensity);
glm::vec3 CameraDirection = cam->GetDirection();
Renderer::m_ProceduralSkyShader->Bind();
Renderer::m_ProceduralSkyShader->SetUniform1f("SurfaceRadius", SurfaceRadius);
Renderer::m_ProceduralSkyShader->SetUniform1f("AtmosphereRadius", AtmosphereRadius);
Renderer::m_ProceduralSkyShader->SetUniform1f("SunIntensity", SunIntensity);
Renderer::m_ProceduralSkyShader->SetUniform3f("RayleighScattering",
skyShader->SetUniform3f("RayleighScattering",
RayleighScattering.r,
RayleighScattering.g,
RayleighScattering.b);
Renderer::m_ProceduralSkyShader->SetUniform3f("MieScattering",
skyShader->SetUniform3f("MieScattering",
MieScattering.r,
MieScattering.g,
MieScattering.b);
Renderer::m_ProceduralSkyShader->SetUniform3f("CenterPoint",
skyShader->SetUniform3f("CenterPoint",
CenterPoint.x,
CenterPoint.y,
CenterPoint.z);
Renderer::m_ProceduralSkyShader->SetUniform3f("SunDirection",
skyShader->SetUniform3f("SunDirection",
SunDirection.x,
SunDirection.y,
SunDirection.z);
Renderer::m_ProceduralSkyShader->SetUniform1f("u_Exposure", cam->Exposure);
//Renderer::m_ProceduralSkyShader->SetUniform3f("CamDirection",
// CameraDirection.x,
// CameraDirection.y,
// CameraDirection.z);
Renderer::m_ProceduralSkyShader->SetUniformMat4f("InvProjection", cam->GetPerspective());
Renderer::m_ProceduralSkyShader->SetUniformMat4f("InvView", cam->GetTransformRotation());
skyShader->SetUniformMat4f("Projection", projection);
skyShader->SetUniformMat4f("View", view);
//glm::vec3 CamRight = cam->cameraRight;
//Renderer::m_ProceduralSkyShader->SetUniform3f("CamRight",
// CamRight.x,

2
Nuake/src/Scene/Environment/ProceduralSky.h
View File

@@ -21,7 +21,7 @@ namespace Nuake
unsigned int VAO;
unsigned int VBO;
ProceduralSky();
void Draw(Ref<Camera> cam);
void Draw(Matrix4 projection, Matrix4 view);
Vector3 GetSunDirection();

12
Nuake/src/Scene/Lighting/Environment.cpp
View File

@@ -8,9 +8,9 @@ namespace Nuake {
{
m_AmbientColor = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
ProceduralSkybox = CreateRef<ProceduralSky>();
mBloom = CreateScope<Bloom>(4);
}
// Ambient Light
glm::vec4 Environment::GetAmbientColor()
{
return m_AmbientColor;
@@ -23,8 +23,6 @@ namespace Nuake {
void Environment::Push()
{
//Renderer::m_Shader->SetUniform3f("u_AmbientColor", m_AmbientColor.r, m_AmbientColor.g, m_AmbientColor.b);
//Renderer::m_Shader->SetUniform4f("u_AmbientColor", 1.0f, 1.0f, 1.0f, 1.0f);
Renderer::m_Shader->SetUniform1f("u_FogAmount", VolumetricFog);
Renderer::m_Shader->SetUniform1f("u_FogStepCount", VolumetricStepCount);
}
@@ -34,8 +32,6 @@ namespace Nuake {
BEGIN_SERIALIZE();
SERIALIZE_VAL(VolumetricFog);
SERIALIZE_VAL(VolumetricStepCount);
SERIALIZE_VAL(BloomBlurAmount);
SERIALIZE_VAL(BloomThreshold);
SERIALIZE_VEC4(AmbientColor);
SERIALIZE_OBJECT(ProceduralSkybox);
END_SERIALIZE();
@@ -48,11 +44,7 @@ namespace Nuake {
if (j.contains("VolumetricFog"))
VolumetricFog = j["VolumetricFog"];
if (j.contains("VolumetricStepCount"))
VolumetricFog = j["VolumetricStepCount"];
if (j.contains("BloomBlurAmount"))
VolumetricFog = j["BloomBlurAmount"];
if (j.contains("BloomThreshold"))
VolumetricFog = j["BloomThreshold"];
VolumetricStepCount = j["VolumetricStepCount"];
return false;
}
}

12
Nuake/src/Scene/Lighting/Environment.h
View File

@@ -3,6 +3,9 @@
#include "src/Core/Core.h"
#include "src/Scene/Environment/ProceduralSky.h"
#include "src/Resource/Serializable.h"
#include "src/Rendering/PostFX/Bloom.h"
#include <vector>
namespace Nuake
{
@@ -10,11 +13,12 @@ namespace Nuake
{
public:
Environment();
float VolumetricFog = 0.90f;
float VolumetricStepCount = 50.f;
float VolumetricFog = 0.95f;
float VolumetricStepCount = 100.f;
float BloomThreshold = 0.6f;
float BloomBlurAmount = 12.0f;
Scope<Bloom> mBloom;
Vector3 ClearColor;
glm::vec4 AmbientColor;
Ref<ProceduralSky> ProceduralSkybox;

506
Nuake/src/Scene/Scene.cpp
View File

@@ -3,6 +3,8 @@
#include "src/Scene/Systems/PhysicsSystem.h"
#include "src/Scene/Systems/TransformSystem.h"
#include "src/Scene/Systems/QuakeMapBuilder.h"
#include "src/Rendering/SceneRenderer.h"
#include "Scene.h"
#include "Entities/Entity.h"
@@ -38,15 +40,18 @@ namespace Nuake {
m_Systems = std::vector<Ref<System>>();
m_EditorCamera = CreateRef<EditorCamera>();
m_Environement = CreateRef<Environment>();
m_Interfaces = std::vector<Ref<UI::UserInterface>>();
// Adding systems - Order is important
m_Systems.push_back(CreateRef<ScriptingSystem>(this));
m_Systems.push_back(CreateRef<TransformSystem>(this));
m_Systems.push_back(CreateRef<PhysicsSystem>(this));
mSceneRenderer = new SceneRenderer();
mSceneRenderer->Init();
}
Scene::~Scene() {}
Scene::~Scene() {
}
std::string Scene::GetName()
{
@@ -108,215 +113,11 @@ namespace Nuake {
void Scene::EditorUpdate(Timestep ts)
{
UpdatePositions();
m_EditorCamera->Update(ts);
for (auto i : m_Interfaces)
i->Update(ts);
}
void Scene::UpdatePositions()
void Scene::Draw(FrameBuffer& framebuffer)
{
auto transformView = m_Registry.view<ParentComponent, TransformComponent>();
for (auto e : transformView)
{
auto [parent, transform] = transformView.get<ParentComponent, TransformComponent>(e);
Entity currentParent = Entity{ e, this };
Vector3 globalPos = Vector3();
if (parent.HasParent)
{
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalPos += currentParent.GetComponent<TransformComponent>().Translation;
}
transform.GlobalTranslation = globalPos + transform.Translation;
}
else
{
transform.GlobalTranslation = transform.Translation;
}
}
}
struct BSPDrawObject
{
float distance;
BSPBrushComponent brush;
Matrix4 transform;
};
bool DepthSort(BSPDrawObject& one, BSPDrawObject& two)
{
return one.distance < two.distance;
}
void Scene::DrawShadows()
{
glEnable(GL_DEPTH_TEST);
auto meshView = m_Registry.view<TransformComponent, MeshComponent>();
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent>();
auto view = m_Registry.view<TransformComponent, LightComponent>();
Ref<Camera> cam = m_EditorCamera;
//if (Engine::IsPlayMode)
//{
// auto view = m_Registry.view<TransformComponent, CameraComponent>();
// for (auto e : view)
// {
// auto [transform, camera] = view.get<TransformComponent, CameraComponent>(e);
// cam = camera.CameraInstance;
// break;
// }
//}
Ref<Shader> shadowShader = ShaderManager::GetShader("resources/Shaders/shadowMap.shader");
shadowShader->Bind();
glCullFace(GL_BACK);
// Build a list of mesh to draw.
for (auto l : view)
{
auto [lightTransform, light] = view.get<TransformComponent, LightComponent>(l);
if (light.Type != LightType::Directional || !light.CastShadows)
continue;
light.CalculateViewProjection(cam->GetTransform(), cam->GetPerspective());
for (int i = 0; i < CSM_AMOUNT; i++)
{
light.m_Framebuffers[i]->Bind();
light.m_Framebuffers[i]->Clear();
Frustum lightFrustum = Frustum(light.mViewProjections[i]);
shadowShader->SetUniformMat4f("u_LightTransform", light.mViewProjections[i]);
for (auto e : meshView)
{
auto [transform, mesh] = meshView.get<TransformComponent, MeshComponent>(e);
for(auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : quakeView)
{
auto [transform, model] = quakeView.get<TransformComponent, BSPBrushComponent>(e);
if (model.IsTransparent)
continue;
for (Ref<Mesh>& m : model.Meshes)
{
AABB modelAABB = m->GetAABB();
modelAABB.Transform(transform.GetGlobalTransform());
bool isInFrustum = lightFrustum.IsBoxVisible(modelAABB.Min, modelAABB.Max);
if (isInFrustum)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
}
Renderer::Flush(shadowShader, true);
light.m_Framebuffers[i]->Unbind();
}
}
}
void Scene::DrawInterface(Vector2 screensize)
{
for (auto i : m_Interfaces)
i->Draw(screensize);
}
void Scene::Draw()
{
// Find the camera of the scene.
Ref<Camera> cam = nullptr;
{
auto view = m_Registry.view<TransformComponent, CameraComponent, ParentComponent>();
for (auto e : view) {
auto [transform, camera, parent] = view.get<TransformComponent, CameraComponent, ParentComponent>(e);
cam = camera.CameraInstance;
cam->Translation = transform.GlobalTranslation;
break;
}
}
Ref<Shader> pbrShader = ShaderManager::GetShader("resources/Shaders/pbr.shader");
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
Ref<Environment> env = GetEnvironment();
if (env->ProceduralSkybox)
env->ProceduralSkybox->Draw(cam);
pbrShader->Bind();
env->Push();
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Register the lights
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view)
{
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
Renderer::RegisterLight(transform, light);
}
pbrShader->SetUniform3f("u_EyePosition", cam->GetTranslation().x, cam->GetTranslation().y, cam->GetTranslation().z);
pbrShader->SetUniform1i("u_ShowNormal", 0);
if (cam)
{
pbrShader->SetUniform1f("u_Exposure", cam->Exposure);
pbrShader->SetUniformMat4f("u_View", cam->GetTransform());
pbrShader->SetUniformMat4f("u_Projection", cam->GetPerspective());
auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view)
{
auto [transform, model, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
for (auto& m : model.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
glCullFace(GL_BACK);
Renderer::Flush(pbrShader);
glCullFace(GL_FRONT);
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView)
{
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (model.IsTransparent)
continue;
for (auto& b : model.Meshes)
{
Renderer::SubmitMesh(b, transform.GetGlobalTransform());
}
}
Renderer::Flush(pbrShader);
PhysicsManager::Get()->DrawDebug();
}
}
void Scene::DrawDeferred()
{
glEnable(GL_DEPTH_TEST);
Ref<Camera> cam = nullptr;
{
auto view = m_Registry.view<TransformComponent, CameraComponent, ParentComponent>();
@@ -331,260 +132,16 @@ namespace Nuake {
if (!cam)
return;
Ref<Shader> gBufferShader = ShaderManager::GetShader("resources/Shaders/gbuffer.shader");
gBufferShader->Bind();
gBufferShader->SetUniformMat4f("u_Projection", cam->GetPerspective());
gBufferShader->SetUniformMat4f("u_View", cam->GetTransform());
auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view)
{
auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
for (auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
glCullFace(GL_BACK);
Renderer::Flush(gBufferShader, false);
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView)
{
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (model.IsTransparent)
continue;
for (auto& b : model.Meshes)
Renderer::SubmitMesh(b, transform.GetGlobalTransform());
}
glCullFace(GL_FRONT);
Renderer::Flush(gBufferShader, false);
mSceneRenderer->BeginRenderScene(cam->GetPerspective(), cam->GetTransform());
mSceneRenderer->RenderScene(*this, framebuffer);
}
void Scene::DrawDeferredShading()
void Scene::Draw(FrameBuffer& framebuffer, const Matrix4& projection, const Matrix4& view)
{
glDisable(GL_DEPTH_TEST);
Ref<Camera> cam = nullptr;
{
auto view = m_Registry.view<TransformComponent, CameraComponent, ParentComponent>();
for (auto e : view) {
auto [transform, camera, parent] = view.get<TransformComponent, CameraComponent, ParentComponent>(e);
cam = camera.CameraInstance;
cam->Translation = transform.GlobalTranslation;
break;
}
}
if (!cam)
return;
if (GetEnvironment()->ProceduralSkybox)
GetEnvironment()->ProceduralSkybox->Draw(cam);
Ref<Shader> deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
deferredShader->Bind();
deferredShader->SetUniformMat4f("u_Projection", cam->GetPerspective());
deferredShader->SetUniformMat4f("u_View", cam->GetTransform());
//deferredShader->SetUniform1f("u_Exposure", 1.0);
Vector3 camPosition = cam->GetTranslation();
deferredShader->SetUniform3f("u_EyePosition", camPosition.x, camPosition.y, camPosition.z);
Ref<Environment> env = GetEnvironment();
deferredShader->SetUniform1f("u_FogAmount", env->VolumetricFog);
deferredShader->SetUniform1f("u_FogStepCount", env->VolumetricStepCount);
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view)
{
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
Renderer::RegisterDeferredLight(transform, light);
}
mSceneRenderer->BeginRenderScene(projection, view);
mSceneRenderer->RenderScene(*this, framebuffer);
}
void Scene::EditorDraw()
{
Ref<Environment> env = GetEnvironment();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
if (env->ProceduralSkybox)
env->ProceduralSkybox->Draw(m_EditorCamera);
glEnable(GL_CULL_FACE);
Ref<Shader> pbrShader = ShaderManager::GetShader("resources/Shaders/pbr.shader");
pbrShader->Bind();
env->Push();
glEnable(GL_DEPTH_TEST);
// Register the lights
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view)
{
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
Renderer::RegisterLight(transform, light);
}
pbrShader->SetUniform1i("u_ShowNormal", 0);
if (m_EditorCamera)
{
//Renderer::m_Shader->SetUniform1f("u_Exposure", m_EditorCamera->Exposure);
Renderer::m_Shader->SetUniform3f("u_EyePosition", m_EditorCamera->GetTranslation().x, m_EditorCamera->GetTranslation().y, m_EditorCamera->GetTranslation().z);
Renderer::m_Shader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view)
{
auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
for(auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
glCullFace(GL_BACK);
Renderer::Flush(pbrShader);
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView)
{
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (model.IsTransparent)
continue;
for (auto& b : model.Meshes)
Renderer::SubmitMesh(b, transform.GetGlobalTransform());
}
glCullFace(GL_FRONT);
Renderer::Flush(pbrShader);
Ref<Shader> flatShader = ShaderManager::GetShader("resources/Shaders/flat.shader");
flatShader->Bind();
flatShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
flatShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
auto boxCollider = m_Registry.view<TransformComponent, BoxColliderComponent, ParentComponent>();
for (auto e : boxCollider)
{
auto [transform, box, parent] = boxCollider.get<TransformComponent, BoxColliderComponent, ParentComponent>(e);
TransformComponent t = transform;
t.Scale = (box.Size * 2.f) * transform.Scale;
Renderer::DrawCube(t, glm::vec4(0.0f, 0.0f, 0.9f, 0.2f));
}
auto sphereCollider = m_Registry.view<TransformComponent, SphereColliderComponent, ParentComponent>();
for (auto e : sphereCollider)
{
auto [transform, box, parent] = sphereCollider.get<TransformComponent, SphereColliderComponent, ParentComponent>(e);
flatShader->SetUniformMat4f("u_Model", transform.GetGlobalTransform());
TransformComponent t = transform;
t.Scale = (box.Radius * 2.f) * transform.Scale;
Renderer::DrawSphere(t, glm::vec4(0.0f, 0.0f, 0.9f, 0.2f));
}
auto quakeViewTransparent = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeViewTransparent)
{
auto [transform, model, parent] = quakeViewTransparent.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (!model.IsTransparent)
continue;
flatShader->SetUniformMat4f("u_Model", transform.GetGlobalTransform());
flatShader->SetUniform4f("u_Color", 1.f, 0.0f, 0.1f, 0.5f);
for (auto& b : model.Meshes)
{
Renderer::SubmitMesh(b, transform.GetGlobalTransform());
}
}
Renderer::Flush(flatShader, true);
}
}
void Scene::EditorDrawDeferred()
{
glEnable(GL_DEPTH_TEST);
Ref<Shader> gBufferShader = ShaderManager::GetShader("resources/Shaders/gbuffer.shader");
gBufferShader->Bind();
gBufferShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
gBufferShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view)
{
auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
for (auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetGlobalTransform());
}
glCullFace(GL_BACK);
Renderer::Flush(gBufferShader, false);
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView)
{
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (model.IsTransparent)
continue;
for (auto& b : model.Meshes)
Renderer::SubmitMesh(b, transform.GetGlobalTransform());
}
glCullFace(GL_FRONT);
Renderer::Flush(gBufferShader, false);
}
void Scene::EditorDrawDeferredShading()
{
glDisable(GL_DEPTH_TEST);
if (GetEnvironment()->ProceduralSkybox)
GetEnvironment()->ProceduralSkybox->Draw(m_EditorCamera);
Ref<Shader> deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
deferredShader->Bind();
deferredShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
deferredShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
//deferredShader->SetUniform1f("u_Exposure", 1.0);
Vector3 camPosition = m_EditorCamera->GetTranslation();
deferredShader->SetUniform3f("u_EyePosition", camPosition.x, camPosition.y, camPosition.z);
Ref<Environment> env = GetEnvironment();
deferredShader->SetUniform1f("u_FogAmount", env->VolumetricFog);
deferredShader->SetUniform1f("u_FogStepCount", env->VolumetricStepCount);
// Register the lights
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view)
{
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
Renderer::RegisterDeferredLight(transform, light);
}
}
std::vector<Entity> Scene::GetAllEntities()
{
std::vector<Entity> allEntities;
@@ -599,20 +156,6 @@ namespace Nuake {
return allEntities;
}
glm::vec3 Scene::GetGlobalPosition(Entity ent)
{
glm::vec3 globalPos = ent.GetComponent<TransformComponent>().Translation;
Entity currentParent = ent.AddComponent<ParentComponent>().Parent;
while (currentParent.GetHandle() != -1)
{
globalPos += currentParent.GetComponent<TransformComponent>().Translation;
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
}
return globalPos;
}
Entity Scene::GetEntity(const std::string& name)
{
std::vector<Entity> allEntities;
@@ -628,8 +171,6 @@ namespace Nuake {
Entity Scene::CreateEntity(const std::string& name)
{
Entity entity = { m_Registry.create(), this };
// Must have transform
entity.AddComponent<TransformComponent>();
NameComponent& nameComponent = entity.AddComponent<NameComponent>();
@@ -686,7 +227,7 @@ namespace Nuake {
return m_EditorCamera;
}
Ref<Environment> Scene::GetEnvironment()
Ref<Environment> Scene::GetEnvironment() const
{
return m_Environement;
}
@@ -710,22 +251,6 @@ namespace Nuake {
return true;
}
void Scene::ReloadInterfaces()
{
auto interfaceView = m_Registry.view<InterfaceComponent>();
for (auto i : interfaceView)
{
InterfaceComponent& uInterface = interfaceView.get<InterfaceComponent>(i);
if (uInterface.Interface)
uInterface.Interface->Reload();
}
}
void Scene::AddInterface(Ref<UI::UserInterface> interface)
{
this->m_Interfaces.push_back(interface);
}
json Scene::Serialize()
{
BEGIN_SERIALIZE();
@@ -738,7 +263,6 @@ namespace Nuake {
END_SERIALIZE();
}
bool Scene::Deserialize(const std::string& str)
{
if (str == "")

33
Nuake/src/Scene/Scene.h
View File

@@ -16,7 +16,7 @@
namespace Nuake {
class Entity;
class SceneRenderer;
class Scene : public ISerializable
{
friend Entity;
@@ -28,64 +28,47 @@ namespace Nuake {
// You can create a new system(see 'Systems/'.) and register it
// In the scene constructor.
std::vector<Ref<System>> m_Systems;
Ref<Environment> m_Environement;
SceneRenderer* mSceneRenderer;
public:
Ref<EditorCamera> m_EditorCamera;
entt::registry m_Registry;
std::vector<Ref<UI::UserInterface>> m_Interfaces;
std::string Path = "";
static Ref<Scene> New();
static Ref<Scene> New();
Scene();
~Scene();
std::string GetName();
bool SetName(std::string& newName);
Entity GetEntity(int handle);
Entity GetEntityByID(int id);
void Init();
bool OnInit();
void OnExit();
void Update(Timestep ts);
void FixedUpdate(Timestep ts);
void EditorUpdate(Timestep ts);
void UpdatePositions();
// TODO: Maybe move this to Renderer::DrawScene() ?
void DrawShadows();
void DrawInterface(Vector2 screensize);
void Draw();
void DrawDeferred();
void DrawDeferredShading();
void EditorDrawDeferred();
void EditorDrawDeferredShading();
void EditorDraw();
void Draw(FrameBuffer& framebuffer);
void Draw(FrameBuffer& framebuffer, const Matrix4& projection, const Matrix4& view);
std::vector<Entity> GetAllEntities();
Entity GetEntity(const std::string& name);
Entity CreateEntity(const std::string& name);
// TODO: Could be moved to transform component directly.
glm::vec3 GetGlobalPosition(Entity ent);
void DestroyEntity(Entity entity); // TODO: Could return bool
// TODO: Add multiple camera support.
Ref<Camera> GetCurrentCamera();
Ref<Environment> GetEnvironment();
Ref<Environment> GetEnvironment() const;
bool Save();
bool SaveAs(const std::string& path);
void ReloadInterfaces();
void AddInterface(Ref<UI::UserInterface> interface);
json Serialize() override;
bool Deserialize(const std::string& str) override;
void Snapshot();
void LoadSnapshot();
};
}

14
Nuake/src/Scene/Systems/PhysicsSystem.cpp
View File

@@ -96,11 +96,11 @@ namespace Nuake
PhysicsManager::Get()->Step(ts);
auto brushes = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : brushes)
for (auto e : brushes)
{
auto [transform, brush] = brushes.get<TransformComponent, BSPBrushComponent>(e);
for (auto& r : brush.Rigidbody)
for (auto& r : brush.Rigidbody)
{
r->m_Transform->setOrigin(btVector3(transform.GlobalTranslation.x, transform.GlobalTranslation.y, transform.GlobalTranslation.z));
r->UpdateTransform(*r->m_Transform);
@@ -111,11 +111,11 @@ namespace Nuake
brush.Targets.clear();
auto targetnameView = m_Scene->m_Registry.view<TransformComponent, NameComponent>();
for (auto e2 : targetnameView)
for (auto e2 : targetnameView)
{
auto [ttransform, name] = targetnameView.get<TransformComponent, NameComponent>(e2);
if (name.Name == brush.target)
if (name.Name == brush.target)
{
brush.Targets.push_back(Entity{ e2, m_Scene });
}
@@ -124,14 +124,14 @@ namespace Nuake
auto bspTriggerView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent, TriggerZone>();
for (auto e : bspTriggerView)
for (auto e : bspTriggerView)
{
auto [transform, brush, trigger] = bspTriggerView.get<TransformComponent, BSPBrushComponent, TriggerZone>(e);
trigger.GhostObject->ScanOverlap();
brush.Targets.clear();
auto targetnameView = m_Scene->m_Registry.view<TransformComponent, NameComponent>();
for (auto e2 : targetnameView)
for (auto e2 : targetnameView)
{
auto [ttransform, name] = targetnameView.get<TransformComponent, NameComponent>(e2);
@@ -156,7 +156,7 @@ namespace Nuake
void PhysicsSystem::FixedUpdate(Timestep ts)
{
}
void PhysicsSystem::Exit()

145
Nuake/src/Window.cpp
View File

@@ -22,8 +22,6 @@
#include "src/Rendering/PostFX/Bloom.h"
namespace Nuake {
Bloom bloom;
// TODO: Use abstraction for vertex buffers
unsigned int vbo;
unsigned int vao;
@@ -82,16 +80,6 @@ namespace Nuake {
return m_Framebuffer;
}
Ref<FrameBuffer> Window::GetGBuffer() const
{
return m_GBuffer;
}
Ref<FrameBuffer> Window::GetDeferredBuffer() const
{
return m_DeferredBuffer;
}
Vector2 Window::GetSize()
{
int w, h = 0;
@@ -149,19 +137,8 @@ namespace Nuake {
m_Framebuffer = CreateRef<FrameBuffer>(true, glm::vec2(1920, 1080));
m_Framebuffer->SetTexture(CreateRef<Texture>(glm::vec2(1920, 1080), GL_RGB));
m_GBuffer = CreateRef<FrameBuffer>(false, Vector2(1920, 1080));
m_GBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_DEPTH_COMPONENT), GL_DEPTH_ATTACHMENT);
m_GBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT0);
m_GBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT1);
m_GBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT2);
m_DeferredBuffer = CreateRef<FrameBuffer>(true, Vector2(1920, 1080));
m_DeferredBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGB, GL_RGB16F, GL_FLOAT));
m_BloomFrameBuffer = CreateRef<FrameBuffer>(false, Vector2(1920, 1080));
m_BloomFrameBuffer->SetTexture(CreateRef<Texture>(Vector2(1920, 1080), GL_RGBA, GL_RGBA16F, GL_FLOAT));
bloom = Bloom(m_DeferredBuffer->GetTexture(), 5);
{
ImGui::CreateContext();
@@ -258,76 +235,70 @@ namespace Nuake {
Vector2 size = m_Framebuffer->GetSize();
cam->AspectRatio = size.x / size.y;
m_Scene->m_EditorCamera->OnWindowResize(size.x, size.y);
//Renderer::BeginDraw(cam);
m_Scene->DrawShadows();
//m_Framebuffer->Bind();
//m_Framebuffer->Clear();
//{
// if (Engine::IsPlayMode)
// m_Scene->Draw();
// //else
// // m_Scene->EditorDraw();
//
// m_Scene->DrawInterface(m_Framebuffer->GetSize());
//}
//m_Framebuffer->Unbind();
m_Scene->m_EditorCamera->OnWindowResize(m_GBuffer->GetSize().x, m_GBuffer->GetSize().y);
m_GBuffer->Bind();
m_GBuffer->Clear();
if (Engine::IsPlayMode)
{
if (Engine::IsPlayMode)
m_Scene->DrawDeferred();
else
m_Scene->EditorDrawDeferred();
m_Scene->Draw(*m_Framebuffer.get());
}
m_GBuffer->Unbind();
m_DeferredBuffer->Bind();
m_DeferredBuffer->Clear();
else
{
glDisable(GL_CULL_FACE);
if (Engine::IsPlayMode)
m_Scene->DrawDeferredShading();
else
m_Scene->EditorDrawDeferredShading();
m_GBuffer->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(5);
m_GBuffer->GetTexture(GL_COLOR_ATTACHMENT0)->Bind(6);
m_GBuffer->GetTexture(GL_COLOR_ATTACHMENT1)->Bind(7);
m_GBuffer->GetTexture(GL_COLOR_ATTACHMENT2)->Bind(8);
glDisable(GL_CULL_FACE);
Ref<Shader> deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
deferredShader->Bind();
deferredShader->SetUniform1i("m_Depth", 5);
deferredShader->SetUniform1i("m_Albedo", 6);
deferredShader->SetUniform1i("m_Normal", 7);
deferredShader->SetUniform1i("m_Material", 8);
Renderer::DrawQuad(Matrix4());
auto interfaceView = m_Scene->m_Registry.view<InterfaceComponent>();
for (auto i : interfaceView)
{
InterfaceComponent& uInterface = interfaceView.get<InterfaceComponent>(i);
if (uInterface.Interface)
uInterface.Interface->Draw(m_DeferredBuffer->GetSize());
}
m_Scene->Draw(*m_Framebuffer.get(), m_Scene->m_EditorCamera->GetPerspective(), m_Scene->m_EditorCamera->GetTransform());
}
m_DeferredBuffer->Unbind();
bloom.Threshold = GetScene()->GetEnvironment()->BloomThreshold;
bloom.BlurAmount = GetScene()->GetEnvironment()->BloomBlurAmount;
bloom.Draw();
//m_GBuffer->Bind();
//m_GBuffer->Clear();
//{
// if (Engine::IsPlayMode)
// m_Scene->DrawDeferred();
// else
// m_Scene->EditorDrawDeferred();
//}
//
//m_GBuffer->Unbind();
//
//m_DeferredBuffer->Bind();
//m_DeferredBuffer->Clear();
//{
// glDisable(GL_CULL_FACE);
//
// if (Engine::IsPlayMode)
// m_Scene->DrawDeferredShading();
// else
// m_Scene->EditorDrawDeferredShading();
//
// m_GBuffer->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(5);
// m_GBuffer->GetTexture(GL_COLOR_ATTACHMENT0)->Bind(6);
// m_GBuffer->GetTexture(GL_COLOR_ATTACHMENT1)->Bind(7);
// m_GBuffer->GetTexture(GL_COLOR_ATTACHMENT2)->Bind(8);
//
// glDisable(GL_CULL_FACE);
//
// Shader* deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
// deferredShader->Bind();
// deferredShader->SetUniform1i("m_Depth", 5);
// deferredShader->SetUniform1i("m_Albedo", 6);
// deferredShader->SetUniform1i("m_Normal", 7);
// deferredShader->SetUniform1i("m_Material", 8);
//
// Renderer::DrawQuad(Matrix4());
//
// auto interfaceView = m_Scene->m_Registry.view<InterfaceComponent>();
// for (auto i : interfaceView)
// {
// InterfaceComponent& uInterface = interfaceView.get<InterfaceComponent>(i);
// if (uInterface.Interface)
// uInterface.Interface->Draw(m_DeferredBuffer->GetSize());
// }
//}
//m_DeferredBuffer->Unbind();
//
//bloom.Threshold = GetScene()->GetEnvironment()->BloomThreshold;
//bloom.BlurAmount = GetScene()->GetEnvironment()->BloomBlurAmount;
//
//bloom.Draw();

5
Nuake/src/Window.h
View File

@@ -19,9 +19,6 @@ namespace Nuake
GLFWwindow* m_Window;
Ref<FrameBuffer> m_Framebuffer;
Ref<FrameBuffer> m_GBuffer;
Ref<FrameBuffer> m_DeferredBuffer;
Ref<FrameBuffer> m_BloomFrameBuffer;
Ref<Scene> m_Scene;
Vector2 m_FramebufferOffset;
@@ -42,8 +39,6 @@ namespace Nuake
void EndDraw();
Ref<FrameBuffer> GetFrameBuffer() const;
Ref<FrameBuffer> GetGBuffer() const;
Ref<FrameBuffer> GetDeferredBuffer() const;
Vector2 GetSize();
Ref<Scene> GetScene();
bool SetScene(Ref<Scene> scene);