celisej567/Nuake
1
0
Fork 0
mirror of https://github.com/antopilo/Nuake.git synced 2026-09-09 20:08:57 +03:00
Code Issues Packages Projects Releases Wiki Activity

Added editor Gizmos, and shader manager

Browse Source
This commit is contained in:
Antoine Pilote
2021-07-10 19:27:13 -04:00
parent 935e0831a7
commit 81db910e7f
12 changed files with 170 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
Editor/Editor.cpp
View File

@@ -14,65 +14,73 @@
#include <src/Vendors/glm/trigonometric.hpp>
#include <src/Scripting/ScriptingEngine.h>
#include <src/Resource/FGD/FGDFile.h>
#include <src/Rendering/Shaders/ShaderManager.h>
#include <src/Rendering/Renderer.h>
int main()
{
//std::string TrenchbroomPath = "F:/TrenchBroom/";
//
//FGDFile file(TrenchbroomPath + "Games/Nuake/Nuake.fgd");
//
//FGDClass newClass(FGDClassType::Point, "light", "a nuake light");
//
//ClassProperty prop{
// "Intensity",
// ClassPropertyType::Integer,
// "Changes the light intensity"
//};
//
//newClass.AddProperty(prop);
//file.AddClass(newClass);
//
//file.Save();
Engine::Init();
EditorInterface editor;
editor.BuildFonts();
Ref<FrameBuffer> myFramebuffer = CreateRef<FrameBuffer>(true, Vector2(200, 200));
myFramebuffer->SetTexture(CreateRef<Texture>(Vector2(200, 200), GL_RGB));
Ref<Scene> myScene = CreateRef<Scene>();
// Register Gizmo textures
Ref<Texture> lightTexture = TextureManager::Get()->GetTexture("resources/Icons/Gizmo/Light.png");
Ref<Texture> camTexture = TextureManager::Get()->GetTexture("resources/Icons/Gizmo/Camera.png");
Ref<Shader> GuizmoShader = ShaderManager::GetShader("resources/Shaders/gizmo.shader");
while (!Engine::GetCurrentWindow()->ShouldClose())
{
Engine::Tick();
Engine::Draw();
if (Input::IsKeyPressed(GLFW_KEY_F8))
Engine::ExitPlayMode();
myFramebuffer->Bind();
myScene->EditorDraw();
Ref<FrameBuffer> sceneFramebuffer = Engine::GetCurrentWindow()->GetFrameBuffer();
sceneFramebuffer->Bind();
myFramebuffer->Unbind();
if (ImGui::Begin("hahahah"))
Ref<Scene> currentScene = Engine::GetCurrentScene();
if (currentScene && !Engine::IsPlayMode)
{
ImVec2 regionAvail = ImGui::GetContentRegionAvail();
glm::vec2 viewportPanelSize = glm::vec2(regionAvail.x, regionAvail.y);
if (myFramebuffer->GetSize() != viewportPanelSize)
myFramebuffer->QueueResize(viewportPanelSize);
Ref<Texture> texture = myFramebuffer->GetTexture();
ImGui::Image((void*)texture->GetID(), regionAvail, ImVec2(0, 1), ImVec2(1, 0));
}
ImGui::End();
editor.Draw();
GuizmoShader->Bind();
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
auto camView = currentScene->m_Registry.view<TransformComponent, CameraComponent>();
for (auto e : camView) {
auto [transformComponent, cam] = camView.get<TransformComponent, CameraComponent>(e);
GuizmoShader->SetUniformMat4f("model", transformComponent.GetTransform());
GuizmoShader->SetUniformMat4f("view", currentScene->m_EditorCamera->GetTransform());
GuizmoShader->SetUniformMat4f("projection", currentScene->m_EditorCamera->GetPerspective());
camTexture->Bind(2);
GuizmoShader->SetUniform1i("gizmo_texture", 2);
Renderer::DrawQuad(transformComponent.GetTransform());
}
auto view = currentScene->m_Registry.view<TransformComponent, LightComponent>();
for (auto e : view) {
auto [transformComponent, light] = view.get<TransformComponent, LightComponent>(e);
GuizmoShader->SetUniformMat4f("model", transformComponent.GetTransform());
GuizmoShader->SetUniformMat4f("view", currentScene->m_EditorCamera->GetTransform());
GuizmoShader->SetUniformMat4f("projection", currentScene->m_EditorCamera->GetPerspective());
lightTexture->Bind(2);
GuizmoShader->SetUniform1i("gizmo_texture", 2);
Renderer::DrawQuad(transformComponent.GetTransform());
}
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
GuizmoShader->Unbind();
}
sceneFramebuffer->Unbind();
editor.Draw();
Engine::EndDraw();
}

