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

Trenchbroom parser work with entities

Browse Source 
Fixed lighting
Fixed global position system
Fixed child deletion system.
editor work for custom entities registration
This commit is contained in:
Antoine Pilote
2021-06-23 17:37:54 -04:00
parent 1740a5707f
commit c7dc3cc476
35 changed files with 753 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
Editor/Editor.cpp
View File

@@ -18,32 +18,28 @@
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();
//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();
// ScriptingEngine::UpdateScript("test.lua");
EditorInterface editor;
editor.BuildFonts();
//CreateScene();
while (!Engine::GetCurrentWindow()->ShouldClose())
{
Engine::Tick();
@@ -56,8 +52,6 @@ int main()
editor.Draw();
Engine::EndDraw();
}
Engine::Close();

10
Editor/resources/Scenes/test.scene
View File

@@ -75,9 +75,9 @@
"z": 1.0
},
"Translation": {
"x": -359.2229919433594,
"y": -1.979316234588623,
"z": -322.51702880859375
"x": 0.0,
"y": 17.93589973449707,
"z": 0.0
},
"Type": "TransformComponent"
},
@@ -100,7 +100,7 @@
"TransformComponent": {
"Rotation": {
"x": 0.0,
"y": 0.0,
"y": -0.0,
"z": 0.0
},
"Scale": {
@@ -110,7 +110,7 @@
},
"Translation": {
"x": 9.199999809265137,
"y": 5.599999904632568,
"y": -11.569494247436523,
"z": 0.0
},
"Type": "TransformComponent"

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

@@ -1,10 +1,5 @@
#shader vertex
#version 460 core
// Have you ever seen Godot shader. The whole engine has ONE monolithic shader.
// Also, how do you want me to split this in multiple shaders lmao.
// Click upper right Round thing
// DO CODE REVIEW yep
// im following u daddy
layout(location = 0) in vec3 VertexPosition;
layout(location = 1) in vec2 UVPosition;
layout(location = 2) in vec3 Normal;
@@ -12,14 +7,13 @@ layout(location = 3) in vec3 Tangent;
layout(location = 4) in vec3 Bitangent;
out flat vec2 v_UVPosition;
out flat float v_TextureId;
out vec3 v_Normal;
out vec3 v_FragPos;
out vec3 v_ViewPos;
out mat3 v_TBN;
out mat3 v_WTBN;
out vec3 v_Tangent;
out vec3 v_Bitangent;
uniform mat4 u_Projection;
uniform mat4 u_View;
uniform mat4 u_Model;
@@ -43,12 +37,23 @@ void main()
gl_Position = u_Projection * u_View * u_Model * vec4(VertexPosition, 1.0f);
v_FragPos = vec3(u_Model * vec4(VertexPosition, 1.0f));
v_ViewPos = VertexPosition;
}
#shader fragment
#version 460 core
out vec4 FragColor;
in vec3 v_FragPos;
in vec3 v_ViewPos;
in vec2 v_UVPosition;
in flat vec3 v_Normal;
in mat3 v_TBN;
in vec3 v_Tangent;
in vec3 v_Bitangent;
const float PI = 3.141592653589793f;
struct Light {
int Type; // 0 = directional, 1 = point
vec3 Direction;
@@ -69,34 +74,23 @@ struct Light {
int Volumetric;
};
out vec4 FragColor;
// Textures
uniform sampler2D u_Textures[2];
// Debug
uniform int u_ShowNormal;
const int MaxLight = 20;
uniform int LightCount = 0;
uniform Light Lights[MaxLight];
// Debug
uniform int u_ShowNormal;
// Lighting
uniform vec3 u_AmbientColor;
uniform vec4 u_LightColor;
uniform vec3 u_LightDirection;
uniform float u_Exposure;
// Material
uniform vec3 albedo;
uniform float metallic;
uniform float roughness;
uniform float ao;
uniform float u_FogAmount;
// Specular
uniform samplerCube u_Skybox;
uniform samplerCube u_IrradianceMap;
uniform float u_Shininess;
uniform float u_Strength;
uniform vec3 u_EyePosition;
@@ -106,37 +100,29 @@ uniform samplerCube prefilterMap;
uniform sampler2D brdfLUT;
// Material
uniform int u_HasAlbedo; // I would advise against doing this stuff. just need default normal which is 0.5f 0.5f 1.0f.
uniform sampler2D m_Albedo; // yeah just think about it // normal maps are in tangent space which means the default should be a vector pointing straight towards the camera right? ie 0.0, 0.0, 1.0
uniform vec3 m_AlbedoColor;
uniform int u_HasMetalness; // But normal maps can also contain colors where the vectors face away such as vec3(0.2, 0.4, -1.0f) right? yeah
uniform sampler2D m_Metalness; // Well normal maps are stored as colors so you can't have negative values. So they are mapped from the range of -1 to 1, to 0 to 1
uniform float u_MetalnessValue;
uniform int u_HasRoughness; // That is why you do the [normal * 2.0f - 1.0f]; to put it into to range of -1 to 1. yeah 0 - 1 -> -1 - 1
uniform sampler2D m_Roughness; // So vec3(0.0, 0.0, 1.0) put into the range of 0 to 1 is (0.5, 0.5, 1.0). easy.
uniform float u_RoughnessValue;
uniform int u_HasAO;
uniform sampler2D m_Albedo;
uniform sampler2D m_Metalness;
uniform sampler2D m_Roughness;
uniform sampler2D m_AO;
uniform float u_AOValue;
uniform int u_HasNormal;
uniform sampler2D m_Normal;
uniform int u_HasDisplacement;
uniform sampler2D m_Displacement;
in vec3 v_FragPos;
in vec3 v_ViewPos;
in vec2 v_UVPosition;
in flat vec3 v_Normal;
in mat3 v_TBN;
in flat float v_TextureId;
layout(std140, binding = 32) uniform u_MaterialUniform
{
bool u_HasAlbedo;
vec3 m_AlbedoColor;
bool u_HasMetalness;
float u_MetalnessValue;
bool u_HasRoughness;
float u_RoughnessValue;
bool u_HasAO;
float u_AOValue;
bool u_HasNormal;
bool u_HasDisplacement;
};
in vec3 v_Tangent;
in vec3 v_Bitangent;
const float PI = 3.141592653589793f; // mark this as static const wait idk if you can do that in glsl
float height_scale = 0.00f;
vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir) // nice never done this // its easy Af its basicalyy returns a uv coords . that u use everywhere
{
// number of depth layers
@@ -276,35 +262,6 @@ float ShadowCalculation(Light light, vec3 FragPos, vec3 normal)
return shadow /= 9;
}
/*
float ShadowCalculation(vec4 fragPosLightSpace, sampler2D shadowMap, vec3 normal, vec3 lightDir)
{
// perform perspective divide
vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
// transform to [0,1] range
projCoords = projCoords * 0.5 + 0.5;
// get closest depth value from light's perspective (using [0,1] range fragPosLight as coords)
float closestDepth = texture(shadowMap, projCoords.xy).r;
// get depth of current fragment from light's perspective
float currentDepth = projCoords.z;
// check whether current frag pos is in shadow
float bias = max(0.005 * (1.0 - dot(normal, lightDir)), 0.0005);
float shadow = 0.0;
vec2 texelSize = 1.0 / textureSize(shadowMap, 0);
for (int x = -1; x <= 1; ++x)
{
for (int y = -1; y <= 1; ++y)
{
float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r;
shadow += currentDepth - bias > pcfDepth ? 1.0 : 0.0;
}
}
return shadow /= 9;
}
*/
uniform float u_FogAmount;
// Mie scaterring approximated with Henyey-Greenstein phase function.
float ComputeScattering(float lightDotView)
{
@@ -364,24 +321,22 @@ void main()
vec2 texCoords = v_UVPosition;//ParallaxMapping(v_UVPosition, viewDir);
vec2 finalTexCoords = texCoords;
vec3 finalAlbedo = m_AlbedoColor;
if(u_HasAlbedo == 1)
if(u_HasAlbedo)
finalAlbedo = texture(m_Albedo, finalTexCoords).rgb;
float finalRoughness = u_RoughnessValue;
if (u_HasRoughness == 1)
if (u_HasRoughness )
finalRoughness = texture(m_Roughness, finalTexCoords).r;
float finalMetalness = u_MetalnessValue;
if (u_HasMetalness == 1)
if (u_HasMetalness)
finalMetalness = texture(m_Metalness, finalTexCoords).r;
float finalAO = u_AOValue;
if (u_HasAO == 1)
if (u_HasAO)
finalAO = texture(m_AO, finalTexCoords).r;
vec3 finalNormal = texture(m_Normal, finalTexCoords).rgb;
finalNormal = finalNormal * 2.0 - 1.0;
finalNormal = v_TBN * normalize(finalNormal);
@@ -393,8 +348,6 @@ void main()
vec3 F0 = vec3(0.04);
F0 = mix(F0, finalAlbedo, finalMetalness);
// reflectance equation
vec3 eyeDirection = normalize(u_EyePosition - v_FragPos);
vec3 Fog = vec3(0.0);

46
Editor/src/EditorInterface.cpp
View File

@@ -22,6 +22,7 @@
#include <src/Scene/Components/WrenScriptComponent.h>
#include <src/Rendering/MSAAFramebuffer.h>
#include "ProjectInterface.h"
#include <src/Scene/Systems/QuakeMapBuilder.h>
Ref<UI::UserInterface> userInterface;
ImFont* normalFont;
ImFont* EditorInterface::bigIconFont;
@@ -161,6 +162,7 @@ void EditorInterface::DrawViewport()
if (m_IsEntitySelected && !Engine::IsPlayMode)
{
TransformComponent& tc = m_SelectedEntity.GetComponent<TransformComponent>();
ParentComponent& parent = m_SelectedEntity.GetComponent<ParentComponent>();
glm::mat4 oldTransform = tc.GetTransform();
ImGuizmo::Manipulate(
glm::value_ptr(Engine::GetCurrentScene()->GetCurrentCamera()->GetTransform()),
@@ -180,6 +182,20 @@ void EditorInterface::DrawViewport()
scale = glm::vec3(0, 0, 0);
rotation = glm::conjugate(rotation);
glm::vec3 euler = glm::eulerAngles(rotation);
Vector3 globalPos = Vector3();
Entity currentParent = m_SelectedEntity;
if (parent.HasParent)
{
while (currentParent.GetComponent<ParentComponent>().HasParent) {
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalPos -= currentParent.GetComponent<TransformComponent>().Translation;
}
translation = globalPos - translation;
}
tc.Translation = translation;
tc.Rotation = glm::vec3(glm::degrees(euler.x), glm::degrees(euler.y), glm::degrees(euler.z));
tc.Scale = scale;
@@ -188,6 +204,10 @@ void EditorInterface::DrawViewport()
}
else
{
ImGui::PopStyleVar();
}
ImGui::End();
@@ -590,7 +610,11 @@ void EditorInterface::DrawEntityPropreties()
ImGui::Checkbox("Build collisions?", &component.HasCollisions);
if (ImGui::Button("Build"))
component.Build();
{
QuakeMapBuilder mapBuilder;
mapBuilder.BuildQuakeMap(m_SelectedEntity);
}
ImGui::Separator();
}
}
@@ -888,9 +912,9 @@ void EditorInterface::DrawRessourceWindow()
std::string texture = FileDialog::OpenFile("*.png | *.jpg");
}
ImGui::SameLine();
ImGui::Checkbox("Use##1", &m_SelectedMaterial->UseAlbedo);
//ImGui::Checkbox("Use##1", &(bool)(m_SelectedMaterial->data.u_HasAlbedo));
ImGui::SameLine();
ImGui::ColorPicker4("Color", &m_SelectedMaterial->m_AlbedoColor.r);
ImGui::ColorPicker3("Color", &m_SelectedMaterial->data.m_AlbedoColor.r);
}
if (ImGui::CollapsingHeader("AO", ImGuiTreeNodeFlags_DefaultOpen))
{
@@ -906,9 +930,9 @@ void EditorInterface::DrawRessourceWindow()
}
}
ImGui::SameLine();
ImGui::Checkbox("Use##2", &m_SelectedMaterial->UseAO);
//ImGui::Checkbox("Use##2", &m_SelectedMaterial->data.u_HasAO);
ImGui::SameLine();
ImGui::DragFloat("Value##2", &m_SelectedMaterial->m_AOValue, 0.01f, 0.0f, 1.0f);
ImGui::DragFloat("Value##2", &m_SelectedMaterial->data.u_AOValue, 0.01f, 0.0f, 1.0f);
}
if (ImGui::CollapsingHeader("Normal", ImGuiTreeNodeFlags_DefaultOpen))
{
@@ -923,8 +947,8 @@ void EditorInterface::DrawRessourceWindow()
m_SelectedMaterial->SetNormal(TextureManager::Get()->GetTexture(texture));
}
}
ImGui::SameLine();
ImGui::Checkbox("Use##3", &m_SelectedMaterial->UseNormal);
//ImGui::SameLine();
//ImGui::Checkbox("Use##3", &m_SelectedMaterial->data.u_HasNormal);
}
if (ImGui::CollapsingHeader("Metalness", ImGuiTreeNodeFlags_DefaultOpen))
{
@@ -936,9 +960,9 @@ void EditorInterface::DrawRessourceWindow()
std::string texture = FileDialog::OpenFile("*.png | *.jpg");
}
ImGui::SameLine();
ImGui::Checkbox("Use##4", &m_SelectedMaterial->UseMetalness);
//ImGui::Checkbox("Use##4", &m_SelectedMaterial->data.u_HasMetalness);
ImGui::SameLine();
ImGui::DragFloat("Value##4", &m_SelectedMaterial->m_MetalnessValue, 0.01f, 0.0f, 1.0f);
ImGui::DragFloat("Value##4", &m_SelectedMaterial->data.u_MetalnessValue, 0.01f, 0.0f, 1.0f);
}
if (ImGui::CollapsingHeader("Roughness", ImGuiTreeNodeFlags_DefaultOpen))
{
@@ -950,9 +974,9 @@ void EditorInterface::DrawRessourceWindow()
std::string texture = FileDialog::OpenFile("*.png | *.jpg");
}
ImGui::SameLine();
ImGui::Checkbox("Use##5", &m_SelectedMaterial->UseRoughness);
//ImGui::Checkbox("Use##5", &m_SelectedMaterial->data.u_HasRoughness);
ImGui::SameLine();
ImGui::DragFloat("Value##5", &m_SelectedMaterial->m_RoughnessValue, 0.01f, 0.0f, 1.0f);
ImGui::DragFloat("Value##5", &m_SelectedMaterial->data.u_RoughnessValue, 0.01f, 0.0f, 1.0f);
}
}
else

