anfer/OpenEngine
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'jolt' into 3d

Browse Source
This commit is contained in:
Erris
2026-03-06 18:09:26 +01:00
parent eaef554b10 2d3fe57d5a
commit 44f766863d
17 changed files with 354 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
editor/include/editor_component.hpp
View File

@@ -19,7 +19,8 @@ namespace OpenEngine {
void MeshOnImGuiRender(entt::registry&registry, entt::entity entity);
void MaterialOnImGuiRender(entt::registry& registry, entt::entity entity);
void BodyOnImGuiRender(entt::registry& registry, entt::entity entity);
void ShapeOnImGuiRender(entt::registry& registry, entt::entity entity);
void SphereShapeOnImGuiRender(entt::registry& registry, entt::entity entity);
void BoxShapeOnImGuiRender(entt::registry& registry, entt::entity entity);
}
#endif // EDITOR_COMPONENT_HPP

86
editor/src/editor_component.cpp
View File

@@ -1,6 +1,7 @@
#include "imgui.h"
#include "open_engine/renderer/renderer3d.hpp"
#include "open_engine/scene/components.hpp"
#include <Jolt/Physics/Body/MotionType.h>
#include <editor_component.hpp>
#include <entt/entity/fwd.hpp>
#include <glm/gtc/type_ptr.hpp>
@@ -181,12 +182,11 @@ namespace OpenEngine {
{
auto& mesh_component = registry.get<MeshComponent>(entity);
const char* items[] = { "Quad", "Cube" };
static int item_selected_idx = 0;
const char* items[] = { "None", "Quad", "Cube" };
int item_selected_idx = (int)mesh_component.primitive_type;
if (ImGui::BeginCombo("Mesh", items[item_selected_idx])) {
for (int n = 0; n < 2; n++)
{
for (int n = 0; n < 3; n++) {
const bool is_selected = (item_selected_idx == n);
if (ImGui::Selectable(items[n], is_selected))
item_selected_idx = n;
@@ -196,25 +196,26 @@ namespace OpenEngine {
ImGui::SetItemDefaultFocus();
}
ImGui::EndCombo();
}
if ((int)mesh_component.primitive_type == (item_selected_idx + 1))
return;
if ((int)mesh_component.primitive_type == (item_selected_idx))
return;
mesh_component.primitive_type = (PrimitiveType)(item_selected_idx + 1);
switch (mesh_component.primitive_type) {
case OpenEngine::PrimitiveType::Quad:
{
mesh_component.mesh = CreateQuad((uint32_t)entity);
break;
}
case OpenEngine::PrimitiveType::Cube:
{
mesh_component.mesh = CreateCube((uint32_t)entity);
break;
}
default:
mesh_component.primitive_type = (PrimitiveType)(item_selected_idx);
switch (mesh_component.primitive_type) {
case OpenEngine::PrimitiveType::Quad:
{
mesh_component.mesh = CreateQuad((uint32_t)entity);
break;
}
}
case OpenEngine::PrimitiveType::Cube:
{
mesh_component.mesh = CreateCube((uint32_t)entity);
break;
}
default:
mesh_component.mesh = nullptr;
break;
}
}
@@ -233,16 +234,53 @@ namespace OpenEngine {
{
auto& body_comp = registry.get<PhysicsBodyComponent>(entity);
const char* items[] = { "Static", "Kinematic", "Dynamic" };
int item_selected_idx = body_comp.type;
if (ImGui::BeginCombo("Body type", items[item_selected_idx])) {
for (int n = 0; n < 3; n++)
{
const bool is_selected = (item_selected_idx == n);
if (ImGui::Selectable(items[n], is_selected))
item_selected_idx = n;
// Set the initial focus when opening the combo (scrolling + keyboard navigation focus)
if (is_selected)
ImGui::SetItemDefaultFocus();
}
ImGui::EndCombo();
}
body_comp.type = item_selected_idx;
ImGui::SliderFloat("Linear damping", &body_comp.linear_damping, 0, 1);
ImGui::SliderFloat("Angular damping", &body_comp.angular_damping, 0, 1);
ImGui::SliderFloat("Gravity factor", &body_comp.gravity_factor, 0, 1);
ImGui::SliderFloat("Bounciness", &body_comp.restitution, 0, 1);
ImGui::SliderFloat("Friction", &body_comp.friction, 0, 1);
}
void ShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
void SphereShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
{
auto& shape_comp = registry.get<PhysicsShapeComponent>(entity);
auto& sphere_comp = registry.get<SphereShapeComponent>(entity);
ImGui::SliderFloat("Bounciness", &shape_comp.restitution, 0, 1);
ImGui::SliderFloat("Friction", &shape_comp.friction, 0, 1);
ImGui::DragFloat("Radius",
&sphere_comp.radius,
0.1f,
0.11f, FLT_MAX,
"%.2f",
ImGuiSliderFlags_AlwaysClamp);
}
void BoxShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
{
auto& box_comp = registry.get<BoxShapeComponent>(entity);
ImGui::DragFloat3("Size",
glm::value_ptr(box_comp.size),
0.1f,
0.11f, FLT_MAX,
"%.2f",
ImGuiSliderFlags_AlwaysClamp);
}
}

15
editor/src/panels/scene_hierarchy.cpp
View File

@@ -1,4 +1,3 @@
#include "open_engine/scene/components.hpp"
#include "open_engine/scene/entity.hpp"
#include "editor_component.hpp"
@@ -25,7 +24,8 @@ namespace OpenEngine {
RegisterDrawer<MeshComponent>("Mesh", &MeshOnImGuiRender);
RegisterDrawer<MaterialComponent>("Material", &MaterialOnImGuiRender);
RegisterDrawer<PhysicsBodyComponent>("Physics Body", &BodyOnImGuiRender);
RegisterDrawer<PhysicsShapeComponent>("Physics Shape", &ShapeOnImGuiRender);
RegisterDrawer<SphereShapeComponent>("Sphere Shape", &SphereShapeOnImGuiRender);
RegisterDrawer<BoxShapeComponent>("Box Shape", &BoxShapeOnImGuiRender);
scene = context;
selected_context = {};
@@ -64,9 +64,14 @@ namespace OpenEngine {
selected_context.AddComponent<PhysicsBodyComponent>();
ImGui::CloseCurrentPopup();
}
if (!selected_context.HasComponent<PhysicsShapeComponent>())
if (ImGui::MenuItem("Physics shape")) {
selected_context.AddComponent<PhysicsShapeComponent>();
if (!selected_context.HasComponent<SphereShapeComponent>())
if (ImGui::MenuItem("Sphere shape")) {
selected_context.AddComponent<SphereShapeComponent>();
ImGui::CloseCurrentPopup();
}
if (!selected_context.HasComponent<BoxShapeComponent>())
if (ImGui::MenuItem("Box shape")) {
selected_context.AddComponent<BoxShapeComponent>();
ImGui::CloseCurrentPopup();
}
}

18
imgui.ini
View File

@@ -1,6 +1,6 @@
[Window][WindowOverViewport_11111111]
Pos=0,24
Size=2552,1363
Size=1272,1363
Collapsed=0
[Window][Debug##Default]
@@ -15,19 +15,19 @@ Collapsed=0
DockId=0x00000003,0
[Window][Properties]
Pos=2102,24
Pos=822,24
Size=450,805
Collapsed=0
DockId=0x00000007,0
[Window][Viewport]
Pos=226,61
Size=1874,956
Size=594,956
Collapsed=0
DockId=0x00000012,0
[Window][Dear ImGui Demo]
Pos=2102,831
Pos=822,831
Size=450,556
Collapsed=0
DockId=0x00000008,0
@@ -144,7 +144,7 @@ DockId=0x00000012,1
[Window][Assets]
Pos=226,1019
Size=1874,368
Size=594,368
Collapsed=0
DockId=0x0000000C,0
@@ -156,12 +156,12 @@ DockId=0x0000000F,0
[Window][##play_state_bar]
Pos=226,24
Size=1874,35
Size=594,35
Collapsed=0
DockId=0x00000011,0
[Docking][Data]
DockSpace ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=2552,1363 Split=X
DockSpace ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=1272,1363 Split=X
DockNode ID=0x00000005 Parent=0x08BD597D SizeRef=820,1386 Split=X
DockNode ID=0x00000001 Parent=0x00000005 SizeRef=224,1386 Split=Y Selected=0xE601B12F
DockNode ID=0x00000003 Parent=0x00000001 SizeRef=255,417 Selected=0x553E127E
@@ -178,6 +178,6 @@ DockSpace ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=2552,1363
DockNode ID=0x0000000C Parent=0x00000009 SizeRef=409,368 Selected=0x42C24103
DockNode ID=0x0000000A Parent=0x00000002 SizeRef=483,600 Selected=0x1BCA3180
DockNode ID=0x00000006 Parent=0x08BD597D SizeRef=450,1386 Split=Y Selected=0x8C72BEA8
DockNode ID=0x00000007 Parent=0x00000006 SizeRef=444,810 Selected=0x8C72BEA8
DockNode ID=0x00000008 Parent=0x00000006 SizeRef=444,559 Selected=0x5E5F7166
DockNode ID=0x00000007 Parent=0x00000006 SizeRef=444,805 Selected=0x8C72BEA8
DockNode ID=0x00000008 Parent=0x00000006 SizeRef=444,556 Selected=0x5E5F7166

2
open_engine/CMakeLists.txt
View File

@@ -74,3 +74,5 @@ add_subdirectory(vendor/glad
)
add_subdirectory("vendor/nativefiledialog-extended")
target_compile_options(open_engine PRIVATE -msse4.1 -msse4.2 -mavx -mavx2)

36
open_engine/include/open_engine/core/uuid.hpp Normal file
View File

@@ -0,0 +1,36 @@
#ifndef UUID_HPP
#define UUID_HPP
#include <cstdint>
namespace OpenEngine {
class UUID
{
public:
UUID();
UUID(uint64_t uuid);
UUID(const UUID&) = default;
operator uint64_t() const { return uuid; };
private:
uint64_t uuid;
};
}
namespace std {
template<>
struct hash<OpenEngine::UUID>
{
std::size_t operator()(const OpenEngine::UUID& uuid) const
{
return hash<uint64_t>()((uint64_t)uuid);
}
};
}
#endif // UUID_HPP

3
open_engine/include/open_engine/physics.hpp
View File

@@ -17,6 +17,7 @@
#include <Jolt/Physics/Body/BodyActivationListener.h>
#include <cstdarg>
#include <glm/glm.hpp>
using namespace JPH;
using namespace JPH::literals;
@@ -73,6 +74,8 @@ namespace BroadPhaseLayers
static constexpr uint NUM_LAYERS(2);
};
inline JPH::Vec3 ToJolt(const glm::vec3& v) { return JPH::Vec3(v.x, v.y, v.z); };
class BPLayerInterfaceImpl final : public BroadPhaseLayerInterface
{
public:

2
open_engine/include/open_engine/renderer/uniform_buffer.hpp
View File

@@ -8,7 +8,7 @@ namespace OpenEngine {
class UniformBuffer
{
public:
virtual ~UniformBuffer() {}
virtual ~UniformBuffer() = default;
virtual void SetData(const void* data, uint32_t size,
uint32_t offset = 0) = 0;

38
open_engine/include/open_engine/scene/components.hpp
View File

@@ -1,12 +1,12 @@
#ifndef COMPONENTS_HPP
#define COMPONENTS_HPP
#include "open_engine/scene/native_scriptable_entity.hpp"
#include "open_engine/renderer/renderer3d.hpp"
#include "open_engine/scene/scene_camera.hpp"
#include "open_engine/renderer/texture.hpp"
#include "open_engine/renderer/renderer3d.hpp"
#include "open_engine/physics.hpp"
#include "open_engine/core/uuid.hpp"
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Body/BodyInterface.h>
@@ -28,6 +28,15 @@
namespace OpenEngine {
struct IDComponent
{
UUID id;
IDComponent() = default;
IDComponent(const IDComponent&) = default;
IDComponent(const UUID& uuid) : id(uuid) {};
};
struct TagComponent
{
std::string tag;
@@ -74,6 +83,8 @@ namespace OpenEngine {
CameraComponent(const CameraComponent&) = default;
};
class NativeScriptableEntity;
struct NativeScriptComponent
{
NativeScriptableEntity* instance = nullptr;
@@ -81,9 +92,6 @@ namespace OpenEngine {
NativeScriptableEntity* (*InstanciateScript)();
void (*DestroyInstanceScript)(NativeScriptComponent*);
void OnImGuiRender(Entity& entity)
{};
template <typename T>
void Bind()
{
@@ -119,30 +127,32 @@ namespace OpenEngine {
struct PhysicsBodyComponent
{
enum class BodyType { Static = 0, Kinematic, Dynamic };
BodyID body;
BodyType type = BodyType::Dynamic;
float linear_damping = 0.05f;
float angular_damping = 0.05f;
float gravity_factor = 1.0f;
float restitution = 0.8f;
float friction = 0.5f;
EActivation initial_activation_state = EActivation::Activate;
int type = (int)EMotionType::Static;
int initial_activation_state = (int)EActivation::Activate;
int layer = (int)Layers::MOVING;
PhysicsBodyComponent() = default;
PhysicsBodyComponent(const PhysicsBodyComponent&) = default;
};
struct PhysicsShapeComponent
// TODO: Let's add more shapes
struct BoxShapeComponent
{
ShapeRefC shape;
float restitution = 0.8f;
float friction = 0.5f;
glm::vec3 size = { 1.0f, 1.0f, 1.0f };
};
struct SphereShapeComponent
{
float radius = 1.0f;
};
}
#endif // COMPONENTS_HPP

4
open_engine/include/open_engine/scene/entity.hpp
View File

@@ -3,6 +3,8 @@
#include "open_engine/core.hpp"
#include "open_engine/core/uuid.hpp"
#include "open_engine/scene/components.hpp"
#include "open_engine/scene/scene.hpp"
#include <cstdint>
@@ -48,6 +50,8 @@ namespace OpenEngine {
return scene->registry.all_of<T>(handle);
};
UUID GetUUID() { return GetComponents<IDComponent>().id; };
operator bool() const { return handle != entt::null; };
operator entt::entity() const { return handle; };
operator uint32_t() const { return (uint32_t)handle; };

1
open_engine/include/open_engine/scene/native_scriptable_entity.hpp
View File

@@ -1,6 +1,7 @@
#ifndef NATIVE_SCRIPTABLE_ENTITY_HPP
#define NATIVE_SCRIPTABLE_ENTITY_HPP
#include "open_engine/scene/native_scriptable_entity.hpp"
#include "open_engine/scene/entity.hpp"
namespace OpenEngine {

5
open_engine/include/open_engine/scene/scene.hpp
View File

@@ -1,6 +1,7 @@
#ifndef SCENE_HPP
#define SCENE_HPP
#include "open_engine/core/uuid.hpp"
#include "open_engine/renderer/editor_camera.hpp"
#include "open_engine/physics.hpp"
@@ -18,11 +19,13 @@ namespace OpenEngine {
public:
Scene() = default;
~Scene() = default;
Scene(Scene& other) {};
void OnRuntimeStart();
void OnRuntimeStop();
Entity CreateEntity(const std::string& name = std::string());
Entity CreateEntityWithUUID(UUID uuid, const std::string& name = std::string());
void DeleteEntity(entt::entity entity);
void MarkEntityForDeletion(Entity entity);
@@ -52,8 +55,6 @@ namespace OpenEngine {
std::vector<entt::entity> pending_deletion;
//BodyID sphere_id;
friend class SceneSerializer;
friend class Entity;
};

24
open_engine/src/open_engine/core/uuid.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include <cstdint>
#include <pch.hpp>
#include <core/uuid.hpp>
#include <random>
namespace OpenEngine {
static std::random_device s_random_device;
static std::mt19937_64 s_engine(s_random_device());
static std::uniform_int_distribution<uint64_t> s_uniform_distribution;
UUID::UUID()
: uuid(s_uniform_distribution(s_engine))
{
}
UUID::UUID(uint64_t uuid)
: uuid(uuid)
{
}
}

10
open_engine/src/open_engine/physics.cpp
View File

@@ -38,7 +38,9 @@ namespace OpenEngine {
tmp_allocator = CreateRef<TempAllocatorImpl>(10 * 1024 * 1024);
job_system = CreateRef<JobSystemThreadPool>(cMaxPhysicsJobs, cMaxPhysicsBarriers, thread::hardware_concurrency() - 1);
job_system = CreateRef<JobSystemThreadPool>(cMaxPhysicsJobs,
cMaxPhysicsBarriers,
thread::hardware_concurrency() - 1);
physics_system.Init(
1024,
@@ -49,10 +51,10 @@ namespace OpenEngine {
object_vs_broadphase_layer_filter,
object_vs_object_layer_filter);
physics_system.SetBodyActivationListener(&body_activation_listener);
physics_system.SetContactListener(&contact_listener);
//physics_system.SetBodyActivationListener(&body_activation_listener);
//physics_system.SetContactListener(&contact_listener);
// TODO: Move out of here and check the comment on Jolt's example
// TODO: Check the comment on Jolt's example
physics_system.OptimizeBroadPhase();
}

4
open_engine/src/open_engine/renderer/renderer3d.cpp
View File

@@ -205,8 +205,10 @@ namespace OpenEngine {
void Renderer3D::Shutdown()
{
renderer_data.camera_uniform_buffer.reset();
renderer_data.color_shader_3d.reset();
renderer_data.camera_uniform_buffer.reset();
renderer_data.transform_uniform_buffer.reset();
renderer_data.material_uniform_buffer.reset();
}
void Renderer3D::BeginScene(const SceneCamera& camera, const glm::mat4& transform)

140
open_engine/src/open_engine/scene/scene.cpp
View File

@@ -1,69 +1,87 @@
#include "logging.hpp"
#include "physics.hpp"
#include "ref_scope.hpp"
#include <Jolt/Physics/Body/MotionType.h>
#include <Jolt/Physics/Collision/ObjectLayer.h>
#include <Jolt/Physics/Collision/Shape/ConvexShape.h>
#include <pch.hpp>
#include <renderer/renderer3d.hpp>
#include <scene/components.hpp>
#include <open_engine/scene/native_scriptable_entity.hpp>
#include <scene/entity.hpp>
#include <scene/scene.hpp>
#include <core/time.hpp>
#include <Jolt/Physics/Collision/Shape/Shape.h>
#include <Jolt/Physics/Collision/Shape/BoxShape.h>
#include <Jolt/Physics/Collision/Shape/SphereShape.h>
#include <Jolt/Physics/EActivation.h>
#include <Jolt/Math/Real.h>
#include <Jolt/Math/Quat.h>
#include <cstdint>
#include <entt/entity/fwd.hpp>
namespace OpenEngine {
static Ref<ShapeSettings> CreateShape(entt::registry& reg, entt::entity e)
{
if (reg.any_of<BoxShapeComponent>(e)) {
auto& c = reg.get<BoxShapeComponent>(e);
return CreateRef<BoxShapeSettings>(ToJolt(c.size * 0.5f));
}
if (reg.any_of<SphereShapeComponent>(e)) {
auto& c = reg.get<SphereShapeComponent>(e);
return CreateRef<SphereShapeSettings>(c.radius);
}
OE_CORE_ERROR("Entity has no shape component!");
return nullptr;
};
void Scene::OnRuntimeStart()
{
body_interface = &physics_engine.GetBodyInterface();
BoxShapeSettings floor_shape_settings(Vec3(100.0f, 1.0f, 100.0f));
floor_shape_settings.SetEmbedded(); // A ref counted object on the stack (base class RefTarget) should be marked as such to prevent it from being freed when its reference count goes to 0.
// Create the shape
ShapeSettings::ShapeResult floor_shape_result = floor_shape_settings.Create();
ShapeRefC floor_shape = floor_shape_result.Get(); // We don't expect an error here, but you can check floor_shape_result for HasError() / GetError()
// Create the settings for the body itself. Note that here you can also set other properties like the restitution / friction.
BodyCreationSettings floor_settings(floor_shape, RVec3(0.0_r, -1.0_r, 0.0_r), Quat::sIdentity(), EMotionType::Static, Layers::NON_MOVING);
// Create the actual rigid body
Body *floor = body_interface->CreateBody(floor_settings); // Note that if we run out of bodies this can return nullptr
// Add it to the world
body_interface->AddBody(floor->GetID(), EActivation::DontActivate);
auto view = registry.view<PhysicsBodyComponent>();
// TODO: Cleanup components aquisition
auto view = registry.view<TransformComponent, PhysicsBodyComponent>();
for (auto e : view) {
Entity entity = { e, this };
TransformComponent* tc;
if (entity.HasComponent<TransformComponent>())
tc = &entity.GetComponents<TransformComponent>();
auto shape_settings = CreateShape(registry, e);
if (!shape_settings)
shape_settings = CreateRef<BoxShapeSettings>(Vec3(0.5f, 0.5f, 0.5f));
auto shape_result = shape_settings->Create();
if (shape_result.HasError()) {
OE_CORE_ERROR("Shape creation failed: {}", shape_result.GetError().c_str());
continue;
}
ShapeRefC shape = shape_result.Get();
auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
auto& tc = entity.GetComponents<TransformComponent>();
PhysicsShapeComponent* psc;
if (entity.HasComponent<PhysicsShapeComponent>())
psc = &entity.GetComponents<PhysicsShapeComponent>();
glm::vec3& pos = tc.translation;
glm::vec3& scale = tc.scale;
glm::vec3& rot = tc.rotation;
glm::vec3& pos = tc->translation;
Quat quat = Quat::sEulerAngles(Vec3(rot.x, rot.y, rot.z));
BodyCreationSettings settings(
new BoxShape(Vec3(0.5f, 0.5f, 0.5f)),
shape,
//new BoxShape(Vec3(scale.x * 0.5, scale.y * 0.5f, scale.z * 0.5f)),
Vec3(pos.x, pos.y, pos.z),
Quat::sIdentity(),
EMotionType::Dynamic,
Layers::MOVING);
quat,
(EMotionType)pbc.type,
pbc.layer);
settings.mLinearDamping = pbc.linear_damping;
settings.mAngularDamping = pbc.angular_damping;
settings.mGravityFactor = pbc.gravity_factor;
settings.mRestitution = pbc.restitution;
settings.mFriction = pbc.friction;
settings.mObjectLayer = (ObjectLayer)pbc.layer;
settings.mRestitution = psc->restitution;
settings.mFriction = psc->friction;
pbc.body = body_interface->CreateAndAddBody(settings, EActivation::Activate);
pbc.body = body_interface->CreateAndAddBody(settings, (EActivation)pbc.initial_activation_state);
}
}
@@ -75,15 +93,21 @@ namespace OpenEngine {
auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
physics_engine.GetBodyInterface().RemoveBody(pbc.body);
physics_engine.GetBodyInterface().DestroyBody(pbc.body);
body_interface->RemoveBody(pbc.body);
body_interface->DestroyBody(pbc.body);
}
}
Entity Scene::CreateEntity(const std::string& name)
{
return CreateEntityWithUUID(UUID(), name);
}
Entity Scene::CreateEntityWithUUID(UUID uuid, const std::string& name)
{
Entity entity = { registry.create(), this };
entity.AddComponent<IDComponent>(uuid);
auto& tag = entity.AddComponent<TagComponent>();
tag.tag = name.empty() ? "Entity" : name;
@@ -150,15 +174,8 @@ namespace OpenEngine {
body_interface->SetPosition(body.body, { pos.x, pos.y, pos.z }, EActivation::Activate);
PhysicsShapeComponent* shape;
if (entity.HasComponent<PhysicsShapeComponent>()) {
shape = &entity.GetComponents<PhysicsShapeComponent>();
body_interface->SetRestitution(body.body, shape->restitution);
body_interface->SetFriction(body.body, shape->friction);
body_interface->SetGravityFactor(body.body, body.gravity_factor);
}
body_interface->SetRestitution(body.body, body.restitution);
body_interface->SetFriction(body.body, body.friction);
}
OnUpdatePhysics();
@@ -169,10 +186,17 @@ namespace OpenEngine {
auto& transform = entity.GetComponents<TransformComponent>();
auto& body = entity.GetComponents<PhysicsBodyComponent>();
auto position = physics_engine.GetBodyInterface().GetPosition(body.body);
auto position = body_interface->GetPosition(body.body);
auto rotation = body_interface->GetRotation(body.body).GetEulerAngles();
transform.translation.x = position.GetX();
transform.translation.y = position.GetY();
transform.translation.z = position.GetZ();
transform.rotation.x = rotation.GetX();
transform.rotation.y = rotation.GetY();
transform.rotation.z = rotation.GetZ();
body_interface->SetGravityFactor(body.body, body.gravity_factor);
}
SceneCamera* main_camera = nullptr;
@@ -194,14 +218,13 @@ namespace OpenEngine {
auto view = registry.view<TransformComponent, MeshComponent>();
for (const auto& entity : view) {
auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(entity);
for (const auto& e : view) {
auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(e);
Entity entity(e, this);
Material material;
Entity _entity(entity, this);
if (_entity.HasComponent<MaterialComponent>())
material = _entity.GetComponents<MaterialComponent>().material;
if (entity.HasComponent<MaterialComponent>())
material = entity.GetComponents<MaterialComponent>().material;
Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
/*
@@ -234,7 +257,8 @@ namespace OpenEngine {
if (_entity.HasComponent<MaterialComponent>())
material = _entity.GetComponents<MaterialComponent>().material;
Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
if (mesh.mesh)
Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
}
Renderer3D::EndScene();
@@ -315,7 +339,17 @@ namespace OpenEngine {
}
template<>
void Scene::OnComponentAdded<PhysicsShapeComponent>(Entity entity, PhysicsShapeComponent& component)
void Scene::OnComponentAdded<SphereShapeComponent>(Entity entity, SphereShapeComponent& component)
{
}
template<>
void Scene::OnComponentAdded<BoxShapeComponent>(Entity entity, BoxShapeComponent& component)
{
}
template<>
void Scene::OnComponentAdded<IDComponent>(Entity entity, IDComponent& component)
{
}
}

87
open_engine/src/open_engine/scene/scene_serializer.cpp
View File

@@ -88,8 +88,10 @@ namespace OpenEngine {
static void SerializeEntity(YAML::Emitter& out, Entity entity)
{
OE_CORE_ASSERT(entity.HasComponent<IDComponent>(), "Entity is missing UUID.");
out << YAML::BeginMap;
out << YAML::Key << "Entity" << YAML::Value << "412741205"; // Needs random
out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID(); // Needs random
if (entity.HasComponent<TagComponent>())
{
@@ -115,8 +117,7 @@ namespace OpenEngine {
out << YAML::EndMap; // TransformComponent
}
if (entity.HasComponent<CameraComponent>())
{
if (entity.HasComponent<CameraComponent>()) {
out << YAML::Key << "CameraComponent";
out << YAML::BeginMap; // CameraComponent
@@ -151,8 +152,7 @@ namespace OpenEngine {
out << YAML::EndMap; // SpriteRendererComponent
}
if (entity.HasComponent<MeshComponent>())
{
if (entity.HasComponent<MeshComponent>()) {
out << YAML::Key << "MeshComponent";
out << YAML::BeginMap; // MeshComponent
@@ -162,8 +162,7 @@ namespace OpenEngine {
out << YAML::EndMap; // MeshComponent
}
if (entity.HasComponent<MaterialComponent>())
{
if (entity.HasComponent<MaterialComponent>()) {
out << YAML::Key << "MaterialComponent";
out << YAML::BeginMap; // MaterialComponent
@@ -177,6 +176,44 @@ namespace OpenEngine {
out << YAML::EndMap; // MaterialComponent
}
if (entity.HasComponent<PhysicsBodyComponent>()) {
out << YAML::Key << "PhysicsBodyComponent";
out << YAML::BeginMap; // PhysicsBodyComponent
auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
out << YAML::Key << "LinearDamping" << YAML::Value << pbc.linear_damping;
out << YAML::Key << "AngularDamping" << YAML::Value << pbc.angular_damping;
out << YAML::Key << "GravityFactor" << YAML::Value << pbc.gravity_factor;
out << YAML::Key << "Restitution" << YAML::Value << pbc.restitution;
out << YAML::Key << "Friction" << YAML::Value << pbc.friction;
out << YAML::Key << "Type" << YAML::Value << pbc.type;
out << YAML::Key << "ActivationState" << YAML::Value << pbc.initial_activation_state;
out << YAML::Key << "Layer" << YAML::Value << pbc.layer;
out << YAML::EndMap; // PhysicsBodyComponent
}
if (entity.HasComponent<BoxShapeComponent>()) {
out << YAML::Key << "BoxShapeComponent";
out << YAML::BeginMap; //BoxShapeComponent
auto& bsc = entity.GetComponents<BoxShapeComponent>();
out << YAML::Key << "Size" << YAML::Value << bsc.size;
out << YAML::EndMap; //BoxShapeComponent
}
if (entity.HasComponent<SphereShapeComponent>()) {
out << YAML::Key << "SphereShapeComponent";
out << YAML::BeginMap; //SphereShapeComponent
auto& ssc = entity.GetComponents<SphereShapeComponent>();
out << YAML::Key << "Radius" << YAML::Value << ssc.radius;
out << YAML::EndMap; //SphereShapeComponent
}
out << YAML::EndMap;
}
@@ -223,7 +260,7 @@ namespace OpenEngine {
{
for (auto entity : entities)
{
uint64_t uuid = entity["Entity"].as<uint64_t>(); // TODO
uint64_t uuid = entity["Entity"].as<uint64_t>();
std::string name;
auto tagComponent = entity["TagComponent"];
@@ -232,7 +269,7 @@ namespace OpenEngine {
OE_CORE_TRACE("Deserialized entity with ID = {0}, name = {1}", uuid, name);
Entity deserializedEntity = context->CreateEntity(name);
Entity deserializedEntity = context->CreateEntityWithUUID(uuid, name);
auto transformComponent = entity["TransformComponent"];
if (transformComponent)
@@ -292,8 +329,7 @@ namespace OpenEngine {
}
auto material_component = entity["MaterialComponent"];
if (material_component)
{
if (material_component) {
auto& material = deserializedEntity.AddComponent<MaterialComponent>();
material.material.albedo = material_component["Albedo"].as<glm::vec4>();
material.material.roughness = material_component["Roughness"].as<float>();
@@ -301,6 +337,35 @@ namespace OpenEngine {
material.material.ambient_strength = material_component["AmbiantStrength"].as<float>();
material.material.specular_strength = material_component["SpecularStrength"].as<float>();
}
auto physics_body_component = entity["PhysicsBodyComponent"];
if (physics_body_component) {
auto& pbc = deserializedEntity.AddComponent<PhysicsBodyComponent>();
pbc.linear_damping = physics_body_component["LinearDamping"].as<float>();
pbc.angular_damping = physics_body_component["AngularDamping"].as<float>();
pbc.gravity_factor = physics_body_component["GravityFactor"].as<float>();
pbc.restitution = physics_body_component["Restitution"].as<float>();
pbc.friction = physics_body_component["Friction"].as<float>();
pbc.type = physics_body_component["Type"].as<int>();
pbc.initial_activation_state = physics_body_component["ActivationState"].as<int>();
pbc.layer = physics_body_component["Layer"].as<int>();
}
auto box_shape_component = entity["BoxShapeComponent"];
if (box_shape_component) {
auto& bsc = deserializedEntity.AddComponent<BoxShapeComponent>();
bsc.size = box_shape_component["Size"].as<glm::vec3>();
}
auto sphere_shape_component = entity["SphereShapeComponent"];
if (sphere_shape_component) {
auto& ssc = deserializedEntity.AddComponent<SphereShapeComponent>();
ssc.radius = sphere_shape_component["Radius"].as<float>();
}
}
}