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

Major cleanup.

Browse Source 
Moved to namespace
Cleanup includes
This commit is contained in:
Antoine Pilote
2021-07-11 18:56:44 -04:00
parent f77bef6b28
commit 0c6ed48bbd
174 changed files with 11772 additions and 11296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -10,147 +10,149 @@
#include <src/Scene/Components/BSPBrushComponent.h>
#include <src/Scene/Components/TriggerZone.h>
PhysicsSystem::PhysicsSystem(Scene* scene)
namespace Nuake
{
m_Scene = scene;
}
bool PhysicsSystem::Init()
{
// Create physic world.
auto view = m_Scene->m_Registry.view<TransformComponent, RigidBodyComponent>();
for (auto e : view)
PhysicsSystem::PhysicsSystem(Scene* scene)
{
auto [transform, rigidbody] = view.get<TransformComponent, RigidBodyComponent>(e);
Entity ent = Entity({ e, m_Scene });
if (ent.HasComponent<BoxColliderComponent>())
{
float mass = rigidbody.mass;
BoxColliderComponent& boxComponent = ent.GetComponent<BoxColliderComponent>();
Ref<Physics::Box> boxShape = CreateRef<Physics::Box>(boxComponent.Size);
Ref<Physics::RigidBody> btRigidbody = CreateRef<Physics::RigidBody>(mass, transform.Translation, boxShape);
rigidbody.m_Rigidbody = btRigidbody;
btRigidbody->SetKinematic(rigidbody.IsKinematic);
PhysicsManager::Get()->RegisterBody(btRigidbody);
}
m_Scene = scene;
}
// character controllers
auto ccview = m_Scene->m_Registry.view<TransformComponent, CharacterControllerComponent>();
for (auto e : ccview)
bool PhysicsSystem::Init()
{
auto [transform, cc] = ccview.get<TransformComponent, CharacterControllerComponent>(e);
cc.CharacterController = CreateRef<Physics::CharacterController>(cc.Height, cc.Radius, cc.Mass, transform.Translation);
Entity ent = Entity({ e, m_Scene });
cc.CharacterController->SetEntity(ent);
PhysicsManager::Get()->RegisterCharacterController(cc.CharacterController);
}
auto bspView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : bspView)
{
auto [transform, brush] = bspView.get<TransformComponent, BSPBrushComponent>(e);
if (brush.IsSolid)
// Create physic world.
auto view = m_Scene->m_Registry.view<TransformComponent, RigidBodyComponent>();
for (auto e : view)
{
for (auto m : brush.Meshes)
auto [transform, rigidbody] = view.get<TransformComponent, RigidBodyComponent>(e);
Entity ent = Entity({ e, m_Scene });
if (ent.HasComponent<BoxColliderComponent>())
{
Ref<Physics::MeshShape> meshShape = CreateRef<Physics::MeshShape>(m);
Ref<Physics::RigidBody> btRigidbody = CreateRef<Physics::RigidBody>(0.0f, transform.GlobalTranslation, meshShape);
btRigidbody->SetEntityID(Entity{ e, m_Scene });
brush.Rigidbody.push_back(btRigidbody);
float mass = rigidbody.mass;
BoxColliderComponent& boxComponent = ent.GetComponent<BoxColliderComponent>();
Ref<Physics::Box> boxShape = CreateRef<Physics::Box>(boxComponent.Size);
Ref<Physics::RigidBody> btRigidbody = CreateRef<Physics::RigidBody>(mass, transform.Translation, boxShape);
rigidbody.m_Rigidbody = btRigidbody;
btRigidbody->SetKinematic(rigidbody.IsKinematic);
PhysicsManager::Get()->RegisterBody(btRigidbody);
}
}
}
auto bspTriggerView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent, TriggerZone>();
for (auto e : bspTriggerView) {
auto [transform, brush, trigger] = bspTriggerView.get<TransformComponent, BSPBrushComponent, TriggerZone>(e);
Ref<Physics::MeshShape> meshShape = CreateRef<Physics::MeshShape>(brush.Meshes[0]);
Ref<GhostObject> ghostBody = CreateRef<GhostObject>(transform.GlobalTranslation, meshShape);
trigger.GhostObject = ghostBody;
// character controllers
auto ccview = m_Scene->m_Registry.view<TransformComponent, CharacterControllerComponent>();
for (auto e : ccview)
{
auto [transform, cc] = ccview.get<TransformComponent, CharacterControllerComponent>(e);
PhysicsManager::Get()->RegisterGhostBody(ghostBody);
}
return true;
}
cc.CharacterController = CreateRef<Physics::CharacterController>(cc.Height, cc.Radius, cc.Mass, transform.Translation);
Entity ent = Entity({ e, m_Scene });
cc.CharacterController->SetEntity(ent);
void PhysicsSystem::Update(Timestep ts)
{
// Update rigidbodies
PhysicsManager::Get()->Step(ts);
auto brushes = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : brushes) {
auto [transform, brush] = brushes.get<TransformComponent, BSPBrushComponent>(e);
for (auto& r : brush.Rigidbody) {
r->m_Transform->setOrigin(btVector3(transform.GlobalTranslation.x, transform.GlobalTranslation.y, transform.GlobalTranslation.z));
r->UpdateTransform(*r->m_Transform);
PhysicsManager::Get()->RegisterCharacterController(cc.CharacterController);
}
if (!brush.IsFunc)
continue;
auto bspView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : bspView)
{
auto [transform, brush] = bspView.get<TransformComponent, BSPBrushComponent>(e);
brush.Targets.clear();
auto targetnameView = m_Scene->m_Registry.view<TransformComponent, NameComponent>();
for (auto e2 : targetnameView) {
auto [ttransform, name] = targetnameView.get<TransformComponent, NameComponent>(e2);
if (name.Name == brush.target) {
brush.Targets.push_back(Entity{ e2, m_Scene });
if (brush.IsSolid)
{
for (auto m : brush.Meshes)
{
Ref<Physics::MeshShape> meshShape = CreateRef<Physics::MeshShape>(m);
Ref<Physics::RigidBody> btRigidbody = CreateRef<Physics::RigidBody>(0.0f, transform.GlobalTranslation, meshShape);
btRigidbody->SetEntityID(Entity{ e, m_Scene });
brush.Rigidbody.push_back(btRigidbody);
PhysicsManager::Get()->RegisterBody(btRigidbody);
}
}
}
auto bspTriggerView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent, TriggerZone>();
for (auto e : bspTriggerView) {
auto [transform, brush, trigger] = bspTriggerView.get<TransformComponent, BSPBrushComponent, TriggerZone>(e);
Ref<Physics::MeshShape> meshShape = CreateRef<Physics::MeshShape>(brush.Meshes[0]);
Ref<GhostObject> ghostBody = CreateRef<GhostObject>(transform.GlobalTranslation, meshShape);
trigger.GhostObject = ghostBody;
PhysicsManager::Get()->RegisterGhostBody(ghostBody);
}
return true;
}
void PhysicsSystem::Update(Timestep ts)
{
// Update rigidbodies
PhysicsManager::Get()->Step(ts);
auto bspTriggerView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent, TriggerZone>();
for (auto e : bspTriggerView) {
auto [transform, brush, trigger] = bspTriggerView.get<TransformComponent, BSPBrushComponent, TriggerZone>(e);
trigger.GhostObject->ScanOverlap();
auto brushes = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
for (auto e : brushes) {
auto [transform, brush] = brushes.get<TransformComponent, BSPBrushComponent>(e);
brush.Targets.clear();
auto targetnameView = m_Scene->m_Registry.view<TransformComponent, NameComponent>();
for (auto e2 : targetnameView) {
auto [ttransform, name] = targetnameView.get<TransformComponent, NameComponent>(e2);
if (name.Name == brush.target) {
brush.Targets.push_back(Entity{ e2, m_Scene });
for (auto& r : brush.Rigidbody) {
r->m_Transform->setOrigin(btVector3(transform.GlobalTranslation.x, transform.GlobalTranslation.y, transform.GlobalTranslation.z));
r->UpdateTransform(*r->m_Transform);
}
if (!brush.IsFunc)
continue;
brush.Targets.clear();
auto targetnameView = m_Scene->m_Registry.view<TransformComponent, NameComponent>();
for (auto e2 : targetnameView) {
auto [ttransform, name] = targetnameView.get<TransformComponent, NameComponent>(e2);
if (name.Name == brush.target) {
brush.Targets.push_back(Entity{ e2, m_Scene });
}
}
}
auto bspTriggerView = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent, TriggerZone>();
for (auto e : bspTriggerView) {
auto [transform, brush, trigger] = bspTriggerView.get<TransformComponent, BSPBrushComponent, TriggerZone>(e);
trigger.GhostObject->ScanOverlap();
brush.Targets.clear();
auto targetnameView = m_Scene->m_Registry.view<TransformComponent, NameComponent>();
for (auto e2 : targetnameView) {
auto [ttransform, name] = targetnameView.get<TransformComponent, NameComponent>(e2);
if (name.Name == brush.target) {
brush.Targets.push_back(Entity{ e2, m_Scene });
}
}
}
auto physicGroup = m_Scene->m_Registry.view<TransformComponent, RigidBodyComponent>();
for (auto e : physicGroup) {
auto [transform, rb] = physicGroup.get<TransformComponent, RigidBodyComponent>(e);
rb.SyncTransformComponent(&m_Scene->m_Registry.get<TransformComponent>(e));
}
auto ccGroup = m_Scene->m_Registry.view<TransformComponent, CharacterControllerComponent>();
for (auto e : ccGroup) {
auto [transform, rb] = ccGroup.get<TransformComponent, CharacterControllerComponent>(e);
rb.SyncWithTransform(m_Scene->m_Registry.get<TransformComponent>(e));
}
}
auto physicGroup = m_Scene->m_Registry.view<TransformComponent, RigidBodyComponent>();
for (auto e : physicGroup) {
auto [transform, rb] = physicGroup.get<TransformComponent, RigidBodyComponent>(e);
rb.SyncTransformComponent(&m_Scene->m_Registry.get<TransformComponent>(e));
void PhysicsSystem::FixedUpdate(Timestep ts)
{
}
auto ccGroup = m_Scene->m_Registry.view<TransformComponent, CharacterControllerComponent>();
for (auto e : ccGroup) {
auto [transform, rb] = ccGroup.get<TransformComponent, CharacterControllerComponent>(e);
rb.SyncWithTransform(m_Scene->m_Registry.get<TransformComponent>(e));
void PhysicsSystem::Exit()
{
PhysicsManager::Get()->Reset();
}
}
void PhysicsSystem::FixedUpdate(Timestep ts)
{
}
void PhysicsSystem::Exit()
{
PhysicsManager::Get()->Reset();
}

22
Nuake/src/Scene/Systems/PhysicsSystem.h
View File

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

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

@@ -23,276 +23,154 @@ extern "C" {
#include <src/Resource/FGD/FGDClass.h>
#include <src/Scene/Components/WrenScriptComponent.h>
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))
namespace Nuake {
Ref<Material> DefaultMaterial;
std::vector<std::string> split(const std::string& s, char delim)
{
result.push_back(item);
std::vector<std::string> result;
std::stringstream ss(s);
std::string item;
while (getline(ss, item, delim))
{
result.push_back(item);
}
return result;
}
return result;
}
void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
Entity brushEntity = scene->CreateEntity("Trigger");
TransformComponent& transformComponent = brushEntity.GetComponent<TransformComponent>();
TriggerZone& trigger = brushEntity.AddComponent<TriggerZone>();
trigger.target = target;
parent.AddChild(brushEntity);
transformComponent.Translation = Vector3(brush->center.y * (1.0f / 64),
brush->center.z * (1.0f / 64),
brush->center.x * (1.0f / 64));
BSPBrushComponent& bsp = brushEntity.AddComponent<BSPBrushComponent>();
bsp.IsSolid = false;
bsp.target = target;
int indexOffset = 0;
for (int f = 0; f < brush->face_count; ++f)
void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
{
face* face = &brush->faces[f];
face_geometry* face_geo_inst = &brush_inst->faces[f];
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
for (int i = 0; i < face_geo_inst->vertex_count; ++i)
{
face_vertex vertex = face_geo_inst->vertices[i];
Vector3 vertexPos = Vector3(
(vertex.vertex.y - brush->center.y) * (1.0f / 64),
(vertex.vertex.z - brush->center.z) * (1.0f / 64),
(vertex.vertex.x - brush->center.x) * (1.0f / 64)
);
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,
Vector2(0,0),
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((unsigned int)indexOffset + index);
}
indexOffset += face_geo_inst->vertex_count;
}
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)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
Entity brushEntity = scene->CreateEntity(targetname);
TransformComponent& transformComponent = brushEntity.GetComponent<TransformComponent>();
BSPBrushComponent& bsp = brushEntity.AddComponent<BSPBrushComponent>();
parent.AddChild(brushEntity);
transformComponent.Translation = Vector3(
brush->center.y * (1.0f / 64),
brush->center.z * (1.0f / 64),
brush->center.x * (1.0f / 64));
int index_offset = 0;
int lastTextureID = -1;
std::string lastTexturePath = "";
for (int f = 0; f < brush->face_count; ++f)
{
face* face = &brush->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 = FileSystem::Root + "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_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->center.y) * (1.0f / 64),
(vertex.vertex.z - brush->center.z) * (1.0f / 64),
(vertex.vertex.x - brush->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 = FileSystem::Root + "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)));
}
void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname, FGDBrushEntity fgdBrush)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::string name = fgdBrush.Name;
if (targetname != "")
name = targetname;
Entity brushEntity = scene->CreateEntity(name);
TransformComponent& transformComponent = brushEntity.GetComponent<TransformComponent>();
BSPBrushComponent& bsp = brushEntity.AddComponent<BSPBrushComponent>();
bsp.IsSolid = fgdBrush.Solid;
bsp.IsTransparent = !fgdBrush.Visible;
bsp.IsFunc = true;
bsp.IsTrigger = fgdBrush.IsTrigger;
if (fgdBrush.Script != "" && fgdBrush.Class != "")
{
auto& wrenScript = brushEntity.AddComponent<WrenScriptComponent>();
wrenScript.Script = fgdBrush.Script;
wrenScript.Class = fgdBrush.Class;
}
if (bsp.IsTrigger)
{
Entity brushEntity = scene->CreateEntity("Trigger");
TransformComponent& transformComponent = brushEntity.GetComponent<TransformComponent>();
TriggerZone& trigger = brushEntity.AddComponent<TriggerZone>();
trigger.target = target;
parent.AddChild(brushEntity);
transformComponent.Translation = Vector3(brush->center.y * (1.0f / 64),
brush->center.z * (1.0f / 64),
brush->center.x * (1.0f / 64));
BSPBrushComponent& bsp = brushEntity.AddComponent<BSPBrushComponent>();
bsp.IsSolid = false;
bsp.target = target;
int indexOffset = 0;
for (int f = 0; f < brush->face_count; ++f)
{
face* face = &brush->faces[f];
face_geometry* face_geo_inst = &brush_inst->faces[f];
for (int i = 0; i < face_geo_inst->vertex_count; ++i)
{
face_vertex vertex = face_geo_inst->vertices[i];
Vector3 vertexPos = Vector3(
(vertex.vertex.y - brush->center.y) * (1.0f / 64),
(vertex.vertex.z - brush->center.z) * (1.0f / 64),
(vertex.vertex.x - brush->center.x) * (1.0f / 64)
);
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,
Vector2(0,0),
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((unsigned int)indexOffset + index);
}
indexOffset += face_geo_inst->vertex_count;
}
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
}
bsp.target = target;
parent.AddChild(brushEntity);
transformComponent.Translation = Vector3(
brush->center.y * (1.0f / 64),
brush->center.z * (1.0f / 64),
brush->center.x * (1.0f / 64));
int index_offset = 0;
int lastTextureID = -1;
std::string lastTexturePath = "";
for (int f = 0; f < brush->face_count; ++f)
void QuakeMapBuilder::CreateBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
{
face* face = &brush->faces[f];
texture_data* texture = &textures[face->texture_idx];
if (std::string(texture->name) == "__TB_empty")
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
Entity brushEntity = scene->CreateEntity(targetname);
TransformComponent& transformComponent = brushEntity.GetComponent<TransformComponent>();
BSPBrushComponent& bsp = brushEntity.AddComponent<BSPBrushComponent>();
parent.AddChild(brushEntity);
transformComponent.Translation = Vector3(
brush->center.y * (1.0f / 64),
brush->center.z * (1.0f / 64),
brush->center.x * (1.0f / 64));
int index_offset = 0;
int lastTextureID = -1;
std::string lastTexturePath = "";
for (int f = 0; f < brush->face_count; ++f)
{
texture->height = 1;
texture->width = 1;
}
else
{
std::string path = FileSystem::Root + std::string(texture->name) + ".png";
auto tex = TextureManager::Get()->GetTexture(path);
texture->height = tex->GetHeight();
texture->width = tex->GetWidth();
}
face* face = &brush->faces[f];
texture_data* texture = &textures[face->texture_idx];
face_geometry* face_geo_inst = &brush_inst->faces[f];
if (std::string(texture->name) == "__TB_empty")
{
texture->height = 1;
texture->width = 1;
}
else
{
std::string path = FileSystem::Root + "textures/" + std::string(texture->name) + ".png";
auto tex = TextureManager::Get()->GetTexture(path);
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);
texture->height = tex->GetHeight();
texture->width = tex->GetWidth();
}
Vector3 vertexPos = Vector3(
(vertex.vertex.y - brush->center.y) * (1.0f / 64),
(vertex.vertex.z - brush->center.z) * (1.0f / 64),
(vertex.vertex.x - brush->center.x) * (1.0f / 64)
);
face_geometry* face_geo_inst = &brush_inst->faces[f];
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);
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
{
Vector3 vertexPos = Vector3(
(vertex.vertex.y - brush->center.y) * (1.0f / 64),
(vertex.vertex.z - brush->center.z) * (1.0f / 64),
(vertex.vertex.x - brush->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
}
);
}
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);
}
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(!bsp.IsTrigger)
{
if (lastTextureID != face->texture_idx)
{
lastTexturePath = FileSystem::Root + "textures/" + std::string(texture->name) + ".png";
if (std::string(texture->name) == "__TB_empty")
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
else
@@ -308,118 +186,241 @@ void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst,
index_offset += (face_geo_inst->vertex_count);
}
}
else
if (vertices.size() > 0)
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)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::string name = fgdBrush.Name;
if (targetname != "")
name = targetname;
Entity brushEntity = scene->CreateEntity(name);
TransformComponent& transformComponent = brushEntity.GetComponent<TransformComponent>();
BSPBrushComponent& bsp = brushEntity.AddComponent<BSPBrushComponent>();
bsp.IsSolid = fgdBrush.Solid;
bsp.IsTransparent = !fgdBrush.Visible;
bsp.IsFunc = true;
bsp.IsTrigger = fgdBrush.IsTrigger;
if (fgdBrush.Script != "" && fgdBrush.Class != "")
{
index_offset += (face_geo_inst->vertex_count);
auto& wrenScript = brushEntity.AddComponent<WrenScriptComponent>();
wrenScript.Script = fgdBrush.Script;
wrenScript.Class = fgdBrush.Class;
}
}
if (bsp.IsTrigger)
{
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
vertices.clear();
}
if (vertices.size() > 0)
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
}
void QuakeMapBuilder::BuildQuakeMap(Entity& ent, bool Collisions)
{
if (!ent.HasComponent<QuakeMapComponent>())
return;
QuakeMapComponent& quakeMapC = ent.GetComponent<QuakeMapComponent>();
Scene* m_Scene = ent.GetScene();
// TODO: Tag entities *owned* by the map.
ParentComponent& currentParent = ent.GetComponent<ParentComponent>();
// Copy queue, cant delete while iterating.
auto deletionQueue = currentParent.Children;
for (auto& e : deletionQueue)
{
m_Scene->DestroyEntity(e);
}
map_parser_load(std::string(FileSystem::Root + quakeMapC.Path).c_str());
geo_generator_run();
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) );
if (entity_inst->spawn_type == entity_spawn_type::EST_GROUP)
newEntity.GetComponent<NameComponent>().Name = "Group " + std::to_string(e);
bool isTrigger = false;
bool isFunc = false;
bool isPos = false;
ent.AddChild(newEntity);
std::string target = "";
std::string targetname = "";
FGDBrushEntity fgdBrush;
bool isEntity = false;
for (int i = 0; i < entity_inst->property_count; i++)
if (bsp.IsTrigger)
{
property* prop = &(entity_inst->properties)[i];
std::string key = prop->key;
std::string value = prop->value;
if (key == "origin")
{
// Positon split with space.
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")
{
Ref<FGDFile> file = Engine::GetProject()->EntityDefinitionsFile;
EntityType type = file->GetTypeOfEntity(value);
if (type != EntityType::None)
{
if (type == EntityType::Brush)
{
fgdBrush = file->GetBrushEntity(value);
isEntity = true;
}
}
}
if (key == "targetname")
{
targetname = value;
}
if (key == "target")
{
target = value;
}
TriggerZone& trigger = brushEntity.AddComponent<TriggerZone>();
trigger.target = target;
}
for (int b = 0; b < entity_inst->brush_count; ++b)
bsp.target = target;
parent.AddChild(brushEntity);
transformComponent.Translation = Vector3(
brush->center.y * (1.0f / 64),
brush->center.z * (1.0f / 64),
brush->center.x * (1.0f / 64));
int index_offset = 0;
int lastTextureID = -1;
std::string lastTexturePath = "";
for (int f = 0; f < brush->face_count; ++f)
{
brush* brush_inst = &entity_inst->brushes[b];
brush_geometry* brush_geo_inst = &entity_geo_inst->brushes[b];
if (isEntity)
face* face = &brush->faces[f];
texture_data* texture = &textures[face->texture_idx];
if (std::string(texture->name) == "__TB_empty")
{
CreateFuncBrush(brush_inst, brush_geo_inst, m_Scene, newEntity, target, targetname, fgdBrush);
texture->height = 1;
texture->width = 1;
}
else
{
CreateBrush(brush_inst, brush_geo_inst, m_Scene, newEntity, target, targetname);
std::string path = FileSystem::Root + 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_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->center.y) * (1.0f / 64),
(vertex.vertex.z - brush->center.z) * (1.0f / 64),
(vertex.vertex.x - brush->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 (!bsp.IsTrigger)
{
if (lastTextureID != face->texture_idx)
{
lastTexturePath = FileSystem::Root + "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);
}
}
else
{
index_offset += (face_geo_inst->vertex_count);
}
}
isEntity = false;
if (bsp.IsTrigger)
{
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
vertices.clear();
}
if (vertices.size() > 0)
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
}
}
void QuakeMapBuilder::BuildQuakeMap(Entity& ent, bool Collisions)
{
if (!ent.HasComponent<QuakeMapComponent>())
return;
QuakeMapComponent& quakeMapC = ent.GetComponent<QuakeMapComponent>();
Scene* m_Scene = ent.GetScene();
// TODO: Tag entities *owned* by the map.
ParentComponent& currentParent = ent.GetComponent<ParentComponent>();
// Copy queue, cant delete while iterating.
auto deletionQueue = currentParent.Children;
for (auto& e : deletionQueue)
{
m_Scene->DestroyEntity(e);
}
map_parser_load(std::string(FileSystem::Root + quakeMapC.Path).c_str());
geo_generator_run();
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));
if (entity_inst->spawn_type == entity_spawn_type::EST_GROUP)
newEntity.GetComponent<NameComponent>().Name = "Group " + std::to_string(e);
bool isTrigger = false;
bool isFunc = false;
bool isPos = false;
ent.AddChild(newEntity);
std::string target = "";
std::string targetname = "";
FGDBrushEntity fgdBrush;
bool isEntity = false;
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")
{
// Positon split with space.
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")
{
Ref<FGDFile> file = Engine::GetProject()->EntityDefinitionsFile;
EntityType type = file->GetTypeOfEntity(value);
if (type != EntityType::None)
{
if (type == EntityType::Brush)
{
fgdBrush = file->GetBrushEntity(value);
isEntity = true;
}
}
}
if (key == "targetname")
{
targetname = value;
}
if (key == "target")
{
target = value;
}
}
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];
if (isEntity)
{
CreateFuncBrush(brush_inst, brush_geo_inst, m_Scene, newEntity, target, targetname, fgdBrush);
}
else
{
CreateBrush(brush_inst, brush_geo_inst, m_Scene, newEntity, target, targetname);
}
}
isEntity = false;
}
}
}

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