28
Editor/src/ImGuiTextHelper.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include <vcruntime_string.h>
#include <string>
#include <src/Vendors/imgui/imgui.h>
void ImGuiTextSTD(const std::string& label, std::string& value)
{
char buffer[256];
memset(buffer, 0, sizeof(buffer));
std::strncpy(buffer, value.c_str(), sizeof(buffer));
if (ImGui::InputText(label.c_str(), buffer, sizeof(buffer)))
{
value = std::string(buffer);
}
}
void ImGuiTextMultiline(const std::string& label, std::string& value)
{
char buffer[256];
memset(buffer, 0, sizeof(buffer));
std::strncpy(buffer, value.c_str(), sizeof(buffer));
if (ImGui::InputTextMultiline(label.c_str(), buffer, sizeof(buffer)))
{
value = std::string(buffer);
}
}

71
Editor/src/ProjectInterface.cpp
View File

@@ -1,6 +1,7 @@
#include "ProjectInterface.h"
#include <src/Vendors/imgui/imgui.h>
#include "Engine.h"
#include "ImGuiTextHelper.h"
void ProjectInterface::DrawProjectSettings()
{
@@ -20,6 +21,7 @@ void ProjectInterface::DrawProjectSettings()
void ProjectInterface::DrawCreatePointEntity()
{
char buffer[256];
memset(buffer, 0, sizeof(buffer));
std::strncpy(buffer, Engine::GetProject()->Name.c_str(), sizeof(buffer));
@@ -30,32 +32,81 @@ void ProjectInterface::DrawCreatePointEntity()
}
FGDPointEntity newEntity;
const char* items[] = { "String", "Integer", "Float", "Boolean"};
void ProjectInterface::DrawEntitySettings()
{
if (ImGui::Begin("Entity definitions"))
{
ImGui::Text("This is the entity definition used by trenchbroom. This files allows you to see your entities inside Trenchbroom");
ImGui::Text("Trenchbroom path:");
// path here...
Ref<FGDFile> file = Engine::GetProject()->EntityDefinitionsFile;
auto flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize;
auto flags = ImGuiWindowFlags_NoTitleBar;
if (ImGui::BeginPopupModal("Create new point entity", NULL, flags))
{
ImGuiTextSTD("Name", newEntity.Name);
ImGuiTextMultiline("Description", newEntity.Description);
if (ImGui::BeginTable("DictCreate", 2, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable))
{
ImGui::TableSetupColumn("Name");
ImGui::TableSetupColumn("Type");
ImGui::TableHeadersRow();
ImGui::TableNextColumn();
int idx = 0;
for (auto& p : newEntity.Properties)
{
ImGuiTextSTD("Name", p.name);
ImGui::TableNextColumn();
std::string current_item = NULL;
if(ImGui::BeginCombo(("TypeSelection" + std::to_string(idx)).c_str(), current_item.c_str()))
{
for (int n = 0; n < IM_ARRAYSIZE(items); n++)
{
bool is_selected = (p.type == (ClassPropertyType)n); // You can store your selection however you want, outside or inside your objects
if (ImGui::Selectable(items[n], is_selected))
if (is_selected)
{
p.type = (ClassPropertyType)n;
ImGui::SetItemDefaultFocus();
}
}
ImGui::EndCombo();
}
idx++;
ImGui::TableNextColumn();
}
if (ImGui::Button("Add new property")) {
newEntity.Properties.push_back(ClassProperty());
}
ImGui::EndTable();
}
ImGui::Button("Create");
ImGui::SameLine();
ImGui::Button("Cancel");
if (ImGui::Button("Cancel"))
ImGui::CloseCurrentPopup();
ImGui::EndPopup();
}
ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 100));
if (ImGui::BeginTabBar("##Tabs", ImGuiTabBarFlags_None))
{
if (ImGui::BeginTabItem("Point entities"))
{
ImVec2 avail = ImGui::GetContentRegionAvail();
avail.y *= .8;
ImGui::BeginChild("table_child", avail, false);
if (ImGui::BeginTable("nested1", 4, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable))
{
ImGui::TableSetupColumn("Name");
@@ -78,10 +129,10 @@ void ProjectInterface::DrawEntitySettings()
ImGui::Button("Browse");
}
ImGui::EndTable();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Brush entities"))
@@ -91,9 +142,11 @@ void ProjectInterface::DrawEntitySettings()
}
ImGui::EndTabBar();
}
ImGui::PopStyleVar();
if (ImGui::Button("Add new"))
ImGui::OpenPopup("Create new point entity");
}
ImGui::End();
}