31
Editor/resources/Shaders/gizmo.shader Normal file
View File

@@ -0,0 +1,31 @@
#shader vertex
#version 460 core
layout(location = 0) in vec3 Position;
layout(location = 1) in vec2 UV;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
out sample vec2 a_UV;
void main()
{
a_UV = UV;
gl_Position = projection * view * model * vec4(Position, 1.0);
}
#shader fragment
#version 460 core
out vec4 FragColor;
in vec2 a_UV;
uniform sampler2D gizmo_texture;
void main()
{
vec4 px_color = texture(gizmo_texture, a_UV).rgba;
FragColor = px_color;
}

8
Nuake/src/Rendering/Framebuffer.cpp
View File

@@ -43,7 +43,6 @@ void FrameBuffer::SetTexture(Ref<Texture> texture, GLenum attachment)
keys.push_back(s.first);
size += 1;
}
}
if(size > 0)
@@ -53,13 +52,18 @@ void FrameBuffer::SetTexture(Ref<Texture> texture, GLenum attachment)
}
void FrameBuffer::Clear()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void FrameBuffer::Bind()
{
if (ResizeQueued)
UpdateSize(m_Size);
glBindFramebuffer(GL_FRAMEBUFFER, m_FramebufferID);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, m_Size.x, m_Size.y);
}

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

@@ -25,7 +25,7 @@ public:
Ref<Texture> GetTexture(GLenum attachment = 0x8CE0) { return m_Textures[(int)attachment]; }
void SetTexture(Ref<Texture> texture, GLenum attachment = 0x8CE0);
void Clear();
void Bind();
void Unbind();
void QueueResize(Vector2 size);

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