@@ -1,20 +1,26 @@
#pragma once
#include <string>
class Entity;
class Scene;
struct brush;
struct brush_geometry;
class FGDBrushEntity;
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);
public:
QuakeMapBuilder(){}
void BuildQuakeMap(Entity& ent, bool Collisions = true);
namespace Nuake {
class Entity;
class Scene;
class FGDBrushEntity;
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);
public:
QuakeMapBuilder() {}
void BuildQuakeMap(Entity& ent, bool Collisions = true);
};
}
};

118
Nuake/src/Scene/Systems/ScriptingSystem.cpp
View File

@@ -1,74 +1,76 @@
#include "ScriptingSystem.h"
#include <src/Scene/Components/WrenScriptComponent.h>
#include "src/Scene/Components/WrenScriptComponent.h"
#include "src/Scene/Scene.h"
ScriptingSystem::ScriptingSystem(Scene* scene)
{
m_Scene = scene;
}
bool ScriptingSystem::Init()
{
ScriptingEngine::Init();
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto e : entities)
namespace Nuake {
ScriptingSystem::ScriptingSystem(Scene* scene)
{
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.Script != "" && wren.Class != "")
m_Scene = scene;
}
bool ScriptingSystem::Init()
{
ScriptingEngine::Init();
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto e : entities)
{
wren.WrenScript = CreateRef<WrenScript>(wren.Script, wren.Class, true);
if (!wren.WrenScript->CompiledSuccesfully)
return false;
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.Script != "" && wren.Class != "")
{
wren.WrenScript = CreateRef<WrenScript>(wren.Script, wren.Class, true);
if (!wren.WrenScript->CompiledSuccesfully)
return false;
}
if (wren.WrenScript != nullptr)
{
wren.WrenScript->SetScriptableEntityID((int)e);
wren.WrenScript->CallInit();
}
}
if (wren.WrenScript != nullptr)
return true;
}
void ScriptingSystem::Update(Timestep ts)
{
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto& e : entities)
{
wren.WrenScript->SetScriptableEntityID((int)e);
wren.WrenScript->CallInit();
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.WrenScript != nullptr)
wren.WrenScript->CallUpdate(ts);
}
}
return true;
}
void ScriptingSystem::Update(Timestep ts)
{
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto& e : entities)
void ScriptingSystem::FixedUpdate(Timestep ts)
{
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto& e : entities)
{
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.WrenScript != nullptr)
wren.WrenScript->CallUpdate(ts);
}
}
void ScriptingSystem::FixedUpdate(Timestep ts)
{
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto& e : entities)
{
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.WrenScript != nullptr)
wren.WrenScript->CallFixedUpdate(ts);
}
}
void ScriptingSystem::Exit()
{
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto& e : entities)
{
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.WrenScript != nullptr)
wren.WrenScript->CallExit();
if (wren.WrenScript != nullptr)
wren.WrenScript->CallFixedUpdate(ts);
}
}
ScriptingEngine::Close();
}
void ScriptingSystem::Exit()
{
auto entities = m_Scene->m_Registry.view<WrenScriptComponent>();
for (auto& e : entities)
{
WrenScriptComponent& wren = entities.get<WrenScriptComponent>(e);
if (wren.WrenScript != nullptr)
wren.WrenScript->CallExit();
}
ScriptingEngine::Close();
}
}

