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]
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=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=0x00000007 Parent=0x0000000C SizeRef=266,842 Selected=0x393905AB
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_; };
fps_class* get_fps() const { return fps_; };
ecs::EntityManager* get_entity_manager() const { return entity_manager_.get(); };
private:
bool render(float, float, float, float, float);
bool render_physics(float delta_time);

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

@ -386,47 +386,65 @@ void imguiManager::WidgetAddObject()
}
ImGui::SameLine();
ImGui::Text("Number of cubes: %d", app_->get_cube_count());
ImGui::Text("Number of cubes: %d", 1);
}
}
void imguiManager::WidgetObjectWindow()
{
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;
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>();
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());
if (ImGui::CollapsingHeader(headerName.c_str()))
{
XMVECTOR position = object->GetPosition();
XMVECTOR rotation = object->GetRotation();
XMVECTOR scale = object->GetScale();
// Position, Rotation, Scale
XMVECTOR position = transform->GetPosition();
XMVECTOR rotation = transform->GetRotation();
XMVECTOR scale = transform->GetScale();
float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
std::string posLabel = "Position##" + std::to_string(index);
std::string posLabel = "Position##" + std::to_string(identity->GetId());
if (ImGui::DragFloat3(posLabel.c_str(), pos))
{
object->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
transform->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
transform->UpdateWorldMatrix();
}
float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) };
std::string rotLabel = "Rotation##" + std::to_string(index);
std::string rotLabel = "Rotation##" + std::to_string(identity->GetId());
if (ImGui::DragFloat3(rotLabel.c_str(), rot))
{
object->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
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(index);
std::string sclLabel = "Scale##" + std::to_string(identity->GetId());
if (ImGui::DragFloat3(sclLabel.c_str(), scl))
{
object->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
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"
@ -438,7 +456,8 @@ void imguiManager::WidgetObjectWindow()
};
// Créer un espace pour afficher les textures_ avec défilement
ImGui::BeginChild("TextureChild", ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
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++)
@ -447,25 +466,27 @@ void imguiManager::WidgetObjectWindow()
std::string typeName = textureCategories[typeIndex];
// 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 (object->get_model()->GetTexture(type, textureCount) != nullptr)
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 = object->get_model()->GetTexture(type, texIndex);
ID3D11ShaderResourceView* texture = render->GetModel()->GetTexture(type, texIndex);
if (texture)
{
// ID unique pour chaque bouton de texture
std::string buttonId = "tex##" + std::to_string(index) + "_" +
std::string buttonId = "tex##" + std::to_string(identity->GetId()) + "_" +
std::to_string(typeIndex) + "_" +
std::to_string(texIndex);
@ -473,12 +494,11 @@ void imguiManager::WidgetObjectWindow()
{
// Ouvrir une boîte de dialogue pour changer la texture
OPENFILENAME ofn;
WCHAR szFile[260];
WCHAR szFile[260] = {0};
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;
@ -488,7 +508,7 @@ void imguiManager::WidgetObjectWindow()
if (GetOpenFileName(&ofn))
{
// Changer la texture existante
object->get_model()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
render->GetModel()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
}
}
@ -506,17 +526,16 @@ void imguiManager::WidgetObjectWindow()
}
// Bouton pour ajouter une nouvelle texture
std::string addButtonLabel = "+##" + std::to_string(index) + "_" + std::to_string(typeIndex);
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];
WCHAR szFile[260] = {0};
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;
@ -526,7 +545,7 @@ void imguiManager::WidgetObjectWindow()
if (GetOpenFileName(&ofn))
{
// Ajouter une nouvelle texture
object->get_model()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
render->GetModel()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
}
}
@ -535,19 +554,25 @@ void imguiManager::WidgetObjectWindow()
}
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
// 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",
@ -557,30 +582,41 @@ void imguiManager::WidgetObjectWindow()
"Enable Alpha Mapping"
};
ShaderType shaderTypes[] = {
ShaderType::SUNLIGHT,
ShaderType::LIGHTING,
ShaderType::CEL_SHADING,
ShaderType::NORMAL_MAPPING,
ShaderType::SPECULAR_MAPPING,
ShaderType::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
};
// Variable pour stocker l'option sélectionnée
static int currentShader = 0; // Index de l'option actuellement sélectionnée
// 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;
}
}
// Création du menu déroulant
if (ImGui::BeginCombo("Shader Options", shaderOptions[currentShader]))
// Création du menu déroulant avec un ID unique pour chaque entité
std::string shaderComboId = "Shader Options##" + std::to_string(identity->GetId());
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
// 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
// Met à jour l'option sélectionnée uniquement pour cette entité
currentShader = i;
object->SetActiveShader(shaderTypes[i]);
shader->SetActiveShader(shaderTypes[i]);
}
// Si l'option sélectionnée est active, nous mettons en surbrillance
@ -589,88 +625,75 @@ void imguiManager::WidgetObjectWindow()
}
ImGui::EndCombo();
}
}
ImGui::Separator();
// physics
std::string physicsLabel = "physics##" + std::to_string(index);
// Physics
bool isPhysicsEnabled = (physics != nullptr);
std::string physicsLabel = "Physics##" + std::to_string(identity->GetId());
if (ImGui::Checkbox(physicsLabel.c_str(), &m_isPhyiscsEnabled))
if (ImGui::Checkbox(physicsLabel.c_str(), &isPhysicsEnabled))
{
object->SetPhysicsEnabled(m_isPhyiscsEnabled);
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;
}
}
if (physics)
{
// Gravity Enabled checkbox
std::string gravityLabel = "Gravity##" + std::to_string(index);
if (ImGui::Checkbox(gravityLabel.c_str(), &object->m_gravityEnabled))
bool gravityEnabled = physics->IsGravityEnabled();
std::string gravityLabel = "Gravity##" + std::to_string(identity->GetId());
if (ImGui::Checkbox(gravityLabel.c_str(), &gravityEnabled))
{
object->SetGravityEnabled(object->m_gravityEnabled);
physics->SetGravityEnabled(gravityEnabled);
}
// 3 radio buttons pour le type d'objet physique avec IDs uniques
std::string typeLabel = "Type##" + std::to_string(identity->GetId());
ecs::ObjectType type = identity->GetType();
// 3 radio button on the same line to set the ObjectType
std::string typeLabel = "Type##" + std::to_string(index);
ObjectType type = object->GetType();
if (ImGui::RadioButton("None", type == ObjectType::Unknown))
if (ImGui::RadioButton(("None##" + std::to_string(identity->GetId())).c_str(),
type == ecs::ObjectType::Unknown))
{
object->SetType(ObjectType::Unknown);
identity->SetType(ecs::ObjectType::Unknown);
}
ImGui::SameLine();
if (ImGui::RadioButton("Cube", type == ObjectType::Cube))
if (ImGui::RadioButton(("Cube##" + std::to_string(identity->GetId())).c_str(),
type == ecs::ObjectType::Cube))
{
object->SetType(ObjectType::Cube);
identity->SetType(ecs::ObjectType::Cube);
}
ImGui::SameLine();
if (ImGui::RadioButton("Sphere", type == ObjectType::Sphere))
if (ImGui::RadioButton(("Sphere##" + std::to_string(identity->GetId())).c_str(),
type == ecs::ObjectType::Sphere))
{
object->SetType(ObjectType::Sphere);
}
// button to launch the object
std::string launchLabel = "Launch##" + std::to_string(index);
// paraeter to set the alpha, initial stretch and spring constant
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))
{
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();
identity->SetType(ecs::ObjectType::Sphere);
}
ImGui::SameLine();
// button to stop the object
std::string stopLabel = "Stop##" + std::to_string(index);
if (ImGui::Button(stopLabel.c_str()))
if (ImGui::RadioButton(("Terrain##" + std::to_string(identity->GetId())).c_str(),
type == ecs::ObjectType::Terrain))
{
object->SetVelocity(XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f));
object->SetPosition(XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f));
identity->SetType(ecs::ObjectType::Terrain);
}
}
ImGui::Separator();
// Demo spinning
std::string demoLabel = "Demo spinning##" + std::to_string(index);
ImGui::Checkbox(demoLabel.c_str(), &object->m_demoSpinning);
}
index++;
}
}
ImGui::End();
}
@ -679,7 +702,7 @@ void imguiManager::WidgetTerrainWindow()
{
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();
@ -1107,3 +1130,4 @@ void imguiManager::WidgetRenderStats()
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
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
save_scene();
@ -67,7 +67,7 @@ bool scene_manager::save_scene_as() {
bool scene_manager::load_scene() {
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();
w_folder_ = app_->get_w_folder();
direct_3d_ = app_->get_direct_3d();
@ -230,7 +230,7 @@ bool scene_manager::load_scene() {
}
// 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);
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()
{
object_vec_ = app_->get_kobjects();
cubes_vec_ = app_->get_cubes();
terrain_chunk_vec_ = app_->get_terrain_cubes();
// object_vec_ = app_->get_kobjects();
// cubes_vec_ = app_->get_cubes();
// terrain_chunk_vec_ = app_->get_terrain_cubes();
*total_vertex_count_ = get_total_vertex_count();