@@ -19,26 +19,35 @@ Shader* Renderer::m_DebugShader;
unsigned int CubeVAO;
unsigned int CubeVBO;
// Cube
unsigned int QuadVAO;
unsigned int QuadVBO;
glm::vec3 CubeVertices[36]{
glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(0.5f, -0.5f, -0.5f), glm::vec3(0.5f, 0.5f, -0.5f),
glm::vec3(0.5f, 0.5f, -0.5f), glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec3(-0.5f, -0.5f, -0.5f),
glm::vec3(-0.5f, -0.5f, 0.5f),glm::vec3(0.5f, -0.5f, 0.5f),glm::vec3(0.5f, 0.5f, 0.5f),
glm::vec3(0.5f, 0.5f, 0.5f),glm::vec3(-0.5f, 0.5f, 0.5f),glm::vec3(-0.5f, -0.5f, 0.5f),
glm::vec3(-0.5f, 0.5f, 0.5f),glm::vec3(-0.5f, 0.5f, -0.5f),glm::vec3(-0.5f, -0.5f, -0.5f),
glm::vec3(-0.5f, -0.5f, -0.5f),glm::vec3(-0.5f, -0.5f, 0.5f),glm::vec3(-0.5f, 0.5f, 0.5f),
glm::vec3(0.5f, 0.5f, 0.5f),glm::vec3(0.5f, 0.5f, -0.5f),glm::vec3(0.5f, -0.5f, -0.5f),
glm::vec3(0.5f, -0.5f, -0.5f),glm::vec3(0.5f, -0.5f, 0.5f),glm::vec3(0.5f, 0.5f, 0.5f),
glm::vec3(-0.5f, -0.5f, -0.5f),glm::vec3(0.5f, -0.5f, -0.5f),glm::vec3(0.5f, -0.5f, 0.5f),
glm::vec3(0.5f, -0.5f, 0.5f),glm::vec3(-0.5f, -0.5f, 0.5f),glm::vec3(-0.5f, -0.5f, -0.5f),
glm::vec3(-0.5f, 0.5f, -0.5f) ,glm::vec3(0.5f, 0.5f, -0.5f) ,glm::vec3(0.5f, 0.5f, 0.5f) ,
glm::vec3(0.5f, 0.5f, 0.5f) ,glm::vec3(-0.5f, 0.5f, 0.5f) ,glm::vec3(-0.5f, 0.5f, -0.5f)
glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec3(0.5f, -0.5f, 0.5f), glm::vec3(0.5f, 0.5f, 0.5f),
glm::vec3(0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, -0.5f, 0.5f),
glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec3(-0.5f, -0.5f, -0.5f),
glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, 0.5f),
glm::vec3(0.5f, 0.5f, 0.5f), glm::vec3(0.5f, 0.5f, -0.5f), glm::vec3(0.5f, -0.5f, -0.5f),
glm::vec3(0.5f, -0.5f, -0.5f), glm::vec3(0.5f, -0.5f, 0.5f), glm::vec3(0.5f, 0.5f, 0.5f),
glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(0.5f, -0.5f, -0.5f), glm::vec3(0.5f, -0.5f, 0.5f),
glm::vec3(0.5f, -0.5f, 0.5f), glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec3(-0.5f, -0.5f, -0.5f),
glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec3(0.5f, 0.5f, -0.5f), glm::vec3(0.5f, 0.5f, 0.5f),
glm::vec3(0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, -0.5f)
};
float QuadVertices[] = {
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f
};
unsigned int SphereVAO;
unsigned int SphereVBO;
glm::vec3 SphereVertices[360 * 6 + 6];
void Renderer::Init()
{
// TODO: Make shader storage somewhere.
@@ -65,36 +74,22 @@ void Renderer::Init()
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)0);
glEnableVertexAttribArray(0);
// WTF is this.
float r = 1.0f;
int index = 0;
for (int i = 0; i <= 360; i++) {
float ra = glm::radians((float)i );
float rb = glm::radians((float)i + 1);
glm::vec2 a = glm::vec2(sin(ra), cos(ra)) * r;
glm::vec2 b = glm::vec2(sin(rb), cos(rb)) * r;
SphereVertices[index] = glm::vec3(a.x, 0, a.y);
SphereVertices[index + 1] = glm::vec3(b.x, 0, b.y);
SphereVertices[index + 2] = glm::vec3(0, a.x, a.y);
SphereVertices[index + 3] = glm::vec3(0, b.x, b.y);
SphereVertices[index + 4] = glm::vec3(a.x, a.y, 0);
SphereVertices[index + 5] = glm::vec3(b.x, b.y, 0);
index += 6;
}
// Quad
glGenVertexArrays(1, &QuadVAO);
glBindVertexArray(QuadVAO);
glGenVertexArrays(1, &SphereVAO);
glBindVertexArray(SphereVAO);
glGenBuffers(1, &QuadVBO);
glBindBuffer(GL_ARRAY_BUFFER, QuadVBO);
glGenBuffers(1, &SphereVBO);
glBindBuffer(GL_ARRAY_BUFFER, SphereVBO);
glBindBuffer(GL_ARRAY_BUFFER, QuadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(QuadVertices), QuadVertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, SphereVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(SphereVertices), SphereVertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
}
// TODO: Move to shader storage
@@ -221,25 +216,11 @@ void Renderer::DrawCube(TransformComponent transform, glm::vec4 color)
// TODO: See above
void Renderer::DrawSphere(TransformComponent transform, glm::vec4 color)
{
//glDisable(GL_DEPTH_TEST);
Ref<Window> window = Engine::GetCurrentWindow();
Ref<FrameBuffer> fb = window->GetFrameBuffer();
m_DebugShader->Bind();
m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, color.a);
glBindVertexArray(SphereVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, 1.0f);
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);
glLineWidth(8);
glDrawArrays(GL_TRIANGLES, 0, 36);
// Turn off wireframe mode
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
//glEnable(GL_DEPTH_TEST);
}
void Renderer::DrawQuad(Matrix4 transform)
{
glBindVertexArray(QuadVAO);
glDrawArrays(GL_TRIANGLES, 0, 6);
}

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