12
Nuake/Engine.cpp
View File

@@ -26,7 +26,6 @@ void Engine::Init()
PhysicsManager::Get()->Init();
Logger::Log("Physics initialized");
CurrentWindow = Window::Get();
Logger::Log("Window initialized");
@@ -48,22 +47,22 @@ void Engine::Tick()
m_LastFrameTime = time;
// Play mode update vs editor update.
if (Engine::IsPlayMode) {
if (Engine::IsPlayMode)
{
CurrentWindow->Update(timestep);
m_FixedUpdateDifference += timestep;
// Fixed update
if (m_FixedUpdateDifference >= m_FixedUpdateRate)
{
// call update here.
CurrentWindow->FixedUpdate(m_FixedUpdateRate);
m_FixedUpdateDifference = 0.f;
}
}
else
{
GetCurrentScene()->EditorUpdate(timestep);
}
Input::Update();
}
@@ -105,7 +104,6 @@ void Engine::EndDraw()
void Engine::Close()
{
ScriptingEngine::Close();
glfwTerminate();
}

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

@@ -14,17 +14,15 @@ struct MeshVertex
class Mesh
{
public:
std::vector<Texture> m_Textures;
std::vector<unsigned int> m_Indices;
std::vector<Vertex> m_Vertices;
Ref<Material> m_Material;
Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, Ref<Material> material);
void Draw();
void DebugDraw();
private:
// render data
unsigned int VAO, VBO, EBO;
void setupMesh();
};

24
Nuake/src/Rendering/RenderList.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include <vector>
#include <map>
#include "src/Core/Core.h"
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Mesh/Mesh.h"
class RenderList
{
private:
std::map<Ref<Material>, std::vector<Ref<Mesh>>> m_RenderList;
public:
RenderList() {
this->m_RenderList = std::map<Ref<Material>, std::vector<Ref<Mesh>>>();
}
void AddToRenderList(Ref<Mesh> mesh)
{
}
};

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