24
Nuake/src/Scene/Systems/ScriptingSystem.h
View File

@@ -1,13 +1,17 @@
#pragma once
#include "System.h"
class Scene;
class ScriptingSystem : public System {
public:
ScriptingSystem(Scene* scene);
bool Init() override;
void Update(Timestep ts) override;
void Draw() override {}
void FixedUpdate(Timestep ts) override;
void Exit() override;
};
namespace Nuake {
class Scene;
class ScriptingSystem : public System
{
public:
ScriptingSystem(Scene* scene);
bool Init() override;
void Update(Timestep ts) override;
void Draw() override {}
void FixedUpdate(Timestep ts) override;
void Exit() override;
};
}

25
Nuake/src/Scene/Systems/System.h
View File

@@ -1,18 +1,21 @@
#pragma once
#include <src/Core/Timestep.h>
#include "src/Core/Timestep.h"
#include "src/Core/Core.h"
class Scene;
class System {
public:
Scene* m_Scene;
namespace Nuake
{
class Scene;
class System {
public:
Scene* m_Scene;
virtual bool Init() = 0;
virtual bool Init() = 0;
virtual void Draw() = 0;
virtual void Draw() = 0;
virtual void Update(Timestep ts) = 0;
virtual void FixedUpdate(Timestep ts) = 0;
virtual void Update(Timestep ts) = 0;
virtual void FixedUpdate(Timestep ts) = 0;
virtual void Exit() = 0;
};
virtual void Exit() = 0;
};
}

