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

Rendering refactoring

Browse Source
This commit is contained in:
Antoine Pilote
2021-07-12 20:17:16 -04:00
parent c2ce3c9cb9
commit 38ceae6fa9
40 changed files with 504 additions and 632 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Editor/Editor.cpp
View File

@@ -1,4 +1,5 @@
#include <Engine.h>
#include "src/Core/Maths.h"
#include <src/Scene/Entities/Entity.h>
#include <src/Scene/Scene.h>
@@ -7,9 +8,9 @@
#include <src/Vendors/imgui/ImGuizmo.h>
#include <src/Scene/Components/Components.h>
#include <src/Core/Physics/PhysicsManager.h>
#include "../Scene/Components/BoxCollider.h"
#include "src/Scene/Components/BoxCollider.h"
#include "src/EditorInterface.h"
#include "../Core/Input.h"
#include "src/Core/Input.h"
#include <GLFW/glfw3.h>
#include <src/Vendors/glm/trigonometric.hpp>
#include <src/Scripting/ScriptingEngine.h>

20
Editor/resources/Shaders/basic.shader
View File

@@ -17,7 +17,6 @@ out vec3 v_Bitangent;
uniform mat4 u_Projection;
uniform mat4 u_View;
uniform mat4 u_Model;
uniform mat3 u_NormalMatrix;
void main()
{
@@ -77,25 +76,18 @@ struct Light {
// Debug
uniform int u_ShowNormal;
// Lights
const int MaxLight = 24;
uniform int LightCount = 0;
uniform Light Lights[MaxLight];
// Lighting
uniform vec3 u_AmbientColor;
uniform vec4 u_LightColor;
uniform vec3 u_LightDirection;
uniform float u_Exposure;
uniform float u_FogAmount;
// Specular
uniform samplerCube u_Skybox;
uniform samplerCube u_IrradianceMap;
uniform float u_Strength;
// Camera
uniform vec3 u_EyePosition;
uniform float u_Exposure;
// IBL
uniform samplerCube irradianceMap;
// Environmnent
uniform float u_FogAmount;
uniform samplerCube u_IrradianceMap;
uniform samplerCube prefilterMap;
uniform sampler2D brdfLUT;

59
Editor/src/EditorInterface.cpp
View File

@@ -1,28 +1,33 @@
#include "EditorInterface.h"
#include "src/Vendors/imgui/imgui.h"
#include <src/Vendors/imgui/ImGuizmo.h>
#include <src/Rendering/Textures/Texture.h>
#include <Engine.h>
#include <src/Scene/Components/LightComponent.h>
#include <src/Core/Physics/PhysicsManager.h>
#include <src/Scene/Components/Components.h>
#include <src/Vendors/glm/gtc/type_ptr.hpp>
#include <src/Vendors/glm/gtx/matrix_decompose.hpp>
#include "src/Scene/Entities/ImGuiHelper.h"
#include <map>
#include <src/Core/MaterialManager.h>
#include "../Resource/FontAwesome5.h"
#include <src/Scene/Components/BoxCollider.h>
#include <algorithm>
#include <Dependencies/GLEW/include/GL/glew.h>
#include "src/Resource/Project.h"
#include <src/Scene/Components/LuaScriptComponent.h>
#include <src/Core/Logger.h>
#include <src/Scene/Components/WrenScriptComponent.h>
#include "ProjectInterface.h"
#include <src/Scene/Systems/QuakeMapBuilder.h>
#include "EditorInterface.h"
#include "Engine.h"
#include "src/Core/Logger.h"
#include "src/Vendors/imgui/imgui.h"
#include "src/Vendors/imgui/ImGuizmo.h"
#include "src/Scene/Entities/ImGuiHelper.h"
#include "src/Rendering/Textures/Texture.h"
#include "src/Rendering/Textures/MaterialManager.h"
#include "src/Core/Physics/PhysicsManager.h"
#include "src/Vendors/glm/gtc/type_ptr.hpp"
#include "src/Vendors/glm/gtx/matrix_decompose.hpp"
#include "src/Resource/FontAwesome5.h"
#include "Dependencies/GLEW/include/GL/glew.h"
#include "src/Scene/Components/Components.h"
#include "src/Scene/Components/BoxCollider.h"
#include "src/Scene/Components/LuaScriptComponent.h"
#include "src/Scene/Components/WrenScriptComponent.h"
#include "src/Scene/Systems/QuakeMapBuilder.h"
#include "src/Scene/Components/LightComponent.h"
namespace Nuake {
Ref<UI::UserInterface> userInterface;
@@ -367,8 +372,8 @@ namespace Nuake {
if (ImGui::MenuItem("Light Component") && !m_SelectedEntity.HasComponent<LightComponent>())
m_SelectedEntity.AddComponent<LightComponent>();
ImGui::Separator();
if (ImGui::MenuItem("Model Component") && !m_SelectedEntity.HasComponent<ModelComponent>())
m_SelectedEntity.AddComponent<ModelComponent>();
if (ImGui::MenuItem("Mesh Component") && !m_SelectedEntity.HasComponent<MeshComponent>())
m_SelectedEntity.AddComponent<MeshComponent>();
if (ImGui::MenuItem("Quake map Component") && !m_SelectedEntity.HasComponent<QuakeMapComponent>())
m_SelectedEntity.AddComponent<QuakeMapComponent>();
ImGui::Separator();
@@ -411,12 +416,12 @@ namespace Nuake {
ImGui::Separator();
}
if (m_SelectedEntity.HasComponent<ModelComponent>()) {
if (m_SelectedEntity.HasComponent<MeshComponent>()) {
std::string icon = ICON_FA_MALE;
if (ImGui::CollapsingHeader((icon + " " + "Model").c_str(), ImGuiTreeNodeFlags_DefaultOpen))
if (ImGui::CollapsingHeader((icon + " " + "Mesh").c_str(), ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::TextColored(ImGui::GetStyleColorVec4(1), "Model properties");
auto& component = m_SelectedEntity.GetComponent<ModelComponent>();
ImGui::TextColored(ImGui::GetStyleColorVec4(1), "Mesh properties");
auto& component = m_SelectedEntity.GetComponent<MeshComponent>();
// Path
std::string path = component.ModelPath;
char pathBuffer[256];

6
Editor/src/FileSystemUI.cpp
View File

@@ -3,10 +3,10 @@
#include <src/Vendors/imgui/imgui.h>
#include <src/Vendors/imgui/imgui_internal.h>
#include <src/Resource/FontAwesome5.h>
#include "src/Resource/FontAwesome5.h"
#include "src/Scene/Components/ParentComponent.h"
#include <src/Rendering/Textures/Texture.h>
#include <src/Core/TextureManager.h>
#include "src/Rendering/Textures/Texture.h"
#include "src/Rendering/Textures/TextureManager.h"
#include "EditorInterface.h"
namespace Nuake {

21
Nuake/Engine.cpp
View File

@@ -2,12 +2,12 @@
#include "src/Core/Physics/PhysicsManager.h"
#include <GLFW/glfw3.h>
#include "../Core/Input.h"
#include "src/Core/Input.h"
#include "src/Core/FileSystem.h"
#include "src/Scripting/ScriptingEngine.h"
#include "../Rendering/Renderer.h"
#include "../Rendering/Renderer2D.h"
#include "src/Rendering/Renderer.h"
#include "src/Rendering/Renderer2D.h"
#include <imgui/imgui_impl_glfw.h>
#include <imgui/imgui_impl_opengl3.h>
@@ -45,7 +45,6 @@ namespace Nuake
if (!CurrentWindow->GetScene())
return;
// Calculate delta time
float time = (float)glfwGetTime();
Timestep timestep = time - m_LastFrameTime;
m_LastFrameTime = time;
@@ -74,11 +73,13 @@ namespace Nuake
void Engine::EnterPlayMode()
{
// Dont trigger init if already in player mode.
if (!IsPlayMode)
if (GetCurrentScene()->OnInit())
IsPlayMode = true;
else
GetCurrentScene()->OnExit();
if (IsPlayMode)
return;
if (GetCurrentScene()->OnInit())
IsPlayMode = true;
else
GetCurrentScene()->OnExit();
}
void Engine::ExitPlayMode()
@@ -90,7 +91,6 @@ namespace Nuake
}
Input::ShowMouse();
IsPlayMode = false;
}
@@ -107,7 +107,6 @@ namespace Nuake
void Engine::EndDraw()
{
// Swap buffer and draw imgui
Window::Get()->EndDraw();
}

10
Nuake/Engine.h
View File

@@ -8,16 +8,12 @@
/* TODOS:
*
* Engine:
* Scripting API for all component
* Scripting API for editing UI maybe
* Launch game standalone
* Fix physics system
* trenchbroom physics element
*
*
*/
// Welcome to the Nuake source code. This is the entry point for the engine.
// Welcome to the Nuake source code.
namespace Nuake
{
class Engine {
@@ -30,7 +26,7 @@ namespace Nuake
static float m_FixedUpdateRate;
static float m_FixedUpdateDifference;
public:
static bool IsPlayMode; // True if currently playing the game.
static bool IsPlayMode; // Is currently in runtime..
static void Init(); // Initialize the engine.
static void Tick(); // Updates everything, called everyframe.
@@ -45,11 +41,9 @@ namespace Nuake
static Ref<Window> GetCurrentWindow();
// Load a specific scene
static bool LoadScene(Ref<Scene> scene);
static Ref<Scene> GetCurrentScene();
// Loads a project and the default scene.
static bool LoadProject(Ref<Project> project);
static Ref<Project> GetProject();
};

40
Nuake/src/Core/String.cpp Normal file
View File

@@ -0,0 +1,40 @@
#include "String.h"
#include <iostream>
#include <sstream>
namespace Nuake {
bool String::BeginsWith(const std::string& string, const std::string& begin)
{
if (string.rfind(begin, 0) == 0)
return true;
return false;
}
bool String::EndsWith(const std::string& string, const std::string& end)
{
if (string.length() >= end.length())
return (0 == string.compare(string.length() - end.length(), end.length(), end));
else
return false;
}
std::vector<std::string> String::Split(const std::string& string, char delimiter)
{
std::vector<std::string> result;
std::stringstream ss(string);
std::string item;
while (getline(ss, item, delimiter))
{
result.push_back(item);
}
return result;
}
float String::ToFloat(const std::string& string)
{
return std::stof(string);
}
}

18
Nuake/src/Core/String.h Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#include <string>
#include <vector>
/*
This class purpose is to provide helper methods related to strings.
It is not meant to be a replacement for std::string.
*/
namespace Nuake {
class String {
public:
static bool BeginsWith(const std::string& string, const std::string& begin);
static bool EndsWith(const std::string& string, const std::string& end);
static std::vector<std::string> Split(const std::string& string, char delimiter);
static float ToFloat(const std::string& string);
};
}

11
Nuake/src/Rendering/Materials/Material.h Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
namespace Nuake {
class Material
{
public:
virtual void Bind();
private:
};
}

16
Nuake/src/Rendering/Materials/PBRMaterial.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
#include "src/Core/Core.h"
#include "src/Rendering/Shaders/Shader.h"
namespace Nuake {
class PBRMaterial
{
public:
static Ref<Shader> mShader;
PBRMaterial();
void Bind();
private:
};
}

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

@@ -1,8 +1,6 @@
#include "Mesh.h"
#include <GL\glew.h>
#include "src/Rendering/Renderer.h"
#include "src/Core/MaterialManager.h"
#include "src/Rendering/Textures/MaterialManager.h"
namespace Nuake
{

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

@@ -1,16 +1,17 @@
#pragma once
#include <vector>
#include <map>
#include "src/Core/Maths.h"
#include "src/Core/Core.h"
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Mesh/Mesh.h"
#include "src/Rendering/Shaders/ShaderManager.h"
namespace Nuake
{
struct RenderMesh
{
Ref<Mesh> Mesh;
Matrix4 transform;
};
class RenderList
@@ -18,15 +19,36 @@ namespace Nuake
public:
RenderList()
{
this->m_RenderList = std::map<Ref<Material>, std::vector<Ref<Mesh>>>();
this->m_RenderList = std::map<Ref<Material>, std::vector<RenderMesh>>();
}
void AddToRenderList(Ref<Mesh> mesh)
void AddToRenderList(Ref<Mesh> mesh, Matrix4 transform)
{
if (m_RenderList.find(mesh->m_Material) == m_RenderList.end())
m_RenderList[mesh->m_Material] = std::vector<RenderMesh>();
m_RenderList[mesh->m_Material].push_back({mesh, transform});
}
void Flush()
{
Ref<Shader> pbrShader = ShaderManager::GetShader("resources/Shaders/basic.shader");
pbrShader->Bind();
for (auto& i : m_RenderList)
{
i.first->Bind();
for (auto& m : i.second)
{
pbrShader->SetUniformMat4f("u_Model", m.transform);
m.Mesh->Draw(false);
}
}
m_RenderList.clear();
}
private:
std::map<Ref<Material>, std::vector<Ref<Mesh>>> m_RenderList;
std::map<Ref<Material>, std::vector<RenderMesh>> m_RenderList;
};
}

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

@@ -30,11 +30,10 @@ namespace Nuake
VertexArray* Renderer::QuadVertexArray;
VertexBuffer* Renderer::QuadVertexBuffer;
VertexArray* Renderer::CubeVertexArray;
VertexBuffer* Renderer::CubeVertexBuffer;
unsigned int CubeVAO;
unsigned int CubeVBO;
unsigned int QuadVAO;
unsigned int QuadVBO;
RenderList Renderer::m_RenderList = RenderList();
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),
@@ -67,29 +66,22 @@ namespace Nuake
LoadShaders();
m_Shader->Bind();
// TODO: Use buffer abstraction.
// Setup buffers
glGenVertexArrays(1, &CubeVAO);
glBindVertexArray(CubeVAO);
glGenBuffers(1, &CubeVBO);
glBindBuffer(GL_ARRAY_BUFFER, CubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(CubeVertices), CubeVertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)0);
glEnableVertexAttribArray(0);
// Create quad buffer
QuadVertexArray = new VertexArray();
QuadVertexArray->Bind();
QuadVertexBuffer = new VertexBuffer(QuadVertices, sizeof(QuadVertices));
// Cube buffer
CubeVertexArray = new VertexArray();
CubeVertexArray->Bind();
CubeVertexBuffer = new VertexBuffer(CubeVertices, sizeof(CubeVertices));
VertexBufferLayout vblayout = VertexBufferLayout();
vblayout.Push<float>(3);
CubeVertexArray->AddBuffer(*CubeVertexBuffer, vblayout);
// Quad buffer
QuadVertexArray = new VertexArray();
QuadVertexArray->Bind();
QuadVertexBuffer = new VertexBuffer(QuadVertices, sizeof(QuadVertices));
vblayout = VertexBufferLayout();
vblayout.Push<float>(3);
vblayout.Push<float>(2);
QuadVertexArray->AddBuffer(*QuadVertexBuffer, vblayout);
}
@@ -106,6 +98,16 @@ namespace Nuake
m_Shader = ShaderManager::GetShader("resources/Shaders/basic.shader");
}
void Renderer::SubmitMesh(Ref<Mesh> mesh, Matrix4 transform)
{
m_RenderList.AddToRenderList(mesh, transform);
}
void Renderer::Flush()
{
m_RenderList.Flush();
}
void Renderer::BeginDraw(Ref<Camera> camera)
{
RenderCommand::Clear();
@@ -118,7 +120,7 @@ namespace Nuake
void Renderer::EndDraw()
{
m_Lights.clear(); // Clean up lights.
m_Lights.clear();
}
// List of all lights queued to be used for rendering this frame.
@@ -131,12 +133,11 @@ namespace Nuake
m_Lights.push_back({ transform , light });
// What light idx is this?
int idx = m_Lights.size();
glm::vec3 direction = light.GetDirection();
glm::vec3 pos = transform.GlobalTranslation;
glm::mat4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
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);
@@ -173,12 +174,11 @@ namespace Nuake
{
m_Lights.push_back({ transform , light });
// What light idx is this?
int idx = m_Lights.size();
glm::vec3 direction = light.GetDirection();
glm::vec3 pos = transform.Translation;
glm::mat4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
Vector3 direction = light.GetDirection();
Vector3 pos = transform.Translation;
Matrix4 lightView = glm::lookAt(pos, pos - direction, Vector3(0.0f, 1.0f, 0.0f));
light.m_Framebuffer->GetTexture()->Bind(11);
@@ -201,25 +201,24 @@ namespace Nuake
void Renderer::DrawCube(TransformComponent transform, glm::vec4 color)
{
//glDisable(GL_DEPTH_TEST);
Ref<Window> window = Engine::GetCurrentWindow();
Ref<FrameBuffer> fb = window->GetFrameBuffer();
m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, color.a);
glBindVertexArray(CubeVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, 1.0f);
CubeVertexArray->Bind();
RenderCommand::DrawArrays(0, 36);
//glBindVertexArray(CubeVAO);
//glDrawArrays(GL_TRIANGLES, 0, 36);
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);
glLineWidth(4);
glDrawArrays(GL_TRIANGLES, 0, 36);
//m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, 1.0f);
// Turn off wireframe mode
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
//glPolygonMode(GL_FRONT, GL_LINE);
//glPolygonMode(GL_BACK, GL_LINE);
//glLineWidth(4);
//glDrawArrays(GL_TRIANGLES, 0, 36);
//
//// Turn off wireframe mode
//glPolygonMode(GL_FRONT, GL_FILL);
//glPolygonMode(GL_BACK, GL_FILL);
//glEnable(GL_DEPTH_TEST);
}

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

@@ -3,6 +3,7 @@
#include "src/Scene/Components/Components.h"
#include "src/Core/Core.h"
#include "Buffers/VertexArray.h"
#include "RenderList.h"
namespace Nuake
{
@@ -14,9 +15,13 @@ namespace Nuake
class Renderer
{
private:
static RenderList m_RenderList;
public:
static VertexArray* Renderer::QuadVertexArray;
static VertexBuffer* Renderer::QuadVertexBuffer;
static VertexArray* Renderer::CubeVertexArray;
static VertexBuffer* Renderer::CubeVertexBuffer;
static Ref<Shader> m_Shader;
static Ref<Shader> m_ShadowmapShader;
@@ -31,6 +36,7 @@ namespace Nuake
static void LoadShaders();
static void BeginScene();
static void SubmitMesh(Ref<Mesh> mesh, Matrix4 transform);
static void Flush();
// Drawing states
@@ -42,7 +48,7 @@ namespace Nuake
static void RegisterLight(TransformComponent transform, LightComponent light, Ref<Camera> cam);
static void RegisterDeferredLight(TransformComponent transform, LightComponent light, Camera* cam);
static void SubmitMesh(Ref<Mesh> mesh);
// Debug
static void DrawDebugLine(glm::vec3 start, glm::vec3 end, glm::vec4 color);

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

@@ -1,4 +1,4 @@
#include "../Core/MaterialManager.h"
#include "src/Rendering/Textures/MaterialManager.h"
#include "Material.h"
#include "src/Core/Maths.h"

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

@@ -1,5 +1,5 @@
#pragma once
#include "src/Core/TextureManager.h"
#include "src/Rendering/Textures/TextureManager.h"
#include "Texture.h"
#include "src/Core/Core.h"

0
Nuake/src/Core/MaterialManager.cpp → Nuake/src/Rendering/Textures/MaterialManager.cpp
View File

0
Nuake/src/Core/MaterialManager.h → Nuake/src/Rendering/Textures/MaterialManager.h
View File

0
Nuake/src/Core/TextureManager.cpp → Nuake/src/Rendering/Textures/TextureManager.cpp
View File

0
Nuake/src/Core/TextureManager.h → Nuake/src/Rendering/Textures/TextureManager.h
View File

23
Nuake/src/Resource/FGD/FGDClass.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "ClassProperty.h"
#include "src/Resource/Serializable.h"
#include <string>
#include "src/Core/String.h"
#include <vector>
namespace Nuake {
@@ -18,12 +18,13 @@ namespace Nuake {
public:
std::string Name;
std::string Description;
std::string Script = "";
std::string Class = "";
bool Visible = false;
bool Solid = false;
bool IsTrigger = false;
std::string Script = "";
std::string Class = "";
std::vector<ClassProperty> Properties;
FGDBrushEntity()
@@ -41,13 +42,15 @@ namespace Nuake {
json Serialize() override
{
BEGIN_SERIALIZE();
SERIALIZE_VAL(Name);
SERIALIZE_VAL(Description);
SERIALIZE_VAL(Visible);
SERIALIZE_VAL(Solid);
SERIALIZE_VAL(IsTrigger);
SERIALIZE_VAL(Script);
SERIALIZE_VAL(Class);
{
SERIALIZE_VAL(Name);
SERIALIZE_VAL(Description);
SERIALIZE_VAL(Script);
SERIALIZE_VAL(Class);
SERIALIZE_VAL(Visible);
SERIALIZE_VAL(Solid);
SERIALIZE_VAL(IsTrigger);
}
END_SERIALIZE();
}

2
Nuake/src/Resource/FGD/FGDFile.h
View File

@@ -73,7 +73,7 @@ namespace Nuake {
{
for (auto& b : BrushEntities)
{
if (b.Name == name)
if (name == b.Name)
return b;
}
}

16
Nuake/src/Scene/Components/BSPBrushComponent.h
View File

@@ -1,14 +1,14 @@
#pragma once
#include "../Core/Core.h"
#include "../Core/Maths.h"
#include "src/Core/Core.h"
#include "src/Core/Maths.h"
#include "../Rendering/Textures/Material.h"
#include "../Rendering/Mesh/Mesh.h"
#include <src/Core/Physics/Rigibody.h>
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Mesh/Mesh.h"
#include "src/Core/Physics/Rigibody.h"
namespace Nuake
{
class BSPBrushComponent {
namespace Nuake {
class BSPBrushComponent
{
public:
std::vector<Ref<Mesh>> Meshes;
std::vector< Ref<Material>> Materials;

2
Nuake/src/Scene/Components/BoxCollider.cpp
View File

@@ -1,2 +0,0 @@
#include "BoxCollider.h"

5
Nuake/src/Scene/Components/Components.cpp
View File

@@ -1,5 +0,0 @@
#pragma once
#include "Components.h"

6
Nuake/src/Scene/Components/Components.h
View File

@@ -1,12 +1,12 @@
#pragma once
#include <glm\ext\matrix_float4x4.hpp>
#include <string>
#include "BaseComponent.h"
#include "TransformComponent.h"
#include "LightComponent.h"
#include "CameraComponent.h"
#include "MeshComponent.h"
#include "ModelComponent.h"
#include "QuakeMap.h"
#include "RigidbodyComponent.h"
#include "SphereCollider.h"
@@ -15,10 +15,6 @@
#include "CharacterControllerComponent.h"
#include "ParentComponent.h"
#include "NameComponent.h"
#include <imgui/imgui.h>
#include "../Entities/Entity.h"
// TODO: include components here.

276
Nuake/src/Scene/Components/MeshComponent.cpp
View File

@@ -1,178 +1,138 @@
#include "MeshComponent.h"
#include <GL\glew.h>
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Renderer.h"
#include "src/Rendering/Vertex.h"
#include "src/Core/MaterialManager.h"
#include <imgui\imgui.h>
#include "src/Rendering/Textures/TextureManager.h"
namespace Nuake {
Vertex vertices[] = {
Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, -0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, 0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, 0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, 0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, -0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, 0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, -0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, -0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, -0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(0.5f, 0.5f, 0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
Vertex{ glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f },
};
void MeshComponent::LoadModel(const std::string path) {
//Assimp::Importer import;
//const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
//
//if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
//{
// printf("ERROR::ASSIMP::");
// return;
//}
//
//ProcessNode(scene->mRootNode, scene);
void MeshComponent::Draw()
{
for (auto m : meshes)
m->Draw();
}
unsigned int sphereVAO = 0;
unsigned int indexCount;
//void MeshComponent::ProcessNode(aiNode * node, const aiScene* scene)
//{
/// process all the node's meshes (if any)
//or (unsigned int i = 0; i < node->mNumMeshes; i++)
//
// aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
// meshes.push_back(ProcessNode(mesh, scene));
//
/// then do the same for each of its children
//or (unsigned int i = 0; i < node->mNumChildren; i++)
//
// ProcessNode(node->mChildren[i], scene);
//
//}
MeshComponent::MeshComponent() {
//BuildTangents();
// Setup buffers
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);
// UV
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 3));
glEnableVertexAttribArray(1);
// Normal
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 5));
glEnableVertexAttribArray(2);
// Tangent
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 8));
glEnableVertexAttribArray(3);
// Bitangent
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 11));
glEnableVertexAttribArray(4);
// Texture
glVertexAttribPointer(5, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 14));
glEnableVertexAttribArray(5);
//m_Material = MaterialManager::Get()->LoadMaterial("Planks");
}
void MeshComponent::BuildTangents()
void MeshComponent::LoadModel()
{
for (int i = 0; i < 36; i += 3) {
glm::vec3 pos1 = vertices[i].position;
glm::vec3 pos2 = vertices[i + 1].position;
glm::vec3 pos3 = vertices[i + 2].position;
this->meshes.clear();
Assimp::Importer import;
import.SetPropertyFloat("PP_GSN_MAX_SMOOTHING_ANGLE", 90);
const aiScene* scene = import.ReadFile(FileSystem::Root + ModelPath, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
glm::vec2 uv1 = vertices[i].uv;
glm::vec2 uv2 = vertices[i + 1].uv;
glm::vec2 uv3 = vertices[i + 2].uv;
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
{
Logger::Log("ASSIMP! Failed to load model" + std::string(import.GetErrorString()), CRITICAL);
return;
}
glm::vec3 edge1 = pos2 - pos1;
glm::vec3 edge2 = pos3 - pos1;
glm::vec2 deltaUV1 = uv2 - uv1;
glm::vec2 deltaUV2 = uv3 - uv1;
ProcessNode(scene->mRootNode, scene);
}
float f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
for (int j = 0; i < 3; i++)
{
vertices[i + j].tangent.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
vertices[i + j].tangent.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
vertices[i + j].tangent.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
vertices[i + j].bitangent.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
vertices[i + j].bitangent.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
vertices[i + j].bitangent.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
}
void MeshComponent::ProcessNode(aiNode* node, const aiScene* scene)
{
// process all the node's meshes (if any)
for (unsigned int i = 0; i < node->mNumMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
meshes.push_back(ProcessMesh(mesh, scene));
}
// then do the same for each of its children
for (unsigned int i = 0; i < node->mNumChildren; i++)
{
ProcessNode(node->mChildren[i], scene);
}
}
void MeshComponent::SetMaterial(const std::string materialName)
Ref<Mesh> MeshComponent::ProcessMesh(aiMesh* mesh, const aiScene* scene)
{
m_Material = MaterialManager::Get()->LoadMaterial(materialName);
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::vector<Texture> textures;
for (unsigned int i = 0; i < mesh->mNumVertices; i++)
{
Vertex vertex;
vertex.texture = 1.0f;
glm::vec3 vector;
vector.x = mesh->mVertices[i].x;
vector.y = mesh->mVertices[i].y;
vector.z = mesh->mVertices[i].z;
vertex.position = vector;
vector.x = mesh->mNormals[i].x;
vector.y = mesh->mNormals[i].y;
vector.z = mesh->mNormals[i].z;
vertex.normal = vector;
vector.x = mesh->mTangents[i].x;
vector.y = mesh->mTangents[i].y;
vector.z = mesh->mTangents[i].z;
vertex.tangent = vector;
vector.x = mesh->mBitangents[i].x;
vector.y = mesh->mBitangents[i].y;
vector.z = mesh->mBitangents[i].z;
vertex.bitangent = vector;
if (mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
{
glm::vec2 vec;
vec.x = mesh->mTextureCoords[0][i].x;
vec.y = mesh->mTextureCoords[0][i].y;
vertex.uv = vec;
}
else
vertex.uv = glm::vec2(0.0f, 0.0f);
vertices.push_back(vertex);
}
// process indices
for (unsigned int i = 0; i < mesh->mNumFaces; i++)
{
aiFace face = mesh->mFaces[i];
for (unsigned int j = 0; j < face.mNumIndices; j++)
indices.push_back(face.mIndices[j]);
}
// process material
if (mesh->mMaterialIndex >= 0)
{
aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
aiString str;
std::string directory = FileSystem::Root + this->ModelPath + "/../";
material->GetTexture(aiTextureType_DIFFUSE, 0, &str);
Ref<Material> newMaterial = CreateRef<Material>(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//material->GetTexture(aiTextureType_NORMALS, 0, &str);
//newMaterial->SetNormal(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//
//material->GetTexture(aiTextureType_METALNESS, 0, &str);
//newMaterial->SetMetalness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//
//material->GetTexture(aiTextureType_DIFFUSE_ROUGHNESS, 0, &str);
//newMaterial->SetRoughness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//material->GetTexture(aiTextureType_DISPLACEMENT, 0, &str);
//newMaterial->SetDisplacement(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//material->GetTexture(aiTextureType_AMBIENT_OCCLUSION, 0, &str);
//newMaterial->SetAO(TextureManager::Get()->GetTexture(directory + str.C_Str()));
return CreateRef<Mesh>(vertices, indices, newMaterial);
}
}
void MeshComponent::Draw(glm::mat4 projection, glm::mat4 view, glm::mat4 transform) {
std::vector<Texture*> MeshComponent::LoadMaterialTextures(aiMaterial* mat, aiTextureType type)
{
std::vector<Texture*> textures;
for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
{
aiString str;
mat->GetTexture(type, i, &str);
std::string fixedStr = std::string(str.C_Str());
Renderer::m_Shader->SetUniformMat4f("u_Model", transform);
m_Material->Bind();
//RenderSphere();
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
}
void MeshComponent::DrawEditor() {
int choice = 0;
ImGui::Combo("Material", (int*)&choice, "Marble\0Copper\0Gold\0Paving\0Planks\0Default Material");
Texture* texture = new Texture(directory + fixedStr);
textures.push_back(texture);
}
return textures;
}
}

40
Nuake/src/Scene/Components/MeshComponent.h
View File

@@ -1,24 +1,30 @@
#pragma once
#include "../Rendering/Textures/Material.h"
#include <glm\ext\matrix_float4x4.hpp>
#include "BaseComponent.h"
#include <vector>
#include "src/Rendering/Mesh/Mesh.h"
namespace Nuake {
class MeshComponent {
#include "assimp/Importer.hpp"
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <string>
private:
unsigned int VAO;
unsigned int VBO;
Ref<Material> m_Material;
namespace Nuake
{
struct MeshComponent
{
std::string ModelPath;
void BuildTangents();
public:
void LoadModel(const std::string path);
//void ProcessNode(aiNode* node, const aiScene* scene);
MeshComponent();
MeshComponent()
{
//loadModel(path);
}
void LoadModel();
void Draw();
std::vector<Ref<Mesh>> meshes;
std::string directory;
void SetMaterial(const std::string materialName);
void Draw(glm::mat4 projection, glm::mat4 view, glm::mat4 transform);
void DrawEditor();
};
void ProcessNode(aiNode* node, const aiScene* scene);
Ref<Mesh> ProcessMesh(aiMesh* mesh, const aiScene* scene);
std::vector<Texture*> LoadMaterialTextures(aiMaterial* mat, aiTextureType type);
};
}

139
Nuake/src/Scene/Components/ModelComponent.cpp
View File

@@ -1,139 +0,0 @@
#include "ModelComponent.h"
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Renderer.h"
#include "src/Core/TextureManager.h"
namespace Nuake {
void ModelComponent::Draw()
{
for (auto m : meshes) {
m.Draw();
}
}
void ModelComponent::LoadModel()
{
this->meshes.clear();
Assimp::Importer import;
import.SetPropertyFloat("PP_GSN_MAX_SMOOTHING_ANGLE", 90);
const aiScene* scene = import.ReadFile(FileSystem::Root + ModelPath, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
{
Logger::Log("ASSIMP! Failed to load model" + std::string(import.GetErrorString()), CRITICAL);
return;
}
ProcessNode(scene->mRootNode, scene);
}
void ModelComponent::ProcessNode(aiNode* node, const aiScene* scene)
{
// process all the node's meshes (if any)
for (unsigned int i = 0; i < node->mNumMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
meshes.push_back(ProcessMesh(mesh, scene));
}
// then do the same for each of its children
for (unsigned int i = 0; i < node->mNumChildren; i++)
{
ProcessNode(node->mChildren[i], scene);
}
}
Mesh ModelComponent::ProcessMesh(aiMesh* mesh, const aiScene* scene)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::vector<Texture> textures;
for (unsigned int i = 0; i < mesh->mNumVertices; i++)
{
Vertex vertex;
vertex.texture = 1.0f;
glm::vec3 vector;
vector.x = mesh->mVertices[i].x;
vector.y = mesh->mVertices[i].y;
vector.z = mesh->mVertices[i].z;
vertex.position = vector;
vector.x = mesh->mNormals[i].x;
vector.y = mesh->mNormals[i].y;
vector.z = mesh->mNormals[i].z;
vertex.normal = vector;
vector.x = mesh->mTangents[i].x;
vector.y = mesh->mTangents[i].y;
vector.z = mesh->mTangents[i].z;
vertex.tangent = vector;
vector.x = mesh->mBitangents[i].x;
vector.y = mesh->mBitangents[i].y;
vector.z = mesh->mBitangents[i].z;
vertex.bitangent = vector;
if (mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
{
glm::vec2 vec;
vec.x = mesh->mTextureCoords[0][i].x;
vec.y = mesh->mTextureCoords[0][i].y;
vertex.uv = vec;
}
else
vertex.uv = glm::vec2(0.0f, 0.0f);
vertices.push_back(vertex);
}
// process indices
for (unsigned int i = 0; i < mesh->mNumFaces; i++)
{
aiFace face = mesh->mFaces[i];
for (unsigned int j = 0; j < face.mNumIndices; j++)
indices.push_back(face.mIndices[j]);
}
// process material
if (mesh->mMaterialIndex >= 0)
{
aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
aiString str;
std::string directory = FileSystem::Root + this->ModelPath + "/../";
material->GetTexture(aiTextureType_DIFFUSE, 0, &str);
Ref<Material> newMaterial = CreateRef<Material>(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//material->GetTexture(aiTextureType_NORMALS, 0, &str);
//newMaterial->SetNormal(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//
//material->GetTexture(aiTextureType_METALNESS, 0, &str);
//newMaterial->SetMetalness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//
//material->GetTexture(aiTextureType_DIFFUSE_ROUGHNESS, 0, &str);
//newMaterial->SetRoughness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//material->GetTexture(aiTextureType_DISPLACEMENT, 0, &str);
//newMaterial->SetDisplacement(TextureManager::Get()->GetTexture(directory + str.C_Str()));
//material->GetTexture(aiTextureType_AMBIENT_OCCLUSION, 0, &str);
//newMaterial->SetAO(TextureManager::Get()->GetTexture(directory + str.C_Str()));
return Mesh(vertices, indices, newMaterial);
}
}
std::vector<Texture*> ModelComponent::LoadMaterialTextures(aiMaterial* mat, aiTextureType type)
{
std::vector<Texture*> textures;
for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
{
aiString str;
mat->GetTexture(type, i, &str);
std::string fixedStr = std::string(str.C_Str());
Texture* texture = new Texture(directory + fixedStr);
textures.push_back(texture);
}
return textures;
}
}

32
Nuake/src/Scene/Components/ModelComponent.h
View File

@@ -1,32 +0,0 @@
#pragma once
#include <glm\ext\matrix_float4x4.hpp>
#include <vector>
#include "src/Rendering/Mesh/Mesh.h"
#include "assimp/Importer.hpp"
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <string>
namespace Nuake
{
class ModelComponent
{
public:
std::string ModelPath;
ModelComponent()
{
//loadModel(path);
}
void LoadModel();
void Draw();
private:
std::vector<Mesh> meshes;
std::string directory;
void ProcessNode(aiNode* node, const aiScene* scene);
Mesh ProcessMesh(aiMesh* mesh, const aiScene* scene);
std::vector<Texture*> LoadMaterialTextures(aiMaterial* mat, aiTextureType type);
};
}

2
Nuake/src/Scene/Components/NameComponent.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include "src/Resource/Serializable.h"
#include "src/Core/OS.h"
#include "src/Resource/Serializable.h"
namespace Nuake {
class NameComponent

2
Nuake/src/Scene/Components/QuakeMap.cpp
View File

@@ -1,6 +1,4 @@
#include "QuakeMap.h"
#include "src/Core/Core.h"
#include "src/Core/MaterialManager.h"
namespace Nuake {
void QuakeMapComponent::Draw()

9
Nuake/src/Scene/Components/QuakeMap.h
View File

@@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <vector>
#include "../Rendering/Mesh/Mesh.h"
#include "../Resource/TrenchbroomMap.h"
#include "../Resource/Serializable.h"
#include <src/Scene/Systems/QuakeMapBuilder.h>
#include "src/Rendering/Mesh/Mesh.h"
#include "src/Resource/Serializable.h"
#include "src/Scene/Systems/QuakeMapBuilder.h"
namespace Nuake {
class QuakeMapComponent
@@ -13,7 +13,6 @@ namespace Nuake {
public:
std::vector<Ref<Mesh>> m_Meshes;
Ref<TrenchbroomMap> Map;
std::string Path;
bool HasCollisions = false;
void Load(std::string path, bool collisions);

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

@@ -1,23 +1,24 @@
#pragma once
#include <src/Scene/Systems/ScriptingSystem.h>
#include <src/Scene/Systems/PhysicsSystem.h>
#include <src/Scene/Systems/TransformSystem.h>
#include "src/Scene/Systems/ScriptingSystem.h"
#include "src/Scene/Systems/PhysicsSystem.h"
#include "src/Scene/Systems/TransformSystem.h"
#include <src/Scene/Systems/QuakeMapBuilder.h>
#include <src/Scene/Components/BSPBrushComponent.h>
#include "src/Scene/Systems/QuakeMapBuilder.h"
#include "src/Scene/Components/BSPBrushComponent.h"
#include "Scene.h"
#include "Entities/Entity.h"
#include "../Rendering/Renderer.h"
#include "../Core/MaterialManager.h"
#include "../Core/Physics/PhysicsManager.h"
#include "../Core/Core.h"
#include "src/Rendering/Renderer.h"
#include "src/Rendering/Textures/MaterialManager.h"
#include "src/Core/Physics/PhysicsManager.h"
#include "src/Core/Core.h"
#include <GL/glew.h>
#include "../../Engine.h"
#include "../Core/FileSystem.h"
#include "Engine.h"
#include "Engine.h"
#include "src/Core/FileSystem.h"
#include "Components/Components.h"
#include "Components/BoxCollider.h"
#include "Components/LuaScriptComponent.h"
@@ -26,7 +27,7 @@
#include <fstream>
#include <streambuf>
#include <chrono>
#include <src/Core/OS.h>
#include "src/Core/OS.h"
namespace Nuake {
Ref<Scene> Scene::New()
@@ -157,7 +158,7 @@ namespace Nuake {
void Scene::DrawShadows()
{
auto modelView = m_Registry.view<TransformComponent, ModelComponent>();
auto meshView = m_Registry.view<TransformComponent, MeshComponent>();
auto quakeView = m_Registry.view<TransformComponent, QuakeMapComponent>();
auto view = m_Registry.view<TransformComponent, LightComponent>();
@@ -185,12 +186,12 @@ namespace Nuake {
light.m_Framebuffers[i]->Bind();
light.m_Framebuffers[i]->Clear();
Renderer::m_ShadowmapShader->SetUniformMat4f("lightSpaceMatrix", light.mViewProjections[i]);
for (auto e : modelView)
for (auto e : meshView)
{
auto [transform, model] = modelView.get<TransformComponent, ModelComponent>(e);
auto [transform, mesh] = meshView.get<TransformComponent, MeshComponent>(e);
Renderer::m_ShadowmapShader->SetUniformMat4f("model", transform.GetTransform());
model.Draw();
mesh.Draw();
}
std::vector<BSPDrawObject> sortedBrushes = std::vector<BSPDrawObject>();
@@ -288,13 +289,18 @@ namespace Nuake {
{
Renderer::m_Shader->SetUniform1f("u_Exposure", cam->Exposure);
auto view = m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view) {
auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
auto [transform, model, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
Renderer::m_Shader->SetUniformMat4f("u_View", cam->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", cam->GetPerspective());
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
for (auto& m : model.meshes)
{
Renderer::SubmitMesh(m, transform.GetTransform());
}
model.Draw();
}
@@ -306,29 +312,22 @@ namespace Nuake {
if (model.IsTransparent)
continue;
float dist = glm::length(transform.GlobalTranslation - cam->GetTranslation());
sortedBrushes.push_back({
dist,
model,
transform.GetTransform()
});
}
std::sort(sortedBrushes.begin(), sortedBrushes.end(), DepthSort);
for (auto& b : sortedBrushes)
{
Renderer::m_Shader->SetUniformMat4f("u_View", cam->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", cam->GetPerspective());
Renderer::m_Shader->SetUniformMat4f("u_Model", b.transform);
for (auto& e : b.brush.Meshes)
e->Draw();
for (auto& b : model.Meshes)
{
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
Renderer::SubmitMesh(b, transform.GetTransform());
}
}
Renderer::m_DebugShader->SetUniformMat4f("u_View", cam->GetTransform());
Renderer::m_DebugShader->SetUniformMat4f("u_Projection", cam->GetPerspective());
Renderer::Flush();
PhysicsManager::Get()->DrawDebug();
}
}
@@ -340,26 +339,23 @@ namespace Nuake {
glDisable(GL_CULL_FACE);
if (env->ProceduralSkybox)
{
env->ProceduralSkybox->Draw(m_EditorCamera);
}
Renderer::m_Shader->Bind();
env->Push();
glEnable(GL_DEPTH_TEST);
// Push lights
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view)
{
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view) {
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
light.Draw(transform, m_EditorCamera);
}
light.Draw(transform, m_EditorCamera);
}
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
Renderer::m_Shader->Bind();
@@ -368,50 +364,38 @@ namespace Nuake {
{
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);
auto view = m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
for (auto e : view) {
auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
for (auto e : view)
{
auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
Renderer::m_Shader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
model.Draw();
for(auto& m : mesh.meshes)
Renderer::SubmitMesh(m, transform.GetTransform());
}
std::vector<BSPDrawObject> sortedBrushes = std::vector<BSPDrawObject>();
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView) {
for (auto e : quakeView)
{
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
if (model.IsTransparent)
continue;
float dist = glm::length(transform.GlobalTranslation - m_EditorCamera->GetTranslation());
sortedBrushes.push_back({
dist,
model,
transform.GetTransform()
});
for (auto& b : model.Meshes)
Renderer::SubmitMesh(b, transform.GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
}
std::sort(sortedBrushes.begin(), sortedBrushes.end(), DepthSort);
for (auto& b : sortedBrushes)
{
Renderer::m_Shader->SetUniformMat4f("u_Model", b.transform);
for (auto& d : b.brush.Meshes)
d->Draw();
}
Renderer::m_DebugShader->Bind();
auto boxCollider = m_Registry.view<TransformComponent, BoxColliderComponent, ParentComponent>();
for (auto e : boxCollider) {
for (auto e : boxCollider)
{
auto [transform, box, parent] = boxCollider.get<TransformComponent, BoxColliderComponent, ParentComponent>(e);
Renderer::m_DebugShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_DebugShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
@@ -424,7 +408,8 @@ namespace Nuake {
}
auto sphereCollider = m_Registry.view<TransformComponent, SphereColliderComponent, ParentComponent>();
for (auto e : sphereCollider) {
for (auto e : sphereCollider)
{
auto [transform, box, parent] = sphereCollider.get<TransformComponent, SphereColliderComponent, ParentComponent>(e);
Renderer::m_DebugShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
@@ -450,10 +435,12 @@ namespace Nuake {
Renderer::m_DebugShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
Renderer::m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
Renderer::m_DebugShader->SetUniform4f("u_Color", 1.f, 0.0f, 0.1f, 0.5f);
for (auto& e : model.Meshes) {
e->Draw();
}
for (auto& e : model.Meshes)
Renderer::SubmitMesh(e, transform.GetTransform());
}
Renderer::Flush();
}
}
@@ -495,12 +482,14 @@ namespace Nuake {
}
}
Entity Scene::CreateEmptyEntity() {
Entity Scene::CreateEmptyEntity()
{
Entity entity = { m_Registry.create(), this };
return entity;
}
Entity Scene::CreateEntity(const std::string& name) {
Entity Scene::CreateEntity(const std::string& name)
{
Entity entity = { m_Registry.create(), this };
// Must have transform

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

@@ -1,15 +1,18 @@
#pragma once
#include "../Rendering/Camera.h"
#include "Lighting/Environment.h"
#include <vector>
#include "src/Core/Core.h"
#include "src/Core/Maths.h"
#include "entt/entt.hpp"
#include "../Core/Core.h"
#include "src/Rendering/Camera.h"
#include "Lighting/Environment.h"
#include "EditorCamera.h"
#include "../Resource/Serializable.h"
#include "src/Resource/Serializable.h"
#include "src/UI/UserInterface.h"
#include "../Core/Maths.h"
#include <src/Scene/Systems/System.h>
#include "src/Scene/Systems/System.h"
namespace Nuake {
class Entity;

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

@@ -89,7 +89,6 @@ namespace Nuake
void PhysicsSystem::Update(Timestep ts)
{
// Update rigidbodies
PhysicsManager::Get()->Step(ts);
auto brushes = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();

64
Nuake/src/Scene/Systems/QuakeMapBuilder.cpp
View File

@@ -1,12 +1,12 @@
#include "QuakeMapBuilder.h"
#include <src/Scene/Scene.h>
#include <src/Scene/Entities/Entity.h>
#include <src/Scene/Components/QuakeMap.h>
#include <src/Scene/Components/ParentComponent.h>
#include <vector>
#include <iostream>
#include <sstream>
#include "src/Core/FileSystem.h"
#include "src/Core/String.h"
#include "src/Scene/Scene.h"
#include "src/Scene/Entities/Entity.h"
#include "src/Scene/Components/QuakeMap.h"
#include "src/Scene/Components/ParentComponent.h"
#include <vector>
extern "C" {
#include <libmap/h/map_parser.h>
@@ -14,32 +14,21 @@ extern "C" {
#include <libmap/h/surface_gatherer.h>
}
#include <src/Core/MaterialManager.h>
#include <src/Scene/Components/BSPBrushComponent.h>
#include <src/Scene/Components/TransformComponent.h>
#include <src/Scene/Components/LightComponent.h>
#include <src/Scene/Components/NameComponent.h>
#include <src/Scene/Components/TriggerZone.h>
#include <src/Resource/FGD/FGDClass.h>
#include <src/Scene/Components/WrenScriptComponent.h>
#include "src/Rendering/Textures/MaterialManager.h"
#include "src/Scene/Components/BSPBrushComponent.h"
#include "src/Scene/Components/TransformComponent.h"
#include "src/Scene/Components/LightComponent.h"
#include "src/Scene/Components/NameComponent.h"
#include "src/Scene/Components/TriggerZone.h"
#include "src/Resource/FGD/FGDClass.h"
#include "src/Scene/Components/WrenScriptComponent.h"
namespace Nuake {
Ref<Material> DefaultMaterial;
std::vector<std::string> split(const std::string& s, char delim)
{
std::vector<std::string> result;
std::stringstream ss(s);
std::string item;
while (getline(ss, item, delim))
{
result.push_back(item);
}
return result;
}
void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst,
Scene* scene, Entity& parent,
const std::string& target, const std::string& targetname)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
@@ -98,7 +87,9 @@ namespace Nuake {
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
}
void QuakeMapBuilder::CreateBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
void QuakeMapBuilder::CreateBrush(brush* brush, brush_geometry* brush_inst,
Scene* scene, Entity& parent,
const std::string& target, const std::string& targetname)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
@@ -191,7 +182,9 @@ namespace Nuake {
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
}
void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname, FGDBrushEntity fgdBrush)
void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst,
Scene* scene, Entity& parent,
const std::string& target, const std::string& targetname, FGDBrushEntity fgdBrush)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
@@ -373,12 +366,11 @@ namespace Nuake {
if (key == "origin")
{
// Positon split with space.
std::vector<std::string> splits = split(value, ' ');
std::vector<std::string> splits = String::Split(value, ' ');
float x = std::stof(splits[1]) * (1.f / 64.f);
float y = std::stof(splits[2]) * (1.f / 64.f);
float z = std::stof(splits[0]) * (1.f / 64.f);
float x = String::ToFloat(splits[1]) * (1.f / 64.f);
float y = String::ToFloat(splits[2]) * (1.f / 64.f);
float z = String::ToFloat(splits[0]) * (1.f / 64.f);
Vector3 position = Vector3(x, y, z);
newEntity.GetComponent<TransformComponent>().Translation = position;

14
Nuake/src/Scene/Systems/QuakeMapBuilder.h
View File

@@ -12,9 +12,17 @@ namespace Nuake {
class QuakeMapBuilder
{
private:
void CreateTrigger(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname);
void CreateBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname);
void CreateFuncBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname, FGDBrushEntity fgdBrush);
void CreateTrigger(brush* brush, brush_geometry* brush_inst,
Scene* scene, Entity& parent,
const std::string& target, const std::string& targetname);
void CreateBrush(brush* brush, brush_geometry* brush_inst,
Scene* scene, Entity& parent,
const std::string& target, const std::string& targetname);
void CreateFuncBrush(brush* brush, brush_geometry* brush_inst,
Scene* scene, Entity& parent,
const std::string& target, const std::string& targetname, FGDBrushEntity fgdBrush);
public:
QuakeMapBuilder() {}

1
Nuake/src/Window.cpp
View File

@@ -147,7 +147,6 @@ namespace Nuake {
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3));
glEnableVertexAttribArray(1);
// TODO: Style should move to editor
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
//io.Fonts->AddFontDefault();

3
Nuake/src/Window.h
View File

@@ -30,7 +30,6 @@ namespace Nuake
static Ref<Window> Get(); // Get the window instance
GLFWwindow* GetHandle();
bool ShouldClose();
int Init();
@@ -40,8 +39,6 @@ namespace Nuake
void EndDraw();
Ref<FrameBuffer> GetFrameBuffer() const;
Ref<Texture> GetSceneRenderTexture();
void DrawQuad();
Ref<Scene> GetScene();
bool SetScene(Ref<Scene> scene);