@@ -2,7 +2,7 @@
#include "Shaders/Shader.h"
#include "../Scene/Components/Components.h"
#include "../Core/Core.h"
// DTO for light data.
struct Light {
TransformComponent transform;
LightComponent light;
@@ -18,7 +18,6 @@ public:
static Shader* m_DeferredShader;
static Shader* m_ProceduralSkyShader;
static Shader* m_DebugShader;
static Texture* m_VXGI_Debugtexture;
static void Init();
@@ -26,7 +25,6 @@ public:
static void BeginDraw(Ref<Camera> camera);
static void EndDraw();
// Lights
static std::vector<Light> m_Lights;
static void RegisterLight(TransformComponent transform, LightComponent light, Ref<Camera> cam);
@@ -36,4 +34,5 @@ public:
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);
};

14
Nuake/src/Rendering/Shaders/ShaderManager.cpp Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
#include "ShaderManager.h"
std::map<std::string, Ref<Shader>> ShaderManager::m_Shaders = std::map<std::string, Ref<Shader>>();
Ref<Shader> ShaderManager::GetShader(const std::string& path)
{
if (m_Shaders.find(path) == m_Shaders.end())
{
m_Shaders[path] = CreateRef<Shader>(path);
}
return m_Shaders[path];
}

14
Nuake/src/Rendering/Shaders/ShaderManager.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
#include <map>
#include <string>
#include "src/Core/Core.h"
#include "Shader.h"
class ShaderManager {
private:
static std::map<std::string, Ref<Shader>> m_Shaders;
public:
static Ref<Shader> GetShader(const std::string& path);
};

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

@@ -170,6 +170,7 @@ void Scene::DrawShadows()
for (int i = 0; i < 4; i++)
{
light.m_Framebuffers[i]->Bind();
light.m_Framebuffers[i]->Clear();
Renderer::m_ShadowmapShader->SetUniformMat4f("lightSpaceMatrix", light.mViewProjections[i]);
for (auto e : modelView)
{

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

@@ -28,9 +28,8 @@ private:
std::vector<Ref<System>> m_Systems;
Ref<Environment> m_Environement;
Ref<EditorCamera> m_EditorCamera;
public:
Ref<EditorCamera> m_EditorCamera;
entt::registry m_Registry;
std::vector<Ref<UI::UserInterface>> m_Interfaces;
std::string Path = "";

4
Nuake/src/Scripting/ScriptingEngine.cpp
View File

@@ -145,6 +145,8 @@ void ScriptingEngine::ExitScript(Ref<WrenScript> script)
void ScriptingEngine::Init()
{
m_Scripts = std::map<std::string, Ref<WrenScript>>();
m_LoadedScripts.clear();
WrenConfiguration config;
wrenInitConfiguration(&config);
@@ -152,6 +154,7 @@ void ScriptingEngine::Init()
config.errorFn = &errorFn;
config.writeFn = &writeFn;
config.bindForeignMethodFn = &bindForeignMethod;
m_WrenVM = wrenNewVM(&config);
Ref<ScriptAPI::EngineModule> engineModule = CreateRef<ScriptAPI::EngineModule>();
@@ -166,7 +169,6 @@ void ScriptingEngine::Init()
RegisterModule(physicsModule);
}
void ScriptingEngine::Close()
{
wrenFreeVM(m_WrenVM);

19
Nuake/src/Window.cpp
View File

@@ -230,6 +230,7 @@ void Window::FixedUpdate(Timestep ts)
void Window::Draw()
{
// Dont render if no scene is loaded.
if (!m_Scene)
return;
@@ -242,21 +243,19 @@ void Window::Draw()
cam->AspectRatio = size.x / size.y;
Renderer::BeginDraw(cam);
//glCullFace(GL_FRONT);
//glCullFace(GL_BACK);
m_Scene->DrawShadows();
m_Framebuffer->Bind();
if (Engine::IsPlayMode)
m_Scene->Draw();
else
m_Scene->EditorDraw();
m_Framebuffer->Clear();
{
if (Engine::IsPlayMode)
m_Scene->Draw();
else
m_Scene->EditorDraw();
m_Scene->DrawInterface(m_Framebuffer->GetSize());
m_Scene->DrawInterface(m_Framebuffer->GetSize());
}
m_Framebuffer->Unbind();
Renderer::EndDraw();