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

improved model loading and added model component

Browse Source
This commit is contained in:
Erris
2026-03-09 16:37:30 +01:00
parent ac18bb6f00
commit a0c900166f
15 changed files with 486 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
open_engine/include/open_engine/gltf/gltf_model3d.hpp Normal file
View File

@@ -0,0 +1,38 @@
#ifndef GLTF_MODEL3D_HPP
#define GLTF_MODEL3D_HPP
#include "open_engine/renderer/model3d.hpp"
#include <fastgltf/types.hpp>
#include <vector>
#include <cstddef>
namespace OpenEngine {
class GLTFModel3D : public Model3D
{
public:
GLTFModel3D(const char* path);
void loadPrimitive(fastgltf::Asset& asset,
fastgltf::Primitive& primitive,
Mesh& out);
virtual const Mesh& GetMesh(int index) const override;
virtual const std::vector<Mesh>& GetMeshes() const override;
virtual size_t GetMeshCount() const override { return meshes.size(); };
virtual std::vector<Mesh>::iterator begin() override { return meshes.begin(); };
virtual std::vector<Mesh>::iterator end() override { return meshes.end(); };
virtual std::vector<Mesh>::const_iterator begin() const override { return meshes.cbegin(); };
virtual std::vector<Mesh>::const_iterator end() const override { return meshes.end(); };
private:
std::string name;
std::vector<Mesh> meshes;
};
}
#endif // GLTF_MODEL3D_HPP

69
open_engine/include/open_engine/renderer/model3d.hpp Normal file
View File

@@ -0,0 +1,69 @@
#ifndef MODEL3D_HPP
#define MODEL3D_HPP
#include "open_engine/core/uuid.hpp"
#include "open_engine/renderer/vertex_array.hpp"
#include <cstddef>
#include <cstdint>
#include <glm/glm.hpp>
#include <vector>
namespace OpenEngine {
struct Material
{
glm::vec4 albedo = { 1.0f, 0.0f, 0.8f, 1.0f };
float roughness = 1.0f;
float metallic = 1.0f;
float ambient_strength = 1.0f;
float specular_strength = 1.0f;
std::string name = "un-named material";
};
struct MeshVertex
{
glm::vec3 position;
glm::vec3 normal;
glm::vec2 text_coords;
};
struct Mesh
{
UUID uuid;
Material material;
Ref<VertexArray> vertex_array;
Ref<VertexBuffer> vertex_buffer;
Ref<IndexBuffer> index_buffer;
// TODO: Make them a ptr or something
std::vector<MeshVertex> vertices;
std::vector<uint32_t> indices;
};
// TODO: Model3D.Instanciate();
// Or Model3D.GetVertices() {return iterateaccessorwithindex bla bla bla}
// What data should Model3D hold in the end if it is not a renderable object?
class Model3D
{
public:
virtual ~Model3D() = default;
static Ref<Model3D> Create(const char* path);
virtual const Mesh& GetMesh(int index) const = 0;
virtual const std::vector<Mesh>& GetMeshes() const = 0;
virtual size_t GetMeshCount() const = 0;
virtual std::vector<Mesh>::iterator begin() = 0;
virtual std::vector<Mesh>::iterator end() = 0;
virtual std::vector<Mesh>::const_iterator begin() const = 0;
virtual std::vector<Mesh>::const_iterator end() const = 0;
};
}
#endif // MODEL3D_HPP

43
open_engine/include/open_engine/renderer/renderer3d.hpp
View File

@@ -2,9 +2,8 @@
#define RENDERER3D_HPP
#include "open_engine/renderer/editor_camera.hpp"
#include "open_engine/renderer/vertex_array.hpp"
#include "open_engine/renderer/buffer.hpp"
#include "open_engine/scene/scene_camera.hpp"
#include "open_engine/renderer/model3d.hpp"
#include <cstdint>
namespace OpenEngine {
@@ -18,40 +17,12 @@ namespace OpenEngine {
Cube
};
struct MeshVertex
{
glm::vec3 position;
glm::vec4 color;
glm::vec3 normal;
glm::vec2 text_coords;
uint32_t id = -1;
};
struct Material
{
glm::vec4 albedo = { 1.0f, 1.0f, 1.0f, 1.0f };
float roughness = 1.0f;
float metallic = 1.0f;
float ambient_strength = 1.0f;
float specular_strength = 1.0f;
};
struct Mesh
{
Ref<VertexArray> vertex_array;
Ref<VertexBuffer> vertex_buffer;
Ref<IndexBuffer> index_buffer;
// TODO: Make them a ptr or something
std::vector<MeshVertex> vertices;
std::vector<uint32_t> indices;
};
Ref<Mesh> CreateMesh(const std::vector<MeshVertex>& vertices,
const std::vector<uint32_t>& indices,
uint32_t id);
const std::vector<uint32_t>& indices);
void PopulateMesh(Mesh& mesh);
Ref<Mesh> CreateCube(uint32_t id = -1);
Ref<Mesh> CreateQuad(uint32_t id = -1, bool back_face = false);
// ==================================================
class Renderer3D
@@ -66,6 +37,12 @@ namespace OpenEngine {
static void DrawMesh(const Ref<Mesh>& mesh, Material& material,
const glm::mat4& transform);
static void DrawMesh(const Ref<Mesh>& mesh, Material& material,
const glm::mat4& transform,
uint32_t entity_id);
static void DrawModel(const Ref<Model3D>& model,
const glm::mat4& transform,
uint32_t entity_id);
};
}

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

@@ -7,6 +7,8 @@
#include "open_engine/renderer/renderer3d.hpp"
#include "open_engine/physics.hpp"
#include "open_engine/core/uuid.hpp"
#include "open_engine/ref_scope.hpp"
#include "open_engine/renderer/model3d.hpp"
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Body/BodyInterface.h>
@@ -147,16 +149,36 @@ namespace OpenEngine {
struct BoxShapeComponent
{
glm::vec3 size = { 1.0f, 1.0f, 1.0f };
BoxShapeComponent() = default;
BoxShapeComponent(const BoxShapeComponent&) = default;
};
struct SphereShapeComponent
{
float radius = 1.0f;
SphereShapeComponent() = default;
SphereShapeComponent(const SphereShapeComponent&) = default;
};
struct PlaneShapeComponent
{
float extent = 1.0f;
PlaneShapeComponent() = default;
PlaneShapeComponent(const PlaneShapeComponent&) = default;
};
struct ModelComponent
{
Ref<Model3D> model;
ModelComponent() = default;
ModelComponent(const ModelComponent&) = default;
ModelComponent(Ref<Model3D>& model)
: model(model)
{}
};
}

3
open_engine/src/open_engine/fastgltf.cpp
View File

@@ -3,7 +3,6 @@
#include "logging.hpp"
#include <fastgltf.hpp>
#include "ref_scope.hpp"
#include "renderer/renderer3d.hpp"
#include <cstddef>
#include <cstdint>
@@ -58,8 +57,6 @@ namespace OpenEngine {
auto& pbr = material.pbrData;
auto& c = pbr.baseColorFactor;
for (auto& vert : out.vertices)
vert.color = glm::vec4(c[0], c[1], c[2], c[3]);
}
}
}

137
open_engine/src/open_engine/gltf/gltf_model3d.cpp Normal file
View File

@@ -0,0 +1,137 @@
#include "logging.hpp"
#include <pch.hpp>
#include <gltf/gltf_model3d.hpp>
#include <fastgltf/core.hpp>
#include <fastgltf/types.hpp>
#include <fastgltf/tools.hpp>
#include <fastgltf/glm_element_traits.hpp>
namespace OpenEngine {
void PopulateMesh(Mesh& mesh)
{
mesh.vertex_array = VertexArray::Create();
mesh.vertex_buffer = VertexBuffer::Create(mesh.vertices.size() * sizeof(MeshVertex));
mesh.vertex_buffer->SetData(mesh.vertices.data(), mesh.vertices.size() * sizeof(MeshVertex));
BufferLayout layout = {
{ ShaderDataType::Float3, "a_Position" },
{ ShaderDataType::Float3, "a_Normal" },
{ ShaderDataType::Float2, "a_TexCoord" }
};
mesh.vertex_buffer->SetLayout(layout);
mesh.vertex_array->AddVertexBuffer(mesh.vertex_buffer);
mesh.index_buffer = IndexBuffer::Create(mesh.indices.data(), mesh.indices.size());
mesh.vertex_array->SetIndexBuffer(mesh.index_buffer);
}
Ref<Mesh> CreateMesh(const std::vector<MeshVertex>& vertices,
const std::vector<uint32_t>& indices)
{
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->vertices = vertices;
mesh->indices = indices;
PopulateMesh(*mesh);
return mesh;
}
void GLTFModel3D::loadPrimitive(fastgltf::Asset& asset,
fastgltf::Primitive& primitive,
Mesh& out)
{
if (primitive.indicesAccessor.has_value()) {
auto& accessor = asset.accessors[primitive.indicesAccessor.value()];
out.indices.resize(accessor.count);
fastgltf::iterateAccessorWithIndex<uint32_t>(asset, accessor,
[&](uint32_t index, size_t i) {
out.indices[i] = index;
});
}
{
auto* position_iterator = primitive.findAttribute("POSITION");
auto& accessor = asset.accessors[position_iterator->accessorIndex];
out.vertices.resize(accessor.count);
fastgltf::iterateAccessorWithIndex<glm::vec3>(asset, accessor,
[&](glm::vec3 pos, size_t i) {
out.vertices[i].position = pos;
});
}
if (auto* normal_iterator = primitive.findAttribute("NORMAL");
normal_iterator != primitive.attributes.end()) {
auto& accessor = asset.accessors[normal_iterator->accessorIndex];
fastgltf::iterateAccessorWithIndex<glm::vec3>(asset, accessor,
[&](glm::vec3 norm, size_t i) {
out.vertices[i].normal = norm;
});
}
{
if (primitive.materialIndex.has_value()) {
auto& material = asset.materials[primitive.materialIndex.value()];
auto& pbr = material.pbrData;
auto& color = pbr.baseColorFactor;
auto& roughness = pbr.roughnessFactor;
auto& metallic = pbr.metallicFactor;
out.material.name = material.name;
out.material.albedo = glm::vec4(color[0], color[1], color[2], color[3]);
out.material.roughness = roughness;
out.material.metallic = metallic;
}
}
}
GLTFModel3D::GLTFModel3D(const char* path)
{
fastgltf::Parser parser;
auto data = fastgltf::GltfDataBuffer::FromPath(path);
if (data.error() != fastgltf::Error::None)
OE_CORE_ERROR("Could not parse model");
auto asset = parser.loadGltfBinary(data.get(), ".",
fastgltf::Options::LoadExternalBuffers
);
if (asset.error() != fastgltf::Error::None)
OE_CORE_ERROR("Could not optain asset");
for (auto& mesh : asset->meshes) {
name = mesh.name;
for (auto& primitive : mesh.primitives) {
Mesh prim_mesh;
loadPrimitive(asset.get(), primitive, prim_mesh);
PopulateMesh(prim_mesh);
meshes.emplace_back(prim_mesh);
}
}
};
const Mesh& GLTFModel3D::GetMesh(int index) const
{
return meshes[index];
}
const std::vector<Mesh>& GLTFModel3D::GetMeshes() const
{
return meshes;
}
}

19
open_engine/src/open_engine/renderer/model3d.cpp Normal file
View File

@@ -0,0 +1,19 @@
#include <pch.hpp>
#include <renderer/model3d.hpp>
#include <gltf/gltf_model3d.hpp>
#include <instrumentor.hpp>
#include <ref_scope.hpp>
namespace OpenEngine {
Ref<Model3D> Model3D::Create(const char* path)
{
OE_PROFILE_FUNCTION();
return CreateRef<GLTFModel3D>(path);
}
}

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

@@ -23,39 +23,6 @@
namespace OpenEngine {
// SHOULD BE MOVED ==================================
Ref<Mesh> CreateMesh(const std::vector<MeshVertex>& vertices,
const std::vector<uint32_t>& indices,
uint32_t id)
{
Ref<Mesh> mesh = CreateRef<Mesh>();
std::vector<MeshVertex> verts = vertices;
for (auto& vertex : verts)
vertex.id = id;
mesh->vertices = verts;
mesh->indices = indices;
mesh->vertex_array = VertexArray::Create();
mesh->vertex_buffer = VertexBuffer::Create(vertices.size() * sizeof(MeshVertex));
mesh->vertex_buffer->SetData(mesh->vertices.data(), vertices.size() * sizeof(MeshVertex));
BufferLayout layout = {
{ ShaderDataType::Float3, "a_Position" },
{ ShaderDataType::Float4, "a_Color" },
{ ShaderDataType::Float3, "a_Normal" },
{ ShaderDataType::Float2, "a_TexCoord" },
{ ShaderDataType::Int, "a_EntityID"}
};
mesh->vertex_buffer->SetLayout(layout);
mesh->vertex_array->AddVertexBuffer(mesh->vertex_buffer);
mesh->index_buffer = IndexBuffer::Create(indices.data(), indices.size());
mesh->vertex_array->SetIndexBuffer(mesh->index_buffer);
return mesh;
}
Ref<Mesh> CreateQuad(uint32_t id, bool back_face)
{
@@ -67,16 +34,16 @@ namespace OpenEngine {
if (back_face) {
vertices = {
// Front face (normal 0, 0, 1)
{{-0.5f, -0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,0}, id},
{{-0.5f, 0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,1}, id},
{{ 0.5f, 0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,1}, id},
{{ 0.5f, -0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,0}, id},
{{-0.5f, -0.5f, 0.0f}, {0,0,1}, {0,0}},
{{-0.5f, 0.5f, 0.0f}, {0,0,1}, {0,1}},
{{ 0.5f, 0.5f, 0.0f}, {0,0,1}, {1,1}},
{{ 0.5f, -0.5f, 0.0f}, {0,0,1}, {1,0}},
// Back face (normal 0, 0, -1)
{{-0.5f, -0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,0}, id},
{{-0.5f, 0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,1}, id},
{{ 0.5f, 0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,1}, id},
{{ 0.5f, -0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,0}, id}
{{-0.5f, -0.5f, -0.0f}, {0,0,-1}, {0,0}},
{{-0.5f, 0.5f, -0.0f}, {0,0,-1}, {0,1}},
{{ 0.5f, 0.5f, -0.0f}, {0,0,-1}, {1,1}},
{{ 0.5f, -0.5f, -0.0f}, {0,0,-1}, {1,0}}
};
indices = {
@@ -88,10 +55,10 @@ namespace OpenEngine {
} else {
vertices = {
// Front face (normal 0, 0, 1)
{{-0.5f, -0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,0}, id},
{{-0.5f, 0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,1}, id},
{{ 0.5f, 0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,1}, id},
{{ 0.5f, -0.5f, 0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,0}, id}
{{-0.5f, -0.5f, 0.0f}, {0,0,1}, {0,0}},
{{-0.5f, 0.5f, 0.0f}, {0,0,1}, {0,1}},
{{ 0.5f, 0.5f, 0.0f}, {0,0,1}, {1,1}},
{{ 0.5f, -0.5f, 0.0f}, {0,0,1}, {1,0}}
};
indices = {
@@ -100,7 +67,7 @@ namespace OpenEngine {
};
}
return CreateMesh(vertices, indices, id);
return CreateMesh(vertices, indices);
}
Ref<Mesh> CreateCube(uint32_t id)
@@ -109,40 +76,40 @@ namespace OpenEngine {
OE_CORE_DEBUG("Creating cube with id {}.", id);
std::vector<MeshVertex> vertices = {
// Front face (normal 0, 0, 1)
{{-0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,0}, id},
{{-0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,1}, id},
{{ 0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,1}, id},
{{ 0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,0}, id},
{{-0.5f, -0.5f, 0.5f}, {0,0,1}, {0,0}},
{{-0.5f, 0.5f, 0.5f}, {0,0,1}, {0,1}},
{{ 0.5f, 0.5f, 0.5f}, {0,0,1}, {1,1}},
{{ 0.5f, -0.5f, 0.5f}, {0,0,1}, {1,0}},
// Back face (normal 0, 0, -1)
{{-0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,0}, id},
{{-0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,1}, id},
{{ 0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,1}, id},
{{ 0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,0}, id},
{{-0.5f, -0.5f, -0.5f}, {0,0,-1}, {0,0}},
{{-0.5f, 0.5f, -0.5f}, {0,0,-1}, {0,1}},
{{ 0.5f, 0.5f, -0.5f}, {0,0,-1}, {1,1}},
{{ 0.5f, -0.5f, -0.5f}, {0,0,-1}, {1,0}},
// Left face (normal -1, 0, 0)
{{-0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {0,0}, id},
{{-0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {0,1}, id},
{{-0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {1,1}, id},
{{-0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {1,0}, id},
{{-0.5f, -0.5f, -0.5f}, {-1,0,0}, {0,0}},
{{-0.5f, 0.5f, -0.5f}, {-1,0,0}, {0,1}},
{{-0.5f, 0.5f, 0.5f}, {-1,0,0}, {1,1}},
{{-0.5f, -0.5f, 0.5f}, {-1,0,0}, {1,0}},
// Right face (normal 1, 0, 0)
{{ 0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {0,0}, id},
{{ 0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {0,1}, id},
{{ 0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {1,1}, id},
{{ 0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {1,0}, id},
{{ 0.5f, -0.5f, -0.5f}, {1,0,0}, {0,0}},
{{ 0.5f, 0.5f, -0.5f}, {1,0,0}, {0,1}},
{{ 0.5f, 0.5f, 0.5f}, {1,0,0}, {1,1}},
{{ 0.5f, -0.5f, 0.5f}, {1,0,0}, {1,0}},
// Top face (normal 0, 1, 0)
{{-0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {0,0}, id},
{{-0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {0,1}, id},
{{ 0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {1,1}, id},
{{ 0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {1,0}, id},
{{-0.5f, 0.5f, -0.5f}, {0,1,0}, {0,0}},
{{-0.5f, 0.5f, 0.5f}, {0,1,0}, {0,1}},
{{ 0.5f, 0.5f, 0.5f}, {0,1,0}, {1,1}},
{{ 0.5f, 0.5f, -0.5f}, {0,1,0}, {1,0}},
// Bottom face (normal 0, -1, 0)
{{-0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {0,0}, id},
{{-0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {0,1}, id},
{{ 0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {1,1}, id},
{{ 0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {1,0}, id},
{{-0.5f, -0.5f, -0.5f}, {0,-1,0}, {0,0}},
{{-0.5f, -0.5f, 0.5f}, {0,-1,0}, {0,1}},
{{ 0.5f, -0.5f, 0.5f}, {0,-1,0}, {1,1}},
{{ 0.5f, -0.5f, -0.5f}, {0,-1,0}, {1,0}},
};
std::vector<uint32_t> indices = {
@@ -160,7 +127,7 @@ namespace OpenEngine {
20, 22, 21, 20, 23, 22
};
return CreateMesh(vertices, indices, id);
return CreateMesh(vertices, indices);
}
// ==================================================
@@ -185,6 +152,8 @@ namespace OpenEngine {
Material material_buffer;
Ref<UniformBuffer> material_uniform_buffer;
Ref<UniformBuffer> id_uniform_buffer;
};
static Renderer3DData renderer_data;
@@ -200,6 +169,7 @@ namespace OpenEngine {
renderer_data.camera_uniform_buffer = UniformBuffer::Create(sizeof(Renderer3DData::CameraData), 0);
renderer_data.transform_uniform_buffer = UniformBuffer::Create(sizeof(Renderer3DData::TransformData), 1);
renderer_data.material_uniform_buffer = UniformBuffer::Create(sizeof(Material), 2);
renderer_data.id_uniform_buffer = UniformBuffer::Create(sizeof(uint32_t), 3);
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -215,6 +185,7 @@ namespace OpenEngine {
renderer_data.camera_uniform_buffer.reset();
renderer_data.transform_uniform_buffer.reset();
renderer_data.material_uniform_buffer.reset();
renderer_data.id_uniform_buffer.reset();
}
void Renderer3D::BeginScene(const SceneCamera& camera, const glm::mat4& transform)
@@ -259,4 +230,48 @@ namespace OpenEngine {
RenderCommand::DrawIndexed(mesh->vertex_array, mesh->indices.size());
}
void Renderer3D::DrawMesh(const Ref<Mesh>& mesh, Material& material,
const glm::mat4& transform,
uint32_t entity_id)
{
OE_PROFILE_FUNCTION();
renderer_data.color_shader_3d->Bind();
renderer_data.transform_buffer.transform = transform;
renderer_data.transform_uniform_buffer->SetData(&renderer_data.transform_buffer, sizeof(Renderer3DData::TransformData));
renderer_data.material_buffer = material;
renderer_data.material_uniform_buffer->SetData(&renderer_data.material_buffer, sizeof(Material));
renderer_data.id_uniform_buffer->SetData(&entity_id, sizeof(uint32_t));
mesh->vertex_array->Bind();
RenderCommand::DrawIndexed(mesh->vertex_array, mesh->indices.size());
}
void Renderer3D::DrawModel(const Ref<Model3D>& model,
const glm::mat4& transform,
uint32_t entity_id)
{
OE_PROFILE_FUNCTION();
renderer_data.color_shader_3d->Bind();
renderer_data.transform_buffer.transform = transform;
renderer_data.transform_uniform_buffer->SetData(&renderer_data.transform_buffer, sizeof(Renderer3DData::TransformData));
for (auto& mesh : *model) {
renderer_data.material_buffer = mesh.material;
renderer_data.material_uniform_buffer->SetData(&renderer_data.material_buffer, sizeof(Material));
renderer_data.id_uniform_buffer->SetData(&entity_id, sizeof(uint32_t));
mesh.vertex_array->Bind();
RenderCommand::DrawIndexed(mesh.vertex_array, mesh.indices.size());
}
}
}

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

@@ -1,6 +1,7 @@
#include "logging.hpp"
#include "physics.hpp"
#include "ref_scope.hpp"
#include "renderer/model3d.hpp"
#include <Jolt/Physics/Body/MotionType.h>
#include <Jolt/Physics/Collision/ObjectLayer.h>
#include <Jolt/Physics/Collision/Shape/ConvexShape.h>
@@ -264,7 +265,17 @@ namespace OpenEngine {
material = _entity.GetComponents<MaterialComponent>().material;
if (mesh.mesh)
Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform), (uint32_t)_entity);
}
auto model_view = registry.view<TransformComponent, ModelComponent>();
for (const auto& entity : model_view) {
auto [transform, model_comp] = model_view.get<TransformComponent, ModelComponent>(entity);
Entity _entity(entity, this);
Renderer3D::DrawModel(model_comp.model, GetTransformFromComp(transform), (uint32_t)_entity);
}
Renderer3D::EndScene();
@@ -363,4 +374,9 @@ namespace OpenEngine {
void Scene::OnComponentAdded<PlaneShapeComponent>(Entity entity, PlaneShapeComponent& component)
{
}
template<>
void Scene::OnComponentAdded<ModelComponent>(Entity entity, ModelComponent& component)
{
}
}