diff --git a/Editor/Editor.cpp b/Editor/Editor.cpp index f4048179..bda49981 100644 --- a/Editor/Editor.cpp +++ b/Editor/Editor.cpp @@ -55,8 +55,8 @@ int main() // Register Gizmo textures Ref lightTexture = Nuake::TextureManager::Get()->GetTexture("resources/Icons/Gizmo/Light.png"); Ref camTexture = Nuake::TextureManager::Get()->GetTexture("resources/Icons/Gizmo/Camera.png"); - Ref GuizmoShader = Nuake::ShaderManager::GetShader("resources/Shaders/gizmo.shader"); - Ref 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(); diff --git a/Editor/resources/Scripts/Math.wren b/Editor/resources/Scripts/Math.wren index 477a0bc8..6783aa12 100644 --- a/Editor/resources/Scripts/Math.wren +++ b/Editor/resources/Scripts/Math.wren @@ -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 diff --git a/Editor/resources/Shaders/atmospheric_sky.shader b/Editor/resources/Shaders/atmospheric_sky.shader index d47656e3..369b8d71 100644 --- a/Editor/resources/Shaders/atmospheric_sky.shader +++ b/Editor/resources/Shaders/atmospheric_sky.shader @@ -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.); } \ No newline at end of file diff --git a/Editor/resources/Shaders/bloom.shader b/Editor/resources/Shaders/bloom.shader index cfef2373..fb728db1 100644 --- a/Editor/resources/Shaders/bloom.shader +++ b/Editor/resources/Shaders/bloom.shader @@ -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)); diff --git a/Editor/resources/Shaders/copy.shader b/Editor/resources/Shaders/copy.shader new file mode 100644 index 00000000..e7359322 --- /dev/null +++ b/Editor/resources/Shaders/copy.shader @@ -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); +} \ No newline at end of file diff --git a/Editor/resources/Shaders/deferred.shader b/Editor/resources/Shaders/deferred.shader index 507f96e1..4e8d85c2 100644 --- a/Editor/resources/Shaders/deferred.shader +++ b/Editor/resources/Shaders/deferred.shader @@ -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; diff --git a/Editor/src/EditorInterface.cpp b/Editor/src/EditorInterface.cpp index d845812d..3c70b705 100644 --- a/Editor/src/EditorInterface.cpp +++ b/Editor/src/EditorInterface.cpp @@ -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 = Engine::GetCurrentWindow()->GetDeferredBuffer(); + Ref framebuffer = Engine::GetCurrentWindow()->GetFrameBuffer(); if (framebuffer->GetSize() != viewportPanelSize) - { - Engine::GetCurrentWindow()->GetGBuffer()->QueueResize(viewportPanelSize); framebuffer->QueueResize(viewportPanelSize); - } Ref 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 env = Engine::GetCurrentScene()->GetEnvironment(); + const Ref 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; diff --git a/Nuake/Engine.cpp b/Nuake/Engine.cpp index c6f42dbd..d66d5058 100644 --- a/Nuake/Engine.cpp +++ b/Nuake/Engine.cpp @@ -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(); diff --git a/Nuake/src/Core/Core.h b/Nuake/src/Core/Core.h index f6b9d8aa..1072c89a 100644 --- a/Nuake/src/Core/Core.h +++ b/Nuake/src/Core/Core.h @@ -4,14 +4,23 @@ #include #include -template -using Scope = std::unique_ptr; +#define ASSERT(x) if (!(x)) assert(false) template using Ref = std::shared_ptr; +template +using Scope = std::unique_ptr; + + template constexpr Ref CreateRef(Args&& ... args) { return std::make_shared(std::forward(args)...); +} + +template +constexpr Scope CreateScope(Args&& ... args) +{ + return std::make_unique(std::forward(args)...); } \ No newline at end of file diff --git a/Nuake/src/Core/Maths.h b/Nuake/src/Core/Maths.h index 0313f1d0..6b9b65a0 100644 --- a/Nuake/src/Core/Maths.h +++ b/Nuake/src/Core/Maths.h @@ -5,13 +5,13 @@ #include #include - - 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; } diff --git a/Nuake/src/Core/Physics/DynamicWorld.cpp b/Nuake/src/Core/Physics/DynamicWorld.cpp index a620b631..6d52b388 100644 --- a/Nuake/src/Core/Physics/DynamicWorld.cpp +++ b/Nuake/src/Core/Physics/DynamicWorld.cpp @@ -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]; diff --git a/Nuake/src/Rendering/Buffers/Framebuffer.cpp b/Nuake/src/Rendering/Buffers/Framebuffer.cpp index 873707cc..1b6f5b1b 100644 --- a/Nuake/src/Rendering/Buffers/Framebuffer.cpp +++ b/Nuake/src/Rendering/Buffers/Framebuffer.cpp @@ -84,6 +84,9 @@ namespace Nuake void FrameBuffer::QueueResize(Vector2 size) { + if (size == m_Size) + return; + ResizeQueued = true; m_Size = size; } diff --git a/Nuake/src/Rendering/Mesh/Mesh.cpp b/Nuake/src/Rendering/Mesh/Mesh.cpp index 4c4c41f6..861fa41b 100644 --- a/Nuake/src/Rendering/Mesh/Mesh.cpp +++ b/Nuake/src/Rendering/Mesh/Mesh.cpp @@ -55,7 +55,7 @@ namespace Nuake m_VertexArray->Unbind(); } - void Mesh::Draw(Ref shader, bool bindMaterial) + void Mesh::Draw(Shader* shader, bool bindMaterial) { if (bindMaterial) m_Material->Bind(shader); diff --git a/Nuake/src/Rendering/Mesh/Mesh.h b/Nuake/src/Rendering/Mesh/Mesh.h index c6bbeb69..3c56e906 100644 --- a/Nuake/src/Rendering/Mesh/Mesh.h +++ b/Nuake/src/Rendering/Mesh/Mesh.h @@ -21,7 +21,7 @@ namespace Nuake Mesh(std::vector vertices, std::vector indices, Ref material); - void Draw(Ref shader, bool bindMaterial = true); + void Draw(Shader* shader, bool bindMaterial = true); void DebugDraw(); inline AABB GetAABB() const { return m_AABB; } diff --git a/Nuake/src/Rendering/Platforms/OGLRendererAPI.cpp b/Nuake/src/Rendering/Platforms/OGLRendererAPI.cpp index 558d00f3..1fcec512 100644 --- a/Nuake/src/Rendering/Platforms/OGLRendererAPI.cpp +++ b/Nuake/src/Rendering/Platforms/OGLRendererAPI.cpp @@ -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; diff --git a/Nuake/src/Rendering/Platforms/OGLRendererAPI.h b/Nuake/src/Rendering/Platforms/OGLRendererAPI.h index 1ad89a80..3a10d7b2 100644 --- a/Nuake/src/Rendering/Platforms/OGLRendererAPI.h +++ b/Nuake/src/Rendering/Platforms/OGLRendererAPI.h @@ -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; diff --git a/Nuake/src/Rendering/Platforms/RendererAPI.h b/Nuake/src/Rendering/Platforms/RendererAPI.h index 6549acd0..31f3dd3c 100644 --- a/Nuake/src/Rendering/Platforms/RendererAPI.h +++ b/Nuake/src/Rendering/Platforms/RendererAPI.h @@ -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; diff --git a/Nuake/src/Rendering/PostFX/Bloom.cpp b/Nuake/src/Rendering/PostFX/Bloom.cpp index 68a7d177..9b87ce39 100644 --- a/Nuake/src/Rendering/PostFX/Bloom.cpp +++ b/Nuake/src/Rendering/PostFX/Bloom.cpp @@ -6,26 +6,38 @@ namespace Nuake { const float DownsamplingScale = 0.4f; - Bloom::Bloom(Ref source, unsigned int iteration) + Bloom::Bloom(unsigned int iteration) { m_Iteration = iteration; + } + + void Bloom::SetSource(Ref source) + { + if (m_Source == source) + return; + m_Source = source; + m_Size = source->GetSize(); + Init(); + } - + void Bloom::Init() + { + if (!m_Source) + return; - m_FinalFB = CreateRef(false, Vector2(1920, 1080)); - m_FinalFB->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGBA, GL_RGBA16F, GL_FLOAT)); + m_FinalFB = CreateRef(false, m_Size); + m_FinalFB->SetTexture(CreateRef(m_Size, GL_RGBA, GL_RGBA16F, GL_FLOAT)); + + m_ThresholdFB = CreateRef(false, m_Size); + m_ThresholdFB->SetTexture(CreateRef(m_Size, GL_RGBA, GL_RGBA16F, GL_FLOAT)); - m_ThresholdFB = CreateRef(false, Vector2(1920, 1080)); - m_ThresholdFB->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGBA, GL_RGBA16F, GL_FLOAT)); - m_DownSampleFB = std::vector>(); m_UpSampleFB = std::vector>(); m_HBlurFB = std::vector>(); m_VBlurFB = std::vector>(); - 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 fb = CreateRef(false, currentSize); @@ -53,21 +65,20 @@ namespace Nuake } } - int downsampleMip = 0; int upSampleMip = 0; void Bloom::Draw() { - Ref 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 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(); + } } \ No newline at end of file diff --git a/Nuake/src/Rendering/PostFX/Bloom.h b/Nuake/src/Rendering/PostFX/Bloom.h index 754ca20b..cedfbc79 100644 --- a/Nuake/src/Rendering/PostFX/Bloom.h +++ b/Nuake/src/Rendering/PostFX/Bloom.h @@ -10,30 +10,55 @@ namespace Nuake { class Bloom { - public: - float Threshold = 0.3f; - float BlurAmount = 12.0f; - Bloom() {} - Bloom(Ref source, unsigned int iteration = 4); - - void Draw(); - - Ref 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 m_Source; - - std::vector> m_DownsampleMIP; - std::vector> m_UpSampleMIP; - Ref m_FinalFB; - Ref m_Final; Ref m_ThresholdFB; - - std::vector> m_DownSampleFB; std::vector> m_HBlurFB; std::vector> m_VBlurFB; std::vector> 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 source); + Ref GetOutput() const { return m_FinalFB->GetTexture(); } + }; } \ No newline at end of file diff --git a/Nuake/src/Rendering/RenderCommand.cpp b/Nuake/src/Rendering/RenderCommand.cpp index a0e3b20c..f3bd49e9 100644 --- a/Nuake/src/Rendering/RenderCommand.cpp +++ b/Nuake/src/Rendering/RenderCommand.cpp @@ -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); diff --git a/Nuake/src/Rendering/RenderCommand.h b/Nuake/src/Rendering/RenderCommand.h index ed4670c6..b101a6f8 100644 --- a/Nuake/src/Rendering/RenderCommand.h +++ b/Nuake/src/Rendering/RenderCommand.h @@ -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); diff --git a/Nuake/src/Rendering/RenderList.h b/Nuake/src/Rendering/RenderList.h index 0bf33b2a..e50874f8 100644 --- a/Nuake/src/Rendering/RenderList.h +++ b/Nuake/src/Rendering/RenderList.h @@ -30,7 +30,7 @@ namespace Nuake m_RenderList[mesh->m_Material].push_back({mesh, transform}); } - void Flush(Ref shader, bool depthOnly = false) + void Flush(Shader* shader, bool depthOnly = false) { shader->Bind(); for (auto& i : m_RenderList) diff --git a/Nuake/src/Rendering/Renderer.cpp b/Nuake/src/Rendering/Renderer.cpp index 377b2c15..365b96d9 100644 --- a/Nuake/src/Rendering/Renderer.cpp +++ b/Nuake/src/Rendering/Renderer.cpp @@ -19,14 +19,14 @@ namespace Nuake unsigned int depthTexture; unsigned int depthFBO; - Ref Renderer::m_Shader; - Ref Renderer::m_SkyboxShader; - Ref Renderer::m_BRDShader; - Ref Renderer::m_GBufferShader; - Ref Renderer::m_DeferredShader; - Ref Renderer::m_ProceduralSkyShader; - Ref Renderer::m_DebugShader; - Ref 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, Matrix4 transform) @@ -106,7 +98,7 @@ namespace Nuake m_RenderList.AddToRenderList(mesh, transform); } - void Renderer::Flush(Ref 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 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 deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader"); + Shader* deferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader"); deferredShader->Bind(); m_Lights.push_back({ transform , light }); diff --git a/Nuake/src/Rendering/Renderer.h b/Nuake/src/Rendering/Renderer.h index 7e4df1cb..6600e753 100644 --- a/Nuake/src/Rendering/Renderer.h +++ b/Nuake/src/Rendering/Renderer.h @@ -43,14 +43,14 @@ namespace Nuake static VertexArray* Renderer::CubeVertexArray; static VertexBuffer* Renderer::CubeVertexBuffer; - static Ref m_Shader; - static Ref m_ShadowmapShader; - static Ref m_SkyboxShader; - static Ref m_BRDShader; - static Ref m_GBufferShader; - static Ref m_DeferredShader; - static Ref m_ProceduralSkyShader; - static Ref 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 m_LightsUniformBuffer; @@ -59,7 +59,7 @@ namespace Nuake static void BeginScene(); static void SubmitMesh(Ref mesh, Matrix4 transform); - static void Flush(Ref shader, bool depthOnly = false); + static void Flush(Shader* shader, bool depthOnly = false); // Drawing states static void BeginDraw(Ref 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()); }; } diff --git a/Nuake/src/Rendering/Renderer2D.cpp b/Nuake/src/Rendering/Renderer2D.cpp index b8b789fa..b56c41ec 100644 --- a/Nuake/src/Rendering/Renderer2D.cpp +++ b/Nuake/src/Rendering/Renderer2D.cpp @@ -7,8 +7,8 @@ #include "src/Vendors/glm/gtx/matrix_decompose.hpp" namespace Nuake { - Ref Renderer2D::UIShader; - Ref Renderer2D::TextShader; + Shader* Renderer2D::UIShader; + Shader* Renderer2D::TextShader; unsigned int Renderer2D::VAO; unsigned int Renderer2D::VBO; diff --git a/Nuake/src/Rendering/Renderer2D.h b/Nuake/src/Rendering/Renderer2D.h index c77debcc..92434751 100644 --- a/Nuake/src/Rendering/Renderer2D.h +++ b/Nuake/src/Rendering/Renderer2D.h @@ -13,8 +13,8 @@ namespace Nuake static unsigned int VAO; static unsigned int VBO; public: - static Ref UIShader; - static Ref TextShader; + static Shader* UIShader; + static Shader* TextShader; static Matrix4 Projection; static void Init(); diff --git a/Nuake/src/Rendering/SceneRenderer.cpp b/Nuake/src/Rendering/SceneRenderer.cpp new file mode 100644 index 00000000..fa9eb6a3 --- /dev/null +++ b/Nuake/src/Rendering/SceneRenderer.cpp @@ -0,0 +1,208 @@ +#include "SceneRenderer.h" +#include "src/Rendering/Shaders/ShaderManager.h" + +#include +#include +namespace Nuake { + void SceneRenderer::Init() + { + mGBuffer = CreateScope(false, Vector2(1920, 1080)); + mGBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_DEPTH_COMPONENT), GL_DEPTH_ATTACHMENT); + mGBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT0); + mGBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT1); + mGBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT2); + mGBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT3); + + mShadingBuffer = CreateScope(true, Vector2(1920, 1080)); + Ref shadedTexture = CreateRef(Vector2(1920, 1080), GL_RGB, GL_RGB16F, GL_FLOAT); + mShadingBuffer->SetTexture(shadedTexture); + + mBloom = CreateScope(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(); + auto quakeView = scene.m_Registry.view(); + auto view = scene.m_Registry.view(); + for (auto l : view) + { + auto [lightTransform, light] = view.get(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(e); + for (auto& m : mesh.meshes) + Renderer::SubmitMesh(m, transform.GetGlobalTransform()); + } + + for (auto e : quakeView) + { + auto [transform, model] = quakeView.get(e); + + if (model.IsTransparent) + continue; + + for (Ref& 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(); + for (auto e : view) + { + auto [transform, mesh, parent] = view.get(e); + for (auto& m : mesh.meshes) + Renderer::SubmitMesh(m, transform.GetGlobalTransform()); + } + + glCullFace(GL_BACK); + Renderer::Flush(gBufferShader, false); + + auto quakeView = scene.m_Registry.view(); + for (auto e : quakeView) + { + auto [transform, model, parent] = quakeView.get(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 env = scene.GetEnvironment(); + shadingShader->SetUniform1f("u_FogAmount", env->VolumetricFog); + shadingShader->SetUniform1f("u_FogStepCount", env->VolumetricStepCount); + + auto view = scene.m_Registry.view(); + for (auto l : view) + { + auto [transform, light, parent] = view.get(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) + { + } +} \ No newline at end of file diff --git a/Nuake/src/Rendering/SceneRenderer.h b/Nuake/src/Rendering/SceneRenderer.h new file mode 100644 index 00000000..96cf1a2e --- /dev/null +++ b/Nuake/src/Rendering/SceneRenderer.h @@ -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 mGBuffer; + Scope mShadingBuffer; + Scope mBloom; + + void ShadowPass(Scene& scene); + void GBufferPass(Scene& scene); + void ShadingPass(Scene& scene); + void PostProcessPass(const Scene& scene); + }; +} \ No newline at end of file diff --git a/Nuake/src/Rendering/Shaders/Shader.cpp b/Nuake/src/Rendering/Shaders/Shader.cpp index a529d617..30414689 100644 --- a/Nuake/src/Rendering/Shaders/Shader.cpp +++ b/Nuake/src/Rendering/Shaders/Shader.cpp @@ -1,9 +1,9 @@ #pragma once +#include "src/Core/Core.h" #include "Shader.h" #include #include -#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); + } } diff --git a/Nuake/src/Rendering/Shaders/Shader.h b/Nuake/src/Rendering/Shaders/Shader.h index 1c92d39f..e167b2d3 100644 --- a/Nuake/src/Rendering/Shaders/Shader.h +++ b/Nuake/src/Rendering/Shaders/Shader.h @@ -4,6 +4,8 @@ #include #include #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); diff --git a/Nuake/src/Rendering/Shaders/ShaderManager.cpp b/Nuake/src/Rendering/Shaders/ShaderManager.cpp index e51d591d..3fef3ef4 100644 --- a/Nuake/src/Rendering/Shaders/ShaderManager.cpp +++ b/Nuake/src/Rendering/Shaders/ShaderManager.cpp @@ -3,15 +3,16 @@ namespace Nuake { - std::map> ShaderManager::m_Shaders = std::map>(); + std::map> ShaderManager::m_Shaders = std::map>(); - Ref 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(path); + m_Shaders[path] = CreateScope(path); } - return m_Shaders[path]; + + return m_Shaders[path].get(); } } diff --git a/Nuake/src/Rendering/Shaders/ShaderManager.h b/Nuake/src/Rendering/Shaders/ShaderManager.h index 39d57c8e..6db5a02e 100644 --- a/Nuake/src/Rendering/Shaders/ShaderManager.h +++ b/Nuake/src/Rendering/Shaders/ShaderManager.h @@ -7,11 +7,12 @@ namespace Nuake { + class ShaderManager { private: - static std::map> m_Shaders; + static std::map> m_Shaders; public: - static Ref GetShader(const std::string& path); + static Shader* GetShader(const std::string& path); }; } diff --git a/Nuake/src/Rendering/Textures/Material.cpp b/Nuake/src/Rendering/Textures/Material.cpp index 3901cebb..ece7e11b 100644 --- a/Nuake/src/Rendering/Textures/Material.cpp +++ b/Nuake/src/Rendering/Textures/Material.cpp @@ -84,7 +84,7 @@ namespace Nuake Material::~Material() {} - void Material::Bind(Ref shader) + void Material::Bind(Shader* shader) { //if (MaterialManager::Get()->CurrentlyBoundedMaterial == m_Name) // return; diff --git a/Nuake/src/Rendering/Textures/Material.h b/Nuake/src/Rendering/Textures/Material.h index 4ba44496..8acba9de 100644 --- a/Nuake/src/Rendering/Textures/Material.h +++ b/Nuake/src/Rendering/Textures/Material.h @@ -70,7 +70,7 @@ namespace Nuake ~Material(); - void Bind(Ref shader); + void Bind(Shader* shader); void SetupUniformBuffer(); diff --git a/Nuake/src/Rendering/Textures/Texture.h b/Nuake/src/Rendering/Textures/Texture.h index 871e9b9b..1172cc25 100644 --- a/Nuake/src/Rendering/Textures/Texture.h +++ b/Nuake/src/Rendering/Textures/Texture.h @@ -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); } }; } diff --git a/Nuake/src/Scene/Environment/ProceduralSky.cpp b/Nuake/src/Scene/Environment/ProceduralSky.cpp index 4afbdbe9..356a650d 100644 --- a/Nuake/src/Scene/Environment/ProceduralSky.cpp +++ b/Nuake/src/Scene/Environment/ProceduralSky.cpp @@ -34,45 +34,35 @@ namespace Nuake glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float))); } - void ProceduralSky::Draw(Ref 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, diff --git a/Nuake/src/Scene/Environment/ProceduralSky.h b/Nuake/src/Scene/Environment/ProceduralSky.h index 4ed8c699..af5a396e 100644 --- a/Nuake/src/Scene/Environment/ProceduralSky.h +++ b/Nuake/src/Scene/Environment/ProceduralSky.h @@ -21,7 +21,7 @@ namespace Nuake unsigned int VAO; unsigned int VBO; ProceduralSky(); - void Draw(Ref cam); + void Draw(Matrix4 projection, Matrix4 view); Vector3 GetSunDirection(); diff --git a/Nuake/src/Scene/Lighting/Environment.cpp b/Nuake/src/Scene/Lighting/Environment.cpp index 0e9f829c..46ee889b 100644 --- a/Nuake/src/Scene/Lighting/Environment.cpp +++ b/Nuake/src/Scene/Lighting/Environment.cpp @@ -8,9 +8,9 @@ namespace Nuake { { m_AmbientColor = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f); ProceduralSkybox = CreateRef(); + mBloom = CreateScope(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; } } diff --git a/Nuake/src/Scene/Lighting/Environment.h b/Nuake/src/Scene/Lighting/Environment.h index e1b5b75f..b86dd1a8 100644 --- a/Nuake/src/Scene/Lighting/Environment.h +++ b/Nuake/src/Scene/Lighting/Environment.h @@ -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 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 mBloom; + + Vector3 ClearColor; glm::vec4 AmbientColor; Ref ProceduralSkybox; diff --git a/Nuake/src/Scene/Scene.cpp b/Nuake/src/Scene/Scene.cpp index 47ada628..0c9c83cf 100644 --- a/Nuake/src/Scene/Scene.cpp +++ b/Nuake/src/Scene/Scene.cpp @@ -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>(); m_EditorCamera = CreateRef(); m_Environement = CreateRef(); - m_Interfaces = std::vector>(); // Adding systems - Order is important m_Systems.push_back(CreateRef(this)); m_Systems.push_back(CreateRef(this)); m_Systems.push_back(CreateRef(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(); - for (auto e : transformView) - { - auto [parent, transform] = transformView.get(e); - Entity currentParent = Entity{ e, this }; - Vector3 globalPos = Vector3(); - if (parent.HasParent) - { - while (currentParent.GetComponent().HasParent) - { - currentParent = currentParent.GetComponent().Parent; - globalPos += currentParent.GetComponent().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(); - auto quakeView = m_Registry.view(); - auto view = m_Registry.view(); - - Ref cam = m_EditorCamera; - //if (Engine::IsPlayMode) - //{ - // auto view = m_Registry.view(); - // for (auto e : view) - // { - // auto [transform, camera] = view.get(e); - // cam = camera.CameraInstance; - // break; - // } - //} - - Ref 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(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(e); - for(auto& m : mesh.meshes) - Renderer::SubmitMesh(m, transform.GetGlobalTransform()); - } - - auto quakeView = m_Registry.view(); - for (auto e : quakeView) - { - auto [transform, model] = quakeView.get(e); - - if (model.IsTransparent) - continue; - - for (Ref& 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 cam = nullptr; - { - auto view = m_Registry.view(); - for (auto e : view) { - auto [transform, camera, parent] = view.get(e); - cam = camera.CameraInstance; - cam->Translation = transform.GlobalTranslation; - break; - } - } - - Ref pbrShader = ShaderManager::GetShader("resources/Shaders/pbr.shader"); - - glDisable(GL_CULL_FACE); - glDisable(GL_DEPTH_TEST); - Ref 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(); - for (auto l : view) - { - auto [transform, light, parent] = view.get(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(); - for (auto e : view) - { - auto [transform, model, parent] = view.get(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(); - for (auto e : quakeView) - { - auto [transform, model, parent] = quakeView.get(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 cam = nullptr; { auto view = m_Registry.view(); @@ -331,260 +132,16 @@ namespace Nuake { if (!cam) return; - Ref 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(); - for (auto e : view) - { - auto [transform, mesh, parent] = view.get(e); - for (auto& m : mesh.meshes) - Renderer::SubmitMesh(m, transform.GetGlobalTransform()); - } - - glCullFace(GL_BACK); - Renderer::Flush(gBufferShader, false); - - auto quakeView = m_Registry.view(); - for (auto e : quakeView) - { - auto [transform, model, parent] = quakeView.get(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 cam = nullptr; - { - auto view = m_Registry.view(); - for (auto e : view) { - auto [transform, camera, parent] = view.get(e); - cam = camera.CameraInstance; - cam->Translation = transform.GlobalTranslation; - break; - } - } - - if (!cam) - return; - - if (GetEnvironment()->ProceduralSkybox) - GetEnvironment()->ProceduralSkybox->Draw(cam); - - Ref 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 env = GetEnvironment(); - deferredShader->SetUniform1f("u_FogAmount", env->VolumetricFog); - deferredShader->SetUniform1f("u_FogStepCount", env->VolumetricStepCount); - - auto view = m_Registry.view(); - for (auto l : view) - { - auto [transform, light, parent] = view.get(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 env = GetEnvironment(); - - glDisable(GL_DEPTH_TEST); - glDisable(GL_CULL_FACE); - - if (env->ProceduralSkybox) - env->ProceduralSkybox->Draw(m_EditorCamera); - - glEnable(GL_CULL_FACE); - - Ref pbrShader = ShaderManager::GetShader("resources/Shaders/pbr.shader"); - pbrShader->Bind(); - - env->Push(); - - glEnable(GL_DEPTH_TEST); - - // Register the lights - auto view = m_Registry.view(); - for (auto l : view) - { - auto [transform, light, parent] = view.get(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(); - for (auto e : view) - { - auto [transform, mesh, parent] = view.get(e); - for(auto& m : mesh.meshes) - Renderer::SubmitMesh(m, transform.GetGlobalTransform()); - } - glCullFace(GL_BACK); - Renderer::Flush(pbrShader); - - auto quakeView = m_Registry.view(); - for (auto e : quakeView) - { - auto [transform, model, parent] = quakeView.get(e); - - if (model.IsTransparent) - continue; - - for (auto& b : model.Meshes) - Renderer::SubmitMesh(b, transform.GetGlobalTransform()); - } - - glCullFace(GL_FRONT); - Renderer::Flush(pbrShader); - - Ref 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(); - for (auto e : boxCollider) - { - auto [transform, box, parent] = boxCollider.get(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(); - for (auto e : sphereCollider) - { - auto [transform, box, parent] = sphereCollider.get(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(); - for (auto e : quakeViewTransparent) - { - auto [transform, model, parent] = quakeViewTransparent.get(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 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(); - for (auto e : view) - { - auto [transform, mesh, parent] = view.get(e); - for (auto& m : mesh.meshes) - Renderer::SubmitMesh(m, transform.GetGlobalTransform()); - } - glCullFace(GL_BACK); - Renderer::Flush(gBufferShader, false); - - auto quakeView = m_Registry.view(); - for (auto e : quakeView) - { - auto [transform, model, parent] = quakeView.get(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 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 env = GetEnvironment(); - deferredShader->SetUniform1f("u_FogAmount", env->VolumetricFog); - deferredShader->SetUniform1f("u_FogStepCount", env->VolumetricStepCount); - - // Register the lights - auto view = m_Registry.view(); - for (auto l : view) - { - auto [transform, light, parent] = view.get(l); - - if (light.SyncDirectionWithSky) - light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection(); - - Renderer::RegisterDeferredLight(transform, light); - } - } - + std::vector Scene::GetAllEntities() { std::vector allEntities; @@ -599,20 +156,6 @@ namespace Nuake { return allEntities; } - glm::vec3 Scene::GetGlobalPosition(Entity ent) - { - glm::vec3 globalPos = ent.GetComponent().Translation; - Entity currentParent = ent.AddComponent().Parent; - while (currentParent.GetHandle() != -1) - { - globalPos += currentParent.GetComponent().Translation; - currentParent = currentParent.GetComponent().Parent; - } - - return globalPos; - } - - Entity Scene::GetEntity(const std::string& name) { std::vector 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(); NameComponent& nameComponent = entity.AddComponent(); @@ -686,7 +227,7 @@ namespace Nuake { return m_EditorCamera; } - Ref Scene::GetEnvironment() + Ref Scene::GetEnvironment() const { return m_Environement; } @@ -710,22 +251,6 @@ namespace Nuake { return true; } - void Scene::ReloadInterfaces() - { - auto interfaceView = m_Registry.view(); - for (auto i : interfaceView) - { - InterfaceComponent& uInterface = interfaceView.get(i); - if (uInterface.Interface) - uInterface.Interface->Reload(); - } - } - - void Scene::AddInterface(Ref 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 == "") diff --git a/Nuake/src/Scene/Scene.h b/Nuake/src/Scene/Scene.h index 5d388269..06fad8b3 100644 --- a/Nuake/src/Scene/Scene.h +++ b/Nuake/src/Scene/Scene.h @@ -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> m_Systems; - Ref m_Environement; + SceneRenderer* mSceneRenderer; public: Ref m_EditorCamera; entt::registry m_Registry; - std::vector> m_Interfaces; std::string Path = ""; - static Ref New(); + static Ref 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 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 GetCurrentCamera(); - Ref GetEnvironment(); + Ref GetEnvironment() const; bool Save(); bool SaveAs(const std::string& path); - void ReloadInterfaces(); void AddInterface(Ref interface); json Serialize() override; bool Deserialize(const std::string& str) override; - - void Snapshot(); - void LoadSnapshot(); }; } diff --git a/Nuake/src/Scene/Systems/PhysicsSystem.cpp b/Nuake/src/Scene/Systems/PhysicsSystem.cpp index c367fb5d..7145be31 100644 --- a/Nuake/src/Scene/Systems/PhysicsSystem.cpp +++ b/Nuake/src/Scene/Systems/PhysicsSystem.cpp @@ -96,11 +96,11 @@ namespace Nuake PhysicsManager::Get()->Step(ts); auto brushes = m_Scene->m_Registry.view(); - for (auto e : brushes) + for (auto e : brushes) { auto [transform, brush] = brushes.get(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(); - for (auto e2 : targetnameView) + for (auto e2 : targetnameView) { auto [ttransform, name] = targetnameView.get(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(); - for (auto e : bspTriggerView) + for (auto e : bspTriggerView) { auto [transform, brush, trigger] = bspTriggerView.get(e); trigger.GhostObject->ScanOverlap(); brush.Targets.clear(); auto targetnameView = m_Scene->m_Registry.view(); - for (auto e2 : targetnameView) + for (auto e2 : targetnameView) { auto [ttransform, name] = targetnameView.get(e2); @@ -156,7 +156,7 @@ namespace Nuake void PhysicsSystem::FixedUpdate(Timestep ts) { - + } void PhysicsSystem::Exit() diff --git a/Nuake/src/Window.cpp b/Nuake/src/Window.cpp index cfd82dc0..ba708582 100644 --- a/Nuake/src/Window.cpp +++ b/Nuake/src/Window.cpp @@ -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 Window::GetGBuffer() const - { - return m_GBuffer; - } - - Ref Window::GetDeferredBuffer() const - { - return m_DeferredBuffer; - } - Vector2 Window::GetSize() { int w, h = 0; @@ -149,19 +137,8 @@ namespace Nuake { m_Framebuffer = CreateRef(true, glm::vec2(1920, 1080)); m_Framebuffer->SetTexture(CreateRef(glm::vec2(1920, 1080), GL_RGB)); - m_GBuffer = CreateRef(false, Vector2(1920, 1080)); - m_GBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_DEPTH_COMPONENT), GL_DEPTH_ATTACHMENT); - m_GBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT0); - m_GBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT1); - m_GBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB), GL_COLOR_ATTACHMENT2); - - m_DeferredBuffer = CreateRef(true, Vector2(1920, 1080)); - m_DeferredBuffer->SetTexture(CreateRef(Vector2(1920, 1080), GL_RGB, GL_RGB16F, GL_FLOAT)); - - m_BloomFrameBuffer = CreateRef(false, Vector2(1920, 1080)); - m_BloomFrameBuffer->SetTexture(CreateRef(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 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(); - for (auto i : interfaceView) - { - InterfaceComponent& uInterface = interfaceView.get(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(); + // for (auto i : interfaceView) + // { + // InterfaceComponent& uInterface = interfaceView.get(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(); diff --git a/Nuake/src/Window.h b/Nuake/src/Window.h index d3ec4b3e..d1add3db 100644 --- a/Nuake/src/Window.h +++ b/Nuake/src/Window.h @@ -19,9 +19,6 @@ namespace Nuake GLFWwindow* m_Window; Ref m_Framebuffer; - Ref m_GBuffer; - Ref m_DeferredBuffer; - Ref m_BloomFrameBuffer; Ref m_Scene; Vector2 m_FramebufferOffset; @@ -42,8 +39,6 @@ namespace Nuake void EndDraw(); Ref GetFrameBuffer() const; - Ref GetGBuffer() const; - Ref GetDeferredBuffer() const; Vector2 GetSize(); Ref GetScene(); bool SetScene(Ref scene);