@@ -127,7 +127,7 @@ void Renderer::RegisterLight(TransformComponent transform, LightComponent light,
int idx = m_Lights.size();
glm::vec3 direction = light.GetDirection();
glm::vec3 pos = transform.Translation;
glm::vec3 pos = transform.GlobalTranslation;
glm::mat4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
//light.m_Framebuffer->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(17);
@@ -152,7 +152,7 @@ void Renderer::RegisterLight(TransformComponent transform, LightComponent light,
m_Shader->SetUniform1f("Lights[" + std::to_string(idx - 1) + "].CascadeDepth[2]", light.mCascadeSplitDepth[2]);
m_Shader->SetUniform1f("Lights[" + std::to_string(idx - 1) + "].CascadeDepth[3]", light.mCascadeSplitDepth[3]);
m_Shader->SetUniformMat4f("Lights[" + std::to_string(idx - 1) + "].LightTransform", light.GetProjection() * lightView);
m_Shader->SetUniform3f ("Lights[" + std::to_string(idx - 1) + "].Position" , transform.Translation.x, transform.Translation.y, transform.Translation.z);
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);

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

@@ -22,8 +22,6 @@ void Renderer2D::Init()
0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f

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

@@ -8,6 +8,7 @@
#include <string>
#include <sstream>
#include <vector>
#include <dependencies/GLEW/include/GL/glew.h>
Ref<Texture> Material::m_DefaultAlbedo;
Ref<Texture> Material::m_DefaultAO;
Ref<Texture> Material::m_DefaultNormal;
@@ -18,10 +19,14 @@ Ref<Texture> Material::m_DefaultDisplacement;
Material::Material(const std::string albedo)
{
glGenBuffers(1, &UBO);
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
glBufferData(GL_UNIFORM_BUFFER, sizeof(UBOStructure), NULL, GL_STATIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
m_Albedo = TextureManager::Get()->GetTexture(albedo);
UseAlbedo = true;
data.u_HasAlbedo = 1;
std::stringstream ss(albedo);
std::string item;
@@ -42,8 +47,6 @@ Material::Material(const std::string albedo)
m_DefaultRoughness = TextureManager::Get()->GetTexture("resources/Textures/default/Default.png");
if (m_DefaultMetalness == nullptr)
m_DefaultMetalness = TextureManager::Get()->GetTexture("resources/Textures/default/Default.png");
}
//Material::Material()
@@ -52,11 +55,20 @@ Material::Material(const std::string albedo)
Material::Material(const glm::vec3 albedoColor)
{
m_AlbedoColor = albedoColor;
glGenBuffers(1, &UBO);
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
glBufferData(GL_UNIFORM_BUFFER, sizeof(UBOStructure), NULL, GL_STATIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
data.m_AlbedoColor = myVec3{ albedoColor.r, albedoColor.g, albedoColor.b};
m_Name = "New material";
if (m_DefaultAlbedo == nullptr)
m_DefaultAlbedo = TextureManager::Get()->GetTexture("resources/Textures/default/Default.png");
m_Albedo = m_DefaultAlbedo;
if (m_DefaultAO == nullptr)
m_DefaultAO = TextureManager::Get()->GetTexture("resources/Textures/default/Default.png");
if (m_DefaultNormal == nullptr)
@@ -69,23 +81,22 @@ Material::Material(const glm::vec3 albedoColor)
m_DefaultMetalness = TextureManager::Get()->GetTexture("resources/Textures/default/Default.png");
}
Material::~Material()
{
}
Material::~Material() {}
void Material::Bind()
{
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(UBOStructure), &data);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glBindBufferBase(GL_UNIFORM_BUFFER, 32, UBO);
// Albedo
if (m_Albedo != nullptr)
m_Albedo->Bind(4);
else
m_DefaultAlbedo->Bind(4);
Renderer::m_Shader->SetUniform1i("m_Albedo", 4);
Renderer::m_Shader->SetUniform1i("u_HasAlbedo", UseAlbedo);
Renderer::m_Shader->SetUniform3f("m_AlbedoColor", m_AlbedoColor.r, m_AlbedoColor.g, m_AlbedoColor.b);
Renderer::m_GBufferShader->SetUniform1i("m_Albedo", 4);
// AO
if (m_AO != nullptr)
@@ -93,33 +104,28 @@ void Material::Bind()
else
m_DefaultAO->Bind(5);
Renderer::m_Shader->SetUniform1i("m_AO", 5);
Renderer::m_Shader->SetUniform1i("u_HasAO", UseAO);
Renderer::m_Shader->SetUniform1f("u_AOValue", m_AOValue);
Renderer::m_GBufferShader->SetUniform1i("m_AO", 5);
// Metallic
if (m_Metalness != nullptr)
m_Metalness->Bind(6);
else
m_DefaultMetalness->Bind(6);
Renderer::m_Shader->SetUniform1i("m_Metalness", 6);
Renderer::m_Shader->SetUniform1i("u_HasMetalness", UseMetalness);
Renderer::m_Shader->SetUniform1f("u_MetalnessValue", m_MetalnessValue);
Renderer::m_GBufferShader->SetUniform1i("m_Metalness", 6);
// Roughness
if (m_Roughness != nullptr)
m_Roughness->Bind(7);
else
m_DefaultRoughness->Bind(7);
Renderer::m_Shader->SetUniform1i("m_Roughness", 7);
Renderer::m_Shader->SetUniform1i("u_HasRoughness", UseRoughness);
Renderer::m_Shader->SetUniform1f("u_RoughnessValue", m_RoughnessValue);
Renderer::m_GBufferShader->SetUniform1i("m_Roughness", 7);
// Normal
if (m_Normal != nullptr)
m_Normal->Bind(8);
else
m_DefaultNormal->Bind(8);
Renderer::m_Shader->SetUniform1i("m_Normal", 8);
// Displacement
if (m_Displacement != nullptr)
m_Displacement->Bind(9);
@@ -129,6 +135,10 @@ void Material::Bind()
//Renderer::m_Shader->SetUniform1i("m_Displacement", 9);
}
void Material::SetupUniformBuffer()
{
}
void Material::SetName(const std::string name)
{
m_Name = name;

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

@@ -2,12 +2,35 @@
#include "../../Core/TextureManager.h"
#include "Texture.h"
#include <glm\ext\vector_float3.hpp>
#include <glm\ext\vector_float4.hpp>
#include "../Core/Core.h"
struct myVec3 {
float r;
float g;
float b;
float a;
};
struct UBOStructure {
int u_HasAlbedo;
myVec3 m_AlbedoColor;
uint32_t u_HasMetalness;
float u_MetalnessValue;
uint32_t u_HasRoughness;
float u_RoughnessValue;
uint32_t u_HasAO;
float u_AOValue;
uint32_t u_HasNormal;
uint32_t u_HasDisplacement;
};
class Material
{
private:
std::string m_Name;
unsigned int UBO;
public:
Ref<Texture> m_Albedo;
Ref<Texture> m_AO;
@@ -16,12 +39,19 @@ public:
Ref<Texture> m_Normal;
Ref<Texture> m_Displacement;
bool UseAlbedo = false;
bool UseNormal = false;
bool UseMetalness = false;
bool UseRoughness = false;
bool UseDisplacement = false;
bool UseAO = false;
UBOStructure data{
0, // has labedo
myVec3{0.f, 0.f, 0.f, 1.0f}, // m_AlbedoColor
0, // u_HasMetalness
0.5f, // u_MetalnessValue
0, // u_HasRoughness
0.5f, // u_RoughnessValue
0, // u_HasAO
0.5f, // u_AOValue
0, // u_HasNormal
0 // u_HasDisplacement
};
static Ref<Texture> m_DefaultAlbedo;
static Ref<Texture> m_DefaultAO;
@@ -30,44 +60,40 @@ public:
static Ref<Texture> m_DefaultNormal;
static Ref<Texture> m_DefaultDisplacement;
glm::vec3 m_AlbedoColor = glm::vec3(1.f, 1.f, 1.f);
float m_AOValue = 1.0f;
float m_MetalnessValue = 0.5f;
float m_RoughnessValue = 0.5f;
Material(const std::string albedo);
Material(Ref<Texture> texture) { m_Albedo = texture; }
Material(const glm::vec3 albedoColor);
~Material();
void Bind();
void SetupUniformBuffer();
void SetName(const std::string name);
std::string GetName();
bool HasAlbedo() { return m_Albedo != nullptr; }
void SetAlbedo(const std::string path) { m_Albedo = CreateRef<Texture>(path); }
void SetAlbedo(Ref<Texture> texture) { m_Albedo = texture; }
bool HasAO() { return m_AO != nullptr; }
void SetAO(const std::string albedo);
void SetAO(Ref<Texture> texture) { m_AO = texture; }
bool HasMetalness() { return m_Metalness != nullptr; }
void SetMetalness(const std::string albedo);
void SetMetalness(Ref<Texture> texture) { m_Metalness = texture; }
bool HasRougness() { return m_Roughness != nullptr; }
void SetRoughness(const std::string albedo);
void SetRoughness(Ref<Texture> texture) { m_Roughness = texture; }
bool HasNormal() { return m_Normal != nullptr; }
void SetNormal(const std::string albedo);
void SetNormal(Ref<Texture> texture) { m_Normal = texture; }
bool HasDisplacement() { return m_Displacement != nullptr; }
void SetDisplacement(const std::string displacement);
void SetDisplacement(Ref<Texture> texture) { m_Displacement = texture; }
bool HasAlbedo() { return m_Albedo != nullptr; }
bool HasNormal() { return m_Normal != nullptr; }
bool HasAO() { return m_AO != nullptr; }
bool HasMetalness() { return m_Metalness != nullptr; }
bool HasRougness() { return m_Roughness != nullptr; }
bool HasDisplacement() { return m_Displacement != nullptr; }
};

7
Nuake/src/Rendering/UniformBuffer.cpp Normal file
View File

@@ -0,0 +1,7 @@
#include "UniformBuffer.h"
UniformBuffer::UniformBuffer()
{
}

16
Nuake/src/Rendering/UniformBuffer.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
class UniformBuffer {
private:
unsigned int RendererID;
public:
UniformBuffer();
void Bind();
void Unbind();
};

21
Nuake/src/Scene/Components/BSPBrushComponent.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include "../Core/Core.h"
#include "../Core/Maths.h"
#include "../Rendering/Textures/Material.h"
#include "../Rendering/Mesh/Mesh.h"
class BSPBrushComponent {
public:
std::vector<Ref<Mesh>> Meshes;
std::vector< Ref<Material>> Materials;
bool IsSolid = true;
bool IsTrigger = false;
bool IsTransparent = false;
BSPBrushComponent() {
Meshes = std::vector<Ref<Mesh>>();
Materials = std::vector<Ref<Material>>();
}
};

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

@@ -8,12 +8,12 @@
#include "../Resource/Serializable.h"
#include <glm\ext\matrix_clip_space.hpp>
enum LightType {
Directional, Point, Spot
};
class LightComponent {
public:
glm::vec2 yes = glm::vec2(2, 2);

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

@@ -1,12 +1,7 @@
#include "QuakeMap.h"
#include "../Core/Core.h"
#include "../Core/MaterialManager.h"
// Lib map stuff.
extern "C" {
#include "libmap/h/map_parser.h"
#include <libmap/h/geo_generator.h>
#include <libmap/h/surface_gatherer.h>
}
void QuakeMapComponent::Draw()
{
@@ -15,8 +10,6 @@ void QuakeMapComponent::Draw()
}
}
void QuakeMapComponent::Load(std::string path, bool collisions)
{
if (Path == path)
@@ -24,106 +17,106 @@ void QuakeMapComponent::Load(std::string path, bool collisions)
Path = path;
Build();
//Build();
}
void QuakeMapComponent::Build()
{
m_Meshes.clear();
map_parser_load(Path.c_str());
geo_generator_run();
Ref<Material> DefaultMaterial = MaterialManager::Get()->GetMaterial("resources/Textures/default/Default.png");
for (int e = 0; e < entity_count; ++e)
{
entity* entity_inst = &entities[e];
entity_geometry* entity_geo_inst = &entity_geo[e];
for (int b = 0; b < entity_inst->brush_count; ++b)
{
brush* brush_inst = &entity_inst->brushes[b];
brush_geometry* brush_geo_inst = &entity_geo_inst->brushes[b];
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
int index_offset = 0;
int lastTextureID = -1;
std::string lastTexturePath = "";
for (int f = 0; f < brush_inst->face_count; ++f)
{
face* face = &brush_inst->faces[f];
texture_data* texture = &textures[face->texture_idx];
if (std::string(texture->name) == "__TB_empty")
{
texture->height = 1;
texture->width = 1;
}
else
{
std::string path = "resources/Textures/" + std::string(texture->name) + ".png";
auto tex = TextureManager::Get()->GetTexture(path);
texture->height = tex->GetHeight();
texture->width = tex->GetWidth();
}
face_geometry* face_geo_inst = &brush_geo_inst->faces[f];
//printf("Face %d\n", f);
for (int i = 0; i < face_geo_inst->vertex_count; ++i)
{
face_vertex vertex = face_geo_inst->vertices[i];
vertex_uv vertex_uv = get_standard_uv(vertex.vertex, face, texture->width, texture->height);
vertices.push_back(Vertex{
glm::vec3(vertex.vertex.y * (1.0f / 64), vertex.vertex.z * (1.0f / 64), vertex.vertex.x * (1.0f / 64)),
glm::vec2(vertex_uv.u, 1.0 -vertex_uv.v),
glm::vec3(vertex.normal.y, vertex.normal.z, vertex.normal.x),
glm::vec3(vertex.tangent.y, vertex.tangent.z, vertex.tangent.x), glm::vec3(0.0, 1.0, 0.0), 0.0f
});
//printf("vertex: (%f %f %f), normal: (%f %f %f)\n",
// vertex.vertex.x, vertex.vertex.y, vertex.vertex.z,
// vertex.normal.x, vertex.normal.y, vertex.normal.z);
}
//puts("Indices:");
for (int i = 0; i < (face_geo_inst->vertex_count - 2) * 3; ++i)
{
unsigned int index = face_geo_inst->indices[i];
//printf("index: %d\n", index_offset + index);
indices.push_back(index_offset + (unsigned int)index);
}
if (lastTextureID != face->texture_idx)
{
lastTexturePath = "resources/Textures/" + std::string(texture->name) + ".png";
if (std::string(texture->name) == "__TB_empty")
m_Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
else
m_Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
index_offset = 0;
vertices.clear();
indices.clear();
lastTextureID = face->texture_idx;
}
else
{
index_offset += (face_geo_inst->vertex_count);
}
}
if (vertices.size() > 0)
m_Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
//putchar('\n');
//putchar('\n');
}
}
//m_Meshes.clear();
//map_parser_load(Path.c_str());
//
//geo_generator_run();
//
//Ref<Material> DefaultMaterial = MaterialManager::Get()->GetMaterial("resources/Textures/default/Default.png");
//for (int e = 0; e < entity_count; ++e)
//{
// entity* entity_inst = &entities[e];
// entity_geometry* entity_geo_inst = &entity_geo[e];
//
//
// for (int b = 0; b < entity_inst->brush_count; ++b)
// {
// brush* brush_inst = &entity_inst->brushes[b];
// brush_geometry* brush_geo_inst = &entity_geo_inst->brushes[b];
//
// std::vector<Vertex> vertices;
// std::vector<unsigned int> indices;
//
// int index_offset = 0;
// int lastTextureID = -1;
// std::string lastTexturePath = "";
// for (int f = 0; f < brush_inst->face_count; ++f)
// {
// face* face = &brush_inst->faces[f];
// texture_data* texture = &textures[face->texture_idx];
// if (std::string(texture->name) == "__TB_empty") {
// texture->height = 1;
// texture->width = 1;
// }
// else {
// std::string path = "resources/Textures/" + std::string(texture->name) + ".png";
// auto tex = TextureManager::Get()->GetTexture(path);
// texture->height = tex->GetHeight();
// texture->width = tex->GetWidth();
// }
//
//
// face_geometry* face_geo_inst = &brush_geo_inst->faces[f];
// //printf("Face %d\n", f);
// for (int i = 0; i < face_geo_inst->vertex_count; ++i)
// {
// face_vertex vertex = face_geo_inst->vertices[i];
// vertex_uv vertex_uv = get_standard_uv(vertex.vertex, face, texture->width, texture->height);
// vertices.push_back(Vertex{
// glm::vec3((vertex.vertex.y - brush_inst->center.y) * (1.0f / 64),
// (vertex.vertex.z - brush_inst->center.z) * (1.0f / 64),
// (vertex.vertex.x - brush_inst->center.x) * (1.0f / 64)),
// glm::vec2(vertex_uv.u, 1.0 - vertex_uv.v),
// glm::vec3(vertex.normal.y, vertex.normal.z, vertex.normal.x),
// glm::vec3(vertex.tangent.y, vertex.tangent.z, vertex.tangent.x), glm::vec3(0.0, 1.0, 0.0), 0.0f
// });
//
// //printf("vertex: (%f %f %f), normal: (%f %f %f)\n",
// // vertex.vertex.x, vertex.vertex.y, vertex.vertex.z,
// // vertex.normal.x, vertex.normal.y, vertex.normal.z);
// }
//
// //puts("Indices:");
// for (int i = 0; i < (face_geo_inst->vertex_count - 2) * 3; ++i)
// {
// unsigned int index = face_geo_inst->indices[i];
// //printf("index: %d\n", index_offset + index);
// indices.push_back(index_offset + (unsigned int)index);
// }
// if (lastTextureID != face->texture_idx)
// {
// lastTexturePath = "resources/Textures/" + std::string(texture->name) + ".png";
// if (std::string(texture->name) == "__TB_empty")
// m_Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
// else
// m_Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
//
//
//
// index_offset = 0;
// vertices.clear();
// indices.clear();
// lastTextureID = face->texture_idx;
//
//
// }
// else
// {
// index_offset += (face_geo_inst->vertex_count);
// }
// }
//
// if (vertices.size() > 0)
// m_Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
// //putchar('\n');
// //putchar('\n');
// }
//}
}
void QuakeMapComponent::DrawEditor()
{

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

@@ -8,7 +8,6 @@
class QuakeMapComponent {
private:
public:
std::vector<Ref<Mesh>> m_Meshes;
Ref<TrenchbroomMap> Map;

3
Nuake/src/Scene/Components/TransformComponent.cpp
View File

@@ -3,6 +3,7 @@
TransformComponent::TransformComponent()
{
GlobalTranslation = Vector3(0, 0, 0);
Translation = Vector3(0, 0, 0);
Rotation = Vector3(0, 0, 0);
Scale = Vector3(1, 1, 1);
@@ -11,7 +12,7 @@ TransformComponent::TransformComponent()
glm::mat4 TransformComponent::GetTransform()
{
Matrix4 transform = Matrix4(1.0f);
transform = glm::translate(transform, Translation);
transform = glm::translate(transform, GlobalTranslation);
transform = glm::rotate(transform, glm::radians(Rotation.x), Vector3(1, 0, 0));
transform = glm::rotate(transform, glm::radians(Rotation.y), Vector3(0, 1, 0));
transform = glm::rotate(transform, glm::radians(Rotation.z), Vector3(0, 0, 1));

1
Nuake/src/Scene/Components/TransformComponent.h
View File

@@ -4,6 +4,7 @@
class TransformComponent {
public:
Vector3 GlobalTranslation;
Vector3 Translation;
Vector3 Rotation; // TODO: Should use quaternions.
Vector3 Scale;

6
Nuake/src/Scene/Entities/Entity.h
View File

@@ -38,7 +38,8 @@ public:
}
void Destroy() {
m_Scene->m_Registry.destroy(m_EntityHandle);
if(m_Scene->m_Registry.valid(m_EntityHandle))
m_Scene->m_Registry.destroy(m_EntityHandle);
}
bool operator==(const Entity& other) const
@@ -54,6 +55,9 @@ public:
json Serialize() override;
bool Deserialize(const std::string& str);
Scene* GetScene() {
return m_Scene;
}
private:
entt::entity m_EntityHandle;
Scene* m_Scene;

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

@@ -1,6 +1,11 @@
#pragma once
#include <src/Scene/Systems/ScriptingSystem.h>
#include <src/Scene/Systems/PhysicsSystem.h>
#include <src/Scene/Systems/QuakeMapBuilder.h>
#include <src/Scene/Components/BSPBrushComponent.h>
#include "Scene.h"
#include "Entities/Entity.h"
@@ -69,11 +74,10 @@ void Scene::OnExit()
void Scene::Update(Timestep ts)
{
UpdatePositions();
for (auto& system : m_Systems)
system->Update(ts);
}
void Scene::FixedUpdate(Timestep ts)
@@ -84,12 +88,36 @@ void Scene::FixedUpdate(Timestep ts)
void Scene::EditorUpdate(Timestep ts)
{
UpdatePositions();
m_EditorCamera->Update(ts);
for (auto i : m_Interfaces)
i->Update(ts);
}
void Scene::UpdatePositions()
{
auto transformView = m_Registry.view<ParentComponent, TransformComponent>();
for (auto e : transformView) {
auto [parent, transform] = transformView.get<ParentComponent, TransformComponent>(e);
Entity currentParent = Entity{ e, this };
Vector3 globalPos = Vector3();
if (parent.HasParent)
{
while (currentParent.GetComponent<ParentComponent>().HasParent) {
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalPos += currentParent.GetComponent<TransformComponent>().Translation;
}
transform.GlobalTranslation = globalPos + transform.Translation;
}
else
{
transform.GlobalTranslation = transform.Translation;
}
}
}
void Scene::DrawShadows()
{
@@ -97,9 +125,8 @@ void Scene::DrawShadows()
auto quakeView = m_Registry.view<TransformComponent, QuakeMapComponent>();
auto view = m_Registry.view<TransformComponent, LightComponent>();
Ref<Camera> cam = nullptr;
if (Engine::IsPlayMode)
{
Ref<Camera> cam = m_EditorCamera;
if (Engine::IsPlayMode) {
auto view = m_Registry.view<TransformComponent, CameraComponent>();
for (auto e : view) {
auto [transform, camera] = view.get<TransformComponent, CameraComponent>(e);
@@ -107,10 +134,6 @@ void Scene::DrawShadows()
break;
}
}
else
{
cam = m_EditorCamera;
}
glm::mat4 perspective = cam->GetPerspective();
@@ -121,7 +144,6 @@ void Scene::DrawShadows()
light.CalculateViewProjection(cam->GetTransform(), cam->GetPerspective());
light.BeginDrawShadow();
for (int i = 0; i < 4; i++)
{
@@ -139,22 +161,20 @@ void Scene::DrawShadows()
model.Draw();
}
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView) {
auto [transform, model] = quakeView.get<TransformComponent, QuakeMapComponent>(e);
glm::vec3 pos = lightTransform.Translation;
glm::mat4 lightView = glm::lookAt(pos, pos - light.GetDirection(), glm::vec3(0.0f, 1.0f, 0.0f));
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
Renderer::m_ShadowmapShader->SetUniformMat4f("lightSpaceMatrix", light.mViewProjections[i]);
Renderer::m_ShadowmapShader->SetUniformMat4f("model", transform.GetTransform());
model.Draw();
for (auto& e : model.Meshes) {
e->Draw();
}
}
light.m_Framebuffers[i]->Unbind();
}
light.EndDrawShadow();
}
}
@@ -167,7 +187,6 @@ void Scene::DrawInterface(Vector2 screensize)
}
}
void Scene::Draw()
{
// Find the camera of the scene.
@@ -176,24 +195,8 @@ void Scene::Draw()
auto view = m_Registry.view<TransformComponent, CameraComponent, ParentComponent>();
for (auto e : view) {
auto [transform, camera, parent] = view.get<TransformComponent, CameraComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
cam = camera.CameraInstance;
cam->Translation = copyT.Translation;
cam->Translation = transform.GlobalTranslation;
break;
}
}
@@ -216,26 +219,10 @@ void Scene::Draw()
for (auto l : view) {
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ l, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
light.Draw(copyT, m_EditorCamera);
light.Draw(transform, m_EditorCamera);
}
}
glEnable(GL_CULL_FACE);
@@ -249,59 +236,31 @@ void Scene::Draw()
auto view = m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
for (auto e : view) {
auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
Renderer::m_Shader->SetUniformMat4f("u_View", cam->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", cam->GetPerspective());
Renderer::m_Shader->SetUniformMat4f("u_Model", copyT.GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
model.Draw();
}
auto quakeView = m_Registry.view<TransformComponent, QuakeMapComponent, ParentComponent>();
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView) {
auto [transform, model, parent] = quakeView.get<TransformComponent, QuakeMapComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
Renderer::m_Shader->SetUniformMat4f("u_View", cam->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", cam->GetPerspective());
Renderer::m_Shader->SetUniformMat4f("u_Model", copyT.GetTransform());
model.Draw();
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
for (auto& e : model.Meshes)
{
e->Draw();
}
}
Renderer::m_DebugShader->SetUniformMat4f("u_View", cam->GetTransform());
Renderer::m_DebugShader->SetUniformMat4f("u_Projection", cam->GetPerspective());
PhysicsManager::Get()->DrawDebug();
}
}
void Scene::EditorDraw()
@@ -309,6 +268,7 @@ void Scene::EditorDraw()
glDisable(GL_DEPTH_TEST);
Ref<Environment> env = GetEnvironment();
glDisable(GL_CULL_FACE);
if (env->ProceduralSkybox)
{
env->ProceduralSkybox->Draw(m_EditorCamera);
@@ -323,29 +283,15 @@ void Scene::EditorDraw()
auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
for (auto l : view) {
auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ l, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
if (light.SyncDirectionWithSky)
light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
light.Draw(copyT, m_EditorCamera);
light.Draw(transform, m_EditorCamera);
}
}
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
Renderer::m_Shader->Bind();
Renderer::m_Shader->SetUniform1i("u_ShowNormal", 0);
if (m_EditorCamera)
@@ -355,77 +301,33 @@ void Scene::EditorDraw()
auto view = m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
for (auto e : view) {
auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
Renderer::m_Shader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
Renderer::m_Shader->SetUniformMat4f("u_Model", copyT.GetTransform());
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
model.Draw();
}
auto quakeView = m_Registry.view<TransformComponent, QuakeMapComponent, ParentComponent>();
auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
for (auto e : quakeView) {
auto [transform, model, parent] = quakeView.get<TransformComponent, QuakeMapComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, 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", copyT.GetTransform());
model.Draw();
Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
for (auto& e : model.Meshes) {
e->Draw();
}
}
auto boxCollider = m_Registry.view<TransformComponent, BoxColliderComponent, ParentComponent>();
for (auto e : boxCollider) {
auto [transform, box, parent] = boxCollider.get<TransformComponent, BoxColliderComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
Renderer::m_DebugShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_DebugShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
Renderer::m_DebugShader->SetUniformMat4f("u_Model", copyT.GetTransform());
Renderer::m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
TransformComponent t = transform;
t.Scale = (box.Size * 2.f) * transform.Scale;
@@ -436,22 +338,6 @@ void Scene::EditorDraw()
for (auto e : sphereCollider) {
auto [transform, box, parent] = sphereCollider.get<TransformComponent, SphereColliderComponent, ParentComponent>(e);
TransformComponent copyT = transform;
if (parent.HasParent)
{
Entity currentParent = Entity{ e, this };
glm::vec3 globalOffset = copyT.Translation;
while (currentParent.GetComponent<ParentComponent>().HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalOffset += currentParent.GetComponent<TransformComponent>().Translation;
}
copyT.Translation = globalOffset;
}
Renderer::m_DebugShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
Renderer::m_DebugShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
Renderer::m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
@@ -517,7 +403,16 @@ Entity Scene::CreateEntity(const std::string& name) {
return entity;
}
void Scene::DestroyEntity(Entity entity) {
void Scene::DestroyEntity(Entity entity)
{
ParentComponent& parentComponent = entity.GetComponent<ParentComponent>();
if (parentComponent.HasParent) { // Remove self from parents children lists.
int idx = 0;
ParentComponent& parentParentComponent = parentComponent.Parent.GetComponent<ParentComponent>();
}
for (auto& c : parentComponent.Children) {
DestroyEntity(c);
}
entity.Destroy();
}

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

@@ -46,6 +46,8 @@ public:
void FixedUpdate(Timestep ts);
void EditorUpdate(Timestep ts);
void UpdatePositions();
// TODO: Maybe move this to Renderer::DrawScene() ?
void DrawShadows();
void DrawInterface(Vector2 screensize);

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

@@ -7,6 +7,7 @@
#include <src/Core/Physics/PhysicsManager.h>
#include <src/Scene/Components/CharacterControllerComponent.h>
#include <src/Scene/Components/QuakeMap.h>
#include <src/Scene/Components/BSPBrushComponent.h>
PhysicsSystem::PhysicsSystem(Scene* scene)
{
m_Scene = scene;
@@ -19,7 +20,6 @@ void PhysicsSystem::Init()
for (auto e : view)
{
auto [transform, rigidbody] = view.get<TransformComponent, RigidBodyComponent>(e);
Entity ent = Entity({ e, m_Scene });
if (ent.HasComponent<BoxColliderComponent>())
@@ -50,22 +50,21 @@ void PhysicsSystem::Init()
PhysicsManager::Get()->RegisterCharacterController(cc.CharacterController);
}
auto quakeMapview = m_Scene->m_Registry.view<TransformComponent, QuakeMapComponent>();
for (auto e : quakeMapview)
auto bspView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : bspView)
{
auto [transform, quake] = quakeMapview.get<TransformComponent, QuakeMapComponent>(e);
auto [transform, brush] = bspView.get<TransformComponent, BSPBrushComponent>(e);
if (quake.HasCollisions)
if (brush.IsSolid)
{
for (auto m : quake.m_Meshes)
for (auto m : brush.Meshes)
{
Ref<Physics::MeshShape> meshShape = CreateRef<Physics::MeshShape>(m);
Ref<Physics::RigidBody> btRigidbody = CreateRef<Physics::RigidBody>(0.0f, transform.Translation, meshShape);
Ref<Physics::RigidBody> btRigidbody = CreateRef<Physics::RigidBody>(0.0f, transform.GlobalTranslation, meshShape);
PhysicsManager::Get()->RegisterBody(btRigidbody);
}
}
}
}
void PhysicsSystem::Update(Timestep ts)

171
Nuake/src/Scene/Systems/QuakeMapBuilder.cpp Normal file
View File

@@ -0,0 +1,171 @@
#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>
extern "C" {
#include "libmap/h/map_parser.h"
#include <libmap/h/geo_generator.h>
#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>
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::BuildQuakeMap(Entity& ent, bool Collisions)
{
if (!ent.HasComponent<QuakeMapComponent>())
return;
QuakeMapComponent& quakeMapC = ent.GetComponent<QuakeMapComponent>();
Scene* m_Scene = ent.GetScene();
// Clear old map entities.
ParentComponent& currentParent = ent.GetComponent<ParentComponent>();
for (auto& e : currentParent.Children) {
m_Scene->DestroyEntity(e);
}
currentParent.Children.clear();
map_parser_load(quakeMapC.Path.c_str());
geo_generator_run();
Ref<Material> DefaultMaterial = MaterialManager::Get()->GetMaterial("resources/Textures/default/Default.png");
for (int e = 0; e < entity_count; ++e)
{
entity* entity_inst = &entities[e];
entity_geometry* entity_geo_inst = &entity_geo[e];
Entity newEntity = m_Scene->CreateEntity("Brush " + std::to_string(e) );
ent.AddChild(newEntity);
for (int i = 0; i < entity_inst->property_count; i++) {
property* prop = &(entity_inst->properties)[i];
std::string key = prop->key;
std::string value = prop->value;
if (key == "origin") {
// Position
std::vector<std::string> splits = 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);
Vector3 position = Vector3(x, y, z);
newEntity.GetComponent<TransformComponent>().Translation = position;
}
if (key == "classname") {
if (value == "light") {
newEntity.AddComponent<LightComponent>();
}
}
}
for (int b = 0; b < entity_inst->brush_count; ++b)
{
Entity brushEntiuty = m_Scene->CreateEntity("Brush " + std::to_string(e));
newEntity.AddChild(brushEntiuty);
brushEntiuty.AddComponent<BSPBrushComponent>();
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
brush* brush_inst = &entity_inst->brushes[b];
brush_geometry* brush_geo_inst = &entity_geo_inst->brushes[b];
BSPBrushComponent& bsp = brushEntiuty.GetComponent<BSPBrushComponent>();
TransformComponent& transformComponent = brushEntiuty.GetComponent<TransformComponent>();
transformComponent.Translation = Vector3(brush_inst->center.y * (1.0f / 64),
brush_inst->center.z * (1.0f / 64),
brush_inst->center.x * (1.0f / 64));
int index_offset = 0;
int lastTextureID = -1;
std::string lastTexturePath = "";
for (int f = 0; f < brush_inst->face_count; ++f)
{
face* face = &brush_inst->faces[f];
texture_data* texture = &textures[face->texture_idx];
if (std::string(texture->name) == "__TB_empty") {
texture->height = 1;
texture->width = 1;
}
else {
std::string path = "resources/Textures/" + std::string(texture->name) + ".png";
auto tex = TextureManager::Get()->GetTexture(path);
texture->height = tex->GetHeight();
texture->width = tex->GetWidth();
}
face_geometry* face_geo_inst = &brush_geo_inst->faces[f];
for (int i = 0; i < face_geo_inst->vertex_count; ++i)
{
face_vertex vertex = face_geo_inst->vertices[i];
vertex_uv vertex_uv = get_standard_uv(vertex.vertex, face, texture->width, texture->height);
Vector3 vertexPos = Vector3(
(vertex.vertex.y - brush_inst->center.y) * (1.0f / 64),
(vertex.vertex.z - brush_inst->center.z) * (1.0f / 64),
(vertex.vertex.x - brush_inst->center.x) * (1.0f / 64)
);
Vector2 vertexUV = Vector2(vertex_uv.u, 1.0 - vertex_uv.v);
Vector3 vertexNormal = Vector3(vertex.normal.y, vertex.normal.z, vertex.normal.x);
Vector3 vertexTangent = Vector3(vertex.tangent.y, vertex.tangent.z, vertex.tangent.x);
vertices.push_back(Vertex{
vertexPos,
vertexUV,
vertexNormal,
vertexTangent,
glm::vec3(0.0, 1.0, 0.0), 0.0f
});
}
for (int i = 0; i < (face_geo_inst->vertex_count - 2) * 3; ++i)
{
unsigned int index = face_geo_inst->indices[i];
indices.push_back(index_offset + (unsigned int)index);
}
if (lastTextureID != face->texture_idx)
{
lastTexturePath = "resources/Textures/" + std::string(texture->name) + ".png";
if (std::string(texture->name) == "__TB_empty")
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
else
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
index_offset = 0;
vertices.clear();
indices.clear();
lastTextureID = face->texture_idx;
}
else
{
index_offset += (face_geo_inst->vertex_count);
}
}
if (vertices.size() > 0)
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
}
}
}

10
Nuake/src/Scene/Systems/QuakeMapBuilder.h Normal file
View File

@@ -0,0 +1,10 @@
#pragma once
class Entity;
class QuakeMapBuilder
{
public:
QuakeMapBuilder(){}
void BuildQuakeMap(Entity& ent, bool Collisions = true);
};

27
Nuake/src/Scene/Systems/TrenchbroomSystem.cpp Normal file
View File

@@ -0,0 +1,27 @@
#include "TrenchbroomSystem.h"
TrenchbroomSystem::TrenchbroomSystem(Scene* scene)
{
m_Scene = scene;
}
void TrenchbroomSystem::Init()
{
}
void TrenchbroomSystem::Update(Timestep ts)
{
}
void TrenchbroomSystem::FixedUpdate(Timestep ts)
{
}
void TrenchbroomSystem::Exit()
{
}

12
Nuake/src/Scene/Systems/TrenchbroomSystem.h Normal file
View File

@@ -0,0 +1,12 @@
#pragma once
#include <src/Scene/Systems/System.h>
class TrenchbroomSystem : public System {
public:
TrenchbroomSystem(Scene* scene);
void Init() override;
void Update(Timestep ts) override;
void Draw() override {}
void FixedUpdate(Timestep ts) override;
void Exit() override;
};

2
Nuake/src/Scripting/Modules/SceneModule.h
View File

@@ -54,7 +54,7 @@ namespace ScriptAPI
int handle = wrenGetSlotDouble(vm, 1);
std::string name = wrenGetSlotString(vm, 2);
Entity ent = Entity((entt::entity)handle, Engine::GetCurrentScene().get());
if (name == "Transform")
{
bool result = ent.HasComponent<TransformComponent>();

2
Nuake/src/Vendors/libmap/h/entity.h
View File

@@ -20,7 +20,7 @@ enum entity_spawn_type
typedef struct entity {
int property_count;
property *properties;
property* properties;
int brush_count;
brush *brushes;

1
Nuake/src/Vendors/libmap/h/geo_generator.h
View File

@@ -1,3 +1,4 @@
#pragma once
#ifndef GEO_GENERATOR_H
#define GEO_GENERATOR_H

1
Nuake/src/Vendors/libmap/h/map_parser.h
View File

@@ -1,3 +1,4 @@
#pragma once
#ifndef MAP_PARSER_H
#define MAP_PARSER_H

1
Nuake/src/Vendors/libmap/h/surface_gatherer.h
View File

@@ -1,3 +1,4 @@
#pragma once
#ifndef SURFACE_GATHERER_H
#define SURFACE_GATHERER_H

2
Nuake/src/Window.cpp
View File

@@ -240,6 +240,7 @@ void Window::Draw()
Vector2 size = m_Framebuffer->GetSize();
cam->AspectRatio = size.x / size.y;
Renderer::BeginDraw(cam);
{
@@ -258,7 +259,6 @@ void Window::Draw()
m_Framebuffer->Unbind();
}
Renderer::EndDraw();
}