82
Nuake/src/Scene/Systems/TransformSystem.cpp
View File

@@ -1,54 +1,56 @@
#include "TransformSystem.h"
#include "src/Scene/Scene.h"
#include <src/Scene/Components/TransformComponent.h>
#include <src/Scene/Components/ParentComponent.h>
#include "src/Scene/Components/TransformComponent.h"
#include "src/Scene/Components/ParentComponent.h"
TransformSystem::TransformSystem(Scene* scene)
{
m_Scene = scene;
}
namespace Nuake {
TransformSystem::TransformSystem(Scene* scene)
{
m_Scene = scene;
}
bool TransformSystem::Init()
{
UpdateTransform();
return true;
}
bool TransformSystem::Init()
{
UpdateTransform();
return true;
}
void TransformSystem::Update(Timestep ts)
{
UpdateTransform();
}
void TransformSystem::Update(Timestep ts)
{
UpdateTransform();
}
void TransformSystem::FixedUpdate(Timestep ts)
{
void TransformSystem::FixedUpdate(Timestep ts)
{
}
}
void TransformSystem::Exit()
{
void TransformSystem::Exit()
{
}
}
void TransformSystem::UpdateTransform()
{
auto transformView = m_Scene->m_Registry.view<ParentComponent, TransformComponent>();
for (auto e : transformView) {
auto [parent, transform] = transformView.get<ParentComponent, TransformComponent>(e);
Entity currentParent = Entity((entt::entity)e, m_Scene);
Vector3 globalPos = Vector3();
if (parent.HasParent)
{
while (currentParent.GetComponent<ParentComponent>().HasParent)
void TransformSystem::UpdateTransform()
{
auto transformView = m_Scene->m_Registry.view<ParentComponent, TransformComponent>();
for (auto e : transformView) {
auto [parent, transform] = transformView.get<ParentComponent, TransformComponent>(e);
Entity currentParent = Entity((entt::entity)e, m_Scene);
Vector3 globalPos = Vector3();
if (parent.HasParent)
{
currentParent = currentParent.GetComponent<ParentComponent>().Parent;
globalPos += currentParent.GetComponent<TransformComponent>().Translation;
}
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;
transform.GlobalTranslation = globalPos + transform.Translation;
}
else
{
transform.GlobalTranslation = transform.Translation;
}
}
}
}
}

26
Nuake/src/Scene/Systems/TransformSystem.h
View File

@@ -1,15 +1,19 @@
#pragma once
#include "System.h"
class Scene;
class TransformSystem : public System {
public:
TransformSystem(Scene* scene);
bool Init() override;
void Update(Timestep ts) override;
void Draw() override {}
void FixedUpdate(Timestep ts) override;
void Exit() override;
namespace Nuake {
class Scene;
void UpdateTransform();
};
class TransformSystem : public System
{
public:
TransformSystem(Scene* scene);
bool Init() override;
void Update(Timestep ts) override;
void Draw() override {}
void FixedUpdate(Timestep ts) override;
void Exit() override;
void UpdateTransform();
};
}

48
Nuake/src/Scene/Systems/TrenchbroomSystem.cpp
View File

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

22
Nuake/src/Scene/Systems/TrenchbroomSystem.h
View File

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