ShibaGit/khaotic-engine-Reborn
ShibaGit/khaotic-engine-Reborn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity

Minor - ImGui Use ECS - V12.4.0

Browse Source
This commit is contained in:
CatChow0 2025-06-24 16:44:29 +02:00
parent 8f0e583c62
commit ddf5ea30a6
5 changed files with 295 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
enginecustom/imgui.ini
View File

@ -53,7 +53,7 @@ DockId=0x00000006,0
[Docking][Data] [Docking][Data]
DockSpace ID=0xCCBD8CF7 Window=0x3DA2F1DE Pos=0,19 Size=1584,842 Split=Y DockSpace ID=0xCCBD8CF7 Window=0x3DA2F1DE Pos=0,19 Size=1584,842 Split=Y
DockNode ID=0x00000003 Parent=0xCCBD8CF7 SizeRef=1584,609 Split=X DockNode ID=0x00000003 Parent=0xCCBD8CF7 SizeRef=1584,609 Split=X
DockNode ID=0x0000000B Parent=0x00000003 SizeRef=234,842 Selected=0x321620B2 DockNode ID=0x0000000B Parent=0x00000003 SizeRef=234,842 Selected=0x031DC75C
DockNode ID=0x0000000C Parent=0x00000003 SizeRef=1348,842 Split=X DockNode ID=0x0000000C Parent=0x00000003 SizeRef=1348,842 Split=X
DockNode ID=0x00000007 Parent=0x0000000C SizeRef=266,842 Selected=0x393905AB DockNode ID=0x00000007 Parent=0x0000000C SizeRef=266,842 Selected=0x393905AB
DockNode ID=0x00000008 Parent=0x0000000C SizeRef=1316,842 Split=X DockNode ID=0x00000008 Parent=0x0000000C SizeRef=1316,842 Split=X

2
enginecustom/src/inc/system/application_class.h
View File

@ -173,6 +173,8 @@ public:
stats* get_stats() const { return stats_; }; stats* get_stats() const { return stats_; };
fps_class* get_fps() const { return fps_; }; fps_class* get_fps() const { return fps_; };
ecs::EntityManager* get_entity_manager() const { return entity_manager_.get(); };
private: private:
bool render(float, float, float, float, float); bool render(float, float, float, float, float);
bool render_physics(float delta_time); bool render_physics(float delta_time);

548
enginecustom/src/src/system/imguiManager.cpp
View File

@ -386,290 +386,313 @@ void imguiManager::WidgetAddObject()
} }
ImGui::SameLine(); ImGui::SameLine();
ImGui::Text("Number of cubes: %d", app_->get_cube_count()); ImGui::Text("Number of cubes: %d", 1);
} }
} }
void imguiManager::WidgetObjectWindow() void imguiManager::WidgetObjectWindow()
{ {
ImGui::Begin("Objects", &showObjectWindow); ImGui::Begin("Objects", &showObjectWindow);
// Obtenir toutes les entités avec un composant d'identité et de transformation
auto entities = app_->get_entity_manager()->GetEntitiesWithComponent<ecs::IdentityComponent>();
int index = 0; int index = 0;
for (auto& object : app_->get_kobjects()) for (auto& entity : entities)
{ {
std::string headerName = object->GetName() + " " + std::to_string(index); auto identity = entity->GetComponent<ecs::IdentityComponent>();
if (ImGui::CollapsingHeader(headerName.c_str())) auto transform = entity->GetComponent<ecs::TransformComponent>();
auto render = entity->GetComponent<ecs::RenderComponent>();
auto shader = entity->GetComponent<ecs::ShaderComponent>();
auto physics = entity->GetComponent<ecs::PhysicsComponent>();
if (identity && transform)
{ {
std::string headerName = identity->GetName() + " " + std::to_string(identity->GetId());
XMVECTOR position = object->GetPosition(); if (ImGui::CollapsingHeader(headerName.c_str()))
XMVECTOR rotation = object->GetRotation();
XMVECTOR scale = object->GetScale();
float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
std::string posLabel = "Position##" + std::to_string(index);
if (ImGui::DragFloat3(posLabel.c_str(), pos))
{ {
object->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f)); // Position, Rotation, Scale
} XMVECTOR position = transform->GetPosition();
XMVECTOR rotation = transform->GetRotation();
XMVECTOR scale = transform->GetScale();
float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) }; float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
std::string rotLabel = "Rotation##" + std::to_string(index); std::string posLabel = "Position##" + std::to_string(identity->GetId());
if (ImGui::DragFloat3(rotLabel.c_str(), rot)) if (ImGui::DragFloat3(posLabel.c_str(), pos))
{
object->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
}
float scl[3] = { XMVectorGetX(scale), XMVectorGetY(scale), XMVectorGetZ(scale) };
std::string sclLabel = "Scale##" + std::to_string(index);
if (ImGui::DragFloat3(sclLabel.c_str(), scl))
{
object->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
}
ImGui::Separator();
// Définir les types de textures_
std::vector<std::string> textureCategories = {
"Diffuse", "Normal", "Specular", "Alpha"
};
std::vector<TextureType> textureTypes = {
TextureType::Diffuse, TextureType::Normal,
TextureType::Specular, TextureType::Alpha
};
// Créer un espace pour afficher les textures_ avec défilement
ImGui::BeginChild("TextureChild", ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
// Pour chaque type de texture
for (int typeIndex = 0; typeIndex < textureCategories.size(); typeIndex++)
{
TextureType type = textureTypes[typeIndex];
std::string typeName = textureCategories[typeIndex];
// Afficher le titre de la catégorie
ImGui::Text("%s:", typeName.c_str());
ImGui::SameLine();
// Compter combien de textures_ de ce type existent
int textureCount = 0;
while (object->get_model()->GetTexture(type, textureCount) != nullptr)
{
textureCount++;
}
// Afficher toutes les textures_ existantes
ImGui::BeginGroup();
for (int texIndex = 0; texIndex < textureCount; texIndex++)
{
ID3D11ShaderResourceView* texture = object->get_model()->GetTexture(type, texIndex);
if (texture)
{
// ID unique pour chaque bouton de texture
std::string buttonId = "tex##" + std::to_string(index) + "_" +
std::to_string(typeIndex) + "_" +
std::to_string(texIndex);
if (ImGui::ImageButton(buttonId.c_str(), (ImTextureID)texture, ImVec2(48, 48)))
{
// Ouvrir une boîte de dialogue pour changer la texture
OPENFILENAME ofn;
WCHAR szFile[260];
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFile = szFile;
szFile[0] = '\0';
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
ofn.nFilterIndex = 1;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// Changer la texture existante
object->get_model()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
}
}
// Afficher l'indice de texture et prévisualisation au survol
if (ImGui::IsItemHovered())
{
ImGui::BeginTooltip();
ImGui::Text("%s %d", typeName.c_str(), texIndex);
ImGui::Image((ImTextureID)texture, ImVec2(192, 192));
ImGui::EndTooltip();
}
ImGui::SameLine();
}
}
// Bouton pour ajouter une nouvelle texture
std::string addButtonLabel = "+##" + std::to_string(index) + "_" + std::to_string(typeIndex);
if (ImGui::Button(addButtonLabel.c_str(), ImVec2(48, 48)))
{
// Ouvrir une boîte de dialogue pour ajouter une texture
OPENFILENAME ofn;
WCHAR szFile[260];
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFile = szFile;
szFile[0] = '\0';
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
ofn.nFilterIndex = 1;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// Ajouter une nouvelle texture
object->get_model()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
}
}
ImGui::EndGroup();
ImGui::Separator();
}
ImGui::EndChild();
ImGui::Separator();
// Delete button
std::string deleteLabel = "Delete##" + std::to_string(index);
if (ImGui::Button(deleteLabel.c_str()))
{
app_->delete_kobject(index);
}
ImGui::Separator();
// Liste des options
const char* shaderOptions[] = {
"Enable Global Lighting",
"Enable Lighting",
"Enable Cel Shading",
"Enable Normal Mapping",
"Enable Specular Mapping",
"Enable Alpha Mapping"
};
ShaderType shaderTypes[] = {
ShaderType::SUNLIGHT,
ShaderType::LIGHTING,
ShaderType::CEL_SHADING,
ShaderType::NORMAL_MAPPING,
ShaderType::SPECULAR_MAPPING,
ShaderType::ALPHA_MAPPING
};
// Variable pour stocker l'option sélectionnée
static int currentShader = 0; // Index de l'option actuellement sélectionnée
// Création du menu déroulant
if (ImGui::BeginCombo("Shader Options", shaderOptions[currentShader]))
{
for (int i = 0; i < IM_ARRAYSIZE(shaderOptions); i++)
{ {
// Crée une option sélectionnable pour chaque shader transform->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
bool isSelected = (currentShader == i); transform->UpdateWorldMatrix();
if (ImGui::Selectable(shaderOptions[i], isSelected)) }
float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) };
std::string rotLabel = "Rotation##" + std::to_string(identity->GetId());
if (ImGui::DragFloat3(rotLabel.c_str(), rot))
{
transform->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
transform->UpdateWorldMatrix();
}
float scl[3] = { XMVectorGetX(scale), XMVectorGetY(scale), XMVectorGetZ(scale) };
std::string sclLabel = "Scale##" + std::to_string(identity->GetId());
if (ImGui::DragFloat3(sclLabel.c_str(), scl))
{
transform->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
transform->UpdateWorldMatrix();
}
ImGui::Separator();
// Textures - Seulement si le composant de rendu existe
if (render && render->GetModel())
{
// Définir les types de textures_
std::vector<std::string> textureCategories = {
"Diffuse", "Normal", "Specular", "Alpha"
};
std::vector<TextureType> textureTypes = {
TextureType::Diffuse, TextureType::Normal,
TextureType::Specular, TextureType::Alpha
};
// Créer un espace pour afficher les textures_ avec défilement
std::string textureChildId = "TextureChild##" + std::to_string(identity->GetId());
ImGui::BeginChild(textureChildId.c_str(), ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
// Pour chaque type de texture
for (int typeIndex = 0; typeIndex < textureCategories.size(); typeIndex++)
{ {
// Met à jour l'option sélectionnée TextureType type = textureTypes[typeIndex];
currentShader = i; std::string typeName = textureCategories[typeIndex];
object->SetActiveShader(shaderTypes[i]);
// Afficher le titre de la catégorie
std::string categoryLabel = typeName + "##" + std::to_string(identity->GetId());
ImGui::Text("%s:", typeName.c_str());
ImGui::SameLine();
// Compter combien de textures_ de ce type existent
int textureCount = 0;
while (render->GetModel()->GetTexture(type, textureCount) != nullptr)
{
textureCount++;
}
// Afficher toutes les textures_ existantes
std::string groupId = "TextureGroup_" + std::to_string(identity->GetId()) + "_" + std::to_string(typeIndex);
ImGui::BeginGroup();
for (int texIndex = 0; texIndex < textureCount; texIndex++)
{
ID3D11ShaderResourceView* texture = render->GetModel()->GetTexture(type, texIndex);
if (texture)
{
// ID unique pour chaque bouton de texture
std::string buttonId = "tex##" + std::to_string(identity->GetId()) + "_" +
std::to_string(typeIndex) + "_" +
std::to_string(texIndex);
if (ImGui::ImageButton(buttonId.c_str(), (ImTextureID)texture, ImVec2(48, 48)))
{
// Ouvrir une boîte de dialogue pour changer la texture
OPENFILENAME ofn;
WCHAR szFile[260] = {0};
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFile = szFile;
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
ofn.nFilterIndex = 1;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// Changer la texture existante
render->GetModel()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
}
}
// Afficher l'indice de texture et prévisualisation au survol
if (ImGui::IsItemHovered())
{
ImGui::BeginTooltip();
ImGui::Text("%s %d", typeName.c_str(), texIndex);
ImGui::Image((ImTextureID)texture, ImVec2(192, 192));
ImGui::EndTooltip();
}
ImGui::SameLine();
}
}
// Bouton pour ajouter une nouvelle texture
std::string addButtonLabel = "+##" + std::to_string(identity->GetId()) + "_" + std::to_string(typeIndex);
if (ImGui::Button(addButtonLabel.c_str(), ImVec2(48, 48)))
{
// Ouvrir une boîte de dialogue pour ajouter une texture
OPENFILENAME ofn;
WCHAR szFile[260] = {0};
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFile = szFile;
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
ofn.nFilterIndex = 1;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// Ajouter une nouvelle texture
render->GetModel()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
}
}
ImGui::EndGroup();
ImGui::Separator();
}
ImGui::EndChild();
}
ImGui::Separator();
// Delete button
std::string deleteLabel = "Delete##" + std::to_string(identity->GetId());
if (ImGui::Button(deleteLabel.c_str()))
{
app_->delete_entity_by_id(identity->GetId());
// Sortir du boucle après suppression pour éviter des accès invalides
break;
}
ImGui::Separator();
// Shader options
if (shader)
{
// Liste des options de shader
const char* shaderOptions[] = {
"Enable Global Lighting",
"Enable Lighting",
"Enable Cel Shading",
"Enable Normal Mapping",
"Enable Specular Mapping",
"Enable Alpha Mapping"
};
std::vector<ecs::ShaderType> shaderTypes = {
ecs::ShaderType::SUNLIGHT,
ecs::ShaderType::LIGHTING,
ecs::ShaderType::CEL_SHADING,
ecs::ShaderType::NORMAL_MAPPING,
ecs::ShaderType::SPECULAR_MAPPING,
ecs::ShaderType::ALPHA_MAPPING
};
// Trouver l'index actuel du shader pour cette entité spécifique
int currentShader = 0;
ecs::ShaderType activeShader = shader->GetActiveShader();
for (size_t i = 0; i < shaderTypes.size(); i++)
{
if (shaderTypes[i] == activeShader)
{
currentShader = static_cast<int>(i);
break;
}
} }
// Si l'option sélectionnée est active, nous mettons en surbrillance // Création du menu déroulant avec un ID unique pour chaque entité
if (isSelected) std::string shaderComboId = "Shader Options##" + std::to_string(identity->GetId());
ImGui::SetItemDefaultFocus(); if (ImGui::BeginCombo(shaderComboId.c_str(), shaderOptions[currentShader]))
{
for (int i = 0; i < IM_ARRAYSIZE(shaderOptions); i++)
{
// Crée une option sélectionnable pour chaque shader avec ID unique
std::string shaderSelectableId = std::to_string(i) + "##shader_" + std::to_string(identity->GetId());
bool isSelected = (currentShader == i);
if (ImGui::Selectable(shaderOptions[i], isSelected))
{
// Met à jour l'option sélectionnée uniquement pour cette entité
currentShader = i;
shader->SetActiveShader(shaderTypes[i]);
}
// Si l'option sélectionnée est active, nous mettons en surbrillance
if (isSelected)
ImGui::SetItemDefaultFocus();
}
ImGui::EndCombo();
}
} }
ImGui::EndCombo();
} ImGui::Separator();
// Physics
ImGui::Separator(); bool isPhysicsEnabled = (physics != nullptr);
std::string physicsLabel = "Physics##" + std::to_string(identity->GetId());
if (ImGui::Checkbox(physicsLabel.c_str(), &isPhysicsEnabled))
{
if (isPhysicsEnabled && !physics)
{
// Ajouter un composant de physique
physics = entity->AddComponent<ecs::PhysicsComponent>();
physics->Initialize();
}
else if (!isPhysicsEnabled && physics)
{
// Retirer le composant de physique
entity->RemoveComponent<ecs::PhysicsComponent>();
physics = nullptr;
}
}
// physics if (physics)
std::string physicsLabel = "physics##" + std::to_string(index); {
// Gravity Enabled checkbox
if (ImGui::Checkbox(physicsLabel.c_str(), &m_isPhyiscsEnabled)) bool gravityEnabled = physics->IsGravityEnabled();
{ std::string gravityLabel = "Gravity##" + std::to_string(identity->GetId());
object->SetPhysicsEnabled(m_isPhyiscsEnabled); if (ImGui::Checkbox(gravityLabel.c_str(), &gravityEnabled))
} {
physics->SetGravityEnabled(gravityEnabled);
}
// Gravity Enabled checkbox // 3 radio buttons pour le type d'objet physique avec IDs uniques
std::string gravityLabel = "Gravity##" + std::to_string(index); std::string typeLabel = "Type##" + std::to_string(identity->GetId());
if (ImGui::Checkbox(gravityLabel.c_str(), &object->m_gravityEnabled)) ecs::ObjectType type = identity->GetType();
{
object->SetGravityEnabled(object->m_gravityEnabled);
}
// 3 radio button on the same line to set the ObjectType if (ImGui::RadioButton(("None##" + std::to_string(identity->GetId())).c_str(),
std::string typeLabel = "Type##" + std::to_string(index); type == ecs::ObjectType::Unknown))
ObjectType type = object->GetType(); {
if (ImGui::RadioButton("None", type == ObjectType::Unknown)) identity->SetType(ecs::ObjectType::Unknown);
{ }
object->SetType(ObjectType::Unknown); ImGui::SameLine();
} if (ImGui::RadioButton(("Cube##" + std::to_string(identity->GetId())).c_str(),
ImGui::SameLine(); type == ecs::ObjectType::Cube))
if (ImGui::RadioButton("Cube", type == ObjectType::Cube)) {
{ identity->SetType(ecs::ObjectType::Cube);
object->SetType(ObjectType::Cube); }
} ImGui::SameLine();
ImGui::SameLine(); if (ImGui::RadioButton(("Sphere##" + std::to_string(identity->GetId())).c_str(),
if (ImGui::RadioButton("Sphere", type == ObjectType::Sphere)) type == ecs::ObjectType::Sphere))
{ {
object->SetType(ObjectType::Sphere); identity->SetType(ecs::ObjectType::Sphere);
} }
ImGui::SameLine();
if (ImGui::RadioButton(("Terrain##" + std::to_string(identity->GetId())).c_str(),
type == ecs::ObjectType::Terrain))
{
identity->SetType(ecs::ObjectType::Terrain);
}
// button to launch the object }
std::string launchLabel = "Launch##" + std::to_string(index);
// paraeter to set the alpha, initial stretch and spring constant ImGui::Separator();
float alpha = object->GetAlpha();
float initialStretch = object->GetInitialStretch();
float springConstant = object->GetSpringConstant();
if (ImGui::DragFloat("Alpha##" , &alpha, 0.01f, 0.0f, 1.0f))
{
object->SetAlpha(alpha);
} }
if (ImGui::DragFloat("Initial Stretch##", &initialStretch, 0.01f, 0.0f, 1.0f)) index++;
{
object->SetInitialStretch(initialStretch);
}
if (ImGui::DragFloat("Spring Constant##", &springConstant, 0.01f, 0.0f, 100.0f))
{
object->SetSpringConstant(springConstant);
}
if (ImGui::Button(launchLabel.c_str()))
{
object->LaunchObject();
}
ImGui::SameLine();
// button to stop the object
std::string stopLabel = "Stop##" + std::to_string(index);
if (ImGui::Button(stopLabel.c_str()))
{
object->SetVelocity(XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f));
object->SetPosition(XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f));
}
ImGui::Separator();
// Demo spinning
std::string demoLabel = "Demo spinning##" + std::to_string(index);
ImGui::Checkbox(demoLabel.c_str(), &object->m_demoSpinning);
} }
index++;
} }
ImGui::End(); ImGui::End();
@ -679,7 +702,7 @@ void imguiManager::WidgetTerrainWindow()
{ {
ImGui::Begin("Terrain", &showTerrainWindow); ImGui::Begin("Terrain", &showTerrainWindow);
ImGui::Text("Number of terrain cubes: %d", app_->get_terrain_cube_count()); ImGui::Text("Number of terrain cubes: %d", 1);
ImGui::Separator(); ImGui::Separator();
@ -1106,4 +1129,5 @@ void imguiManager::WidgetRenderStats()
ImGui::Columns(1); ImGui::Columns(1);
ImGui::End(); ImGui::End();
} }

6
enginecustom/src/src/system/scene_manager.cpp
View File

@ -52,7 +52,7 @@ bool scene_manager::save_scene_as() {
// Mettre à jour le chemin de scène // Mettre à jour le chemin de scène
scene_path_ = convert_w_string_to_string(filepath.wstring()); scene_path_ = convert_w_string_to_string(filepath.wstring());
object_vec_ = app_->get_kobjects(); //object_vec_ = app_->get_kobjects();
// Sauvegarder la scène avec le nouveau chemin // Sauvegarder la scène avec le nouveau chemin
save_scene(); save_scene();
@ -67,7 +67,7 @@ bool scene_manager::save_scene_as() {
bool scene_manager::load_scene() { bool scene_manager::load_scene() {
Logger::Get().Log("Loading scene from " , __FILE__, __LINE__, Logger::LogLevel::Info); Logger::Get().Log("Loading scene from " , __FILE__, __LINE__, Logger::LogLevel::Info);
object_vec_ = app_->get_kobjects(); //object_vec_ = app_->get_kobjects();
object_id_ = app_->get_object_id(); object_id_ = app_->get_object_id();
w_folder_ = app_->get_w_folder(); w_folder_ = app_->get_w_folder();
direct_3d_ = app_->get_direct_3d(); direct_3d_ = app_->get_direct_3d();
@ -230,7 +230,7 @@ bool scene_manager::load_scene() {
} }
// pass the vec to the application // pass the vec to the application
app_->set_kobjects(object_vec_); //app_->set_kobjects(object_vec_);
Logger::Get().Log("Scene loaded successfully from ", __FILE__, __LINE__, Logger::LogLevel::Info); Logger::Get().Log("Scene loaded successfully from ", __FILE__, __LINE__, Logger::LogLevel::Info);
return true; return true;

6
enginecustom/src/src/system/stats.cpp
View File

@ -37,9 +37,9 @@ bool stats::initialize(application_class* app)
void stats::update_geometric_stats() void stats::update_geometric_stats()
{ {
object_vec_ = app_->get_kobjects(); // object_vec_ = app_->get_kobjects();
cubes_vec_ = app_->get_cubes(); // cubes_vec_ = app_->get_cubes();
terrain_chunk_vec_ = app_->get_terrain_cubes(); // terrain_chunk_vec_ = app_->get_terrain_cubes();
*total_vertex_count_ = get_total_vertex_count(); *total_vertex_count_ = get_total_vertex_count();