bailwillharr/engine
1
0
Fork 0
mirror of https://github.com/bailwillharr/engine.git synced 2024-09-21 04:51:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make index buffers use 32 bit ints

Browse Source
This commit is contained in:
Bailey Harrison 2022-10-24 09:34:09 +01:00
parent 6542b7039b
commit e811349e5b
7 changed files with 38 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/components/text_ui_renderer.hpp
View File

@ -6,6 +6,7 @@
#include "resources/font.hpp" #include "resources/font.hpp"
#include "resources/mesh.hpp" #include "resources/mesh.hpp"
#include "resources/shader.hpp"
#include <glm/mat4x4.hpp> #include <glm/mat4x4.hpp>

32
include/resources/mesh.hpp
View File

@ -4,9 +4,7 @@
#include "resource.hpp" #include "resource.hpp"
#include "resources/shader.hpp" #include "gfx.hpp"
#include <glad/glad.h>
#include <glm/vec3.hpp> #include <glm/vec3.hpp>
#include <glm/vec2.hpp> #include <glm/vec2.hpp>
@ -20,34 +18,30 @@ struct Vertex {
glm::vec2 uv; glm::vec2 uv;
}; };
namespace engine {
class GFXDevice;
}
namespace engine::resources { namespace engine::resources {
class ENGINE_API Mesh : public Resource { class ENGINE_API Mesh : public Resource {
public: public:
Mesh(const std::vector<Vertex>& vertices); Mesh(GFXDevice* gfx, const std::vector<Vertex>& vertices);
Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices); Mesh(GFXDevice* gfx, const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices);
Mesh(const std::filesystem::path& resPath); Mesh(GFXDevice* gfx, const std::filesystem::path& resPath);
~Mesh() override; ~Mesh() override;
void drawMesh(const Shader& shader); void drawMesh(const gfx::Pipeline* pipeline);
static void invalidate()
{
s_active_vao = -1;
}
std::vector<Vertex> m_vertices; std::vector<Vertex> m_vertices;
std::vector<unsigned int> m_indices; std::vector<uint32_t> m_indices;
private: private:
static int s_active_vao; const gfx::Buffer* vb;
const gfx::Buffer* ib;
GLuint m_vao; GFXDevice* gfx;
GLuint m_vbo;
GLuint m_ebo;
void bindVAO() const;
void initMesh(); void initMesh();

6
src/components/mesh_renderer.cpp
View File

@ -33,13 +33,13 @@ void Renderer::render(glm::mat4 transform)
m_shader->setUniform_v3("baseColor", m_color ); m_shader->setUniform_v3("baseColor", m_color );
m_shader->setUniform_v3("emission", m_emission ); m_shader->setUniform_v3("emission", m_emission );
if (m_mesh) // if (m_mesh)
m_mesh->drawMesh(*m_shader); // m_mesh->drawMesh(*m_shader);
} }
void Renderer::setMesh(const std::string& name) void Renderer::setMesh(const std::string& name)
{ {
m_mesh = parent.res.get<resources::Mesh>(name); // m_mesh = parent.res.get<resources::Mesh>(name);
} }
void Renderer::setTexture(const std::string& name) void Renderer::setTexture(const std::string& name)

5
src/components/text_ui_renderer.cpp
View File

@ -57,6 +57,7 @@ void UI::render(glm::mat4 transform)
float w = glyph.size.x * scale; float w = glyph.size.x * scale;
float h = glyph.size.y * scale; float h = glyph.size.y * scale;
/*
resources::Mesh mesh({ resources::Mesh mesh({
{{xpos, ypos + h, 0.0f}, {}, {0.0f, 0.0f}}, {{xpos, ypos + h, 0.0f}, {}, {0.0f, 0.0f}},
{{xpos, ypos , 0.0f}, {}, {0.0f, 1.0f}}, {{xpos, ypos , 0.0f}, {}, {0.0f, 1.0f}},
@ -64,11 +65,11 @@ void UI::render(glm::mat4 transform)
{{xpos, ypos + h, 0.0f}, {}, {0.0f, 0.0f}}, {{xpos, ypos + h, 0.0f}, {}, {0.0f, 0.0f}},
{{xpos + w, ypos, 0.0f}, {}, {1.0f, 1.0f}}, {{xpos + w, ypos, 0.0f}, {}, {1.0f, 1.0f}},
{{xpos + w, ypos + h, 0.0f}, {}, {1.0f, 0.0f}}, {{xpos + w, ypos + h, 0.0f}, {}, {1.0f, 0.0f}},
}); });*/
glBindTexture(GL_TEXTURE_2D, glyph.textureID); glBindTexture(GL_TEXTURE_2D, glyph.textureID);
mesh.drawMesh(*m_shader); // mesh.drawMesh(*m_shader);
x += (glyph.advance >> 6) * scale; x += (glyph.advance >> 6) * scale;

4
src/engine.cpp
View File

@ -37,10 +37,10 @@ namespace engine {
{ {-0.5f, 0.5f}, {0.0f, 1.0f, 1.0f} }, { {-0.5f, 0.5f}, {0.0f, 1.0f, 1.0f} },
}; };
vb = m_gfx->createBuffer(gfx::BufferType::VERTEX, sizeof(Vertex) * vertices.size(), vertices.data()); vb = m_gfx->createBuffer(gfx::BufferType::VERTEX, sizeof(Vertex) * vertices.size(), vertices.data());
const std::vector<uint16_t> indices = { const std::vector<uint32_t> indices = {
0, 1, 2, 2, 1, 3, 0, 1, 2, 2, 1, 3,
}; };
ib = m_gfx->createBuffer(gfx::BufferType::INDEX, sizeof(uint16_t) * indices.size(), indices.data()); ib = m_gfx->createBuffer(gfx::BufferType::INDEX, sizeof(uint32_t) * indices.size(), indices.data());
} }

2
src/gfx_device_vulkan.cpp
View File

@ -1134,7 +1134,7 @@ namespace engine {
// do a simple draw call // do a simple draw call
vkCmdDraw(pimpl->commandBuffer, call.count, 1, 0, 0); vkCmdDraw(pimpl->commandBuffer, call.count, 1, 0, 0);
} else { } else {
vkCmdBindIndexBuffer(pimpl->commandBuffer, call.indexBuffer->buffer, 0, VK_INDEX_TYPE_UINT16); vkCmdBindIndexBuffer(pimpl->commandBuffer, call.indexBuffer->buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(pimpl->commandBuffer, call.count, 1, 0, 0, 0); vkCmdDrawIndexed(pimpl->commandBuffer, call.count, 1, 0, 0, 0);
} }
queue.pop(); queue.pop();

71
src/resources/mesh.cpp
View File

@ -1,5 +1,7 @@
#include "resources/mesh.hpp" #include "resources/mesh.hpp"
#include "gfx_device.hpp"
namespace engine::resources { namespace engine::resources {
struct MeshFileHeader { struct MeshFileHeader {
@ -8,7 +10,7 @@ struct MeshFileHeader {
int material; int material;
}; };
static void loadMeshFromFile(const std::filesystem::path& path, std::vector<Vertex>* vertices, std::vector<unsigned int>* indices) static void loadMeshFromFile(const std::filesystem::path& path, std::vector<Vertex>* vertices, std::vector<uint32_t>* indices)
{ {
// TODO // TODO
@ -26,73 +28,34 @@ static void loadMeshFromFile(const std::filesystem::path& path, std::vector<Vert
indices->resize(header.index_count); indices->resize(header.index_count);
vertices->resize(header.vertex_count); vertices->resize(header.vertex_count);
fread(&(*indices)[0], sizeof(unsigned int) * header.index_count, 1, fp); fread(indices->data(), sizeof(unsigned int) * header.index_count, 1, fp);
fread(&((*vertices)[0].pos[0]), sizeof(float) * 8 * header.vertex_count, 1, fp); fread(vertices->data(), sizeof(float) * 8 * header.vertex_count, 1, fp);
fclose(fp); fclose(fp);
} }
static void loadObjFromFile(const std::filesystem::path& path, std::vector<Vertex>* vertices, std::vector<unsigned int>* indices)
{
}
// -1 means invalidated
int Mesh::s_active_vao = -1;
void Mesh::bindVAO() const
{
if (s_active_vao != m_vao) {
glBindVertexArray(m_vao);
s_active_vao = m_vao;
}
}
void Mesh::initMesh() void Mesh::initMesh()
{ {
glGenVertexArrays(1, &m_vao); vb = gfx->createBuffer(gfx::BufferType::VERTEX, m_vertices.size() * sizeof(Vertex), m_vertices.data());
bindVAO(); ib = gfx->createBuffer(gfx::BufferType::INDEX, m_indices.size() * sizeof(uint32_t), m_indices.data());
glGenBuffers(1, &m_vbo);
glGenBuffers(1, &m_ebo);
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
glBufferData(GL_ARRAY_BUFFER, m_vertices.size()*sizeof(Vertex), &m_vertices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices.size() * sizeof(unsigned int), &(m_indices[0]), GL_STATIC_DRAW);
// position
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)offsetof(Vertex, pos));
// normal
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)offsetof(Vertex, norm));
// uv
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)offsetof(Vertex, uv));
} }
void Mesh::drawMesh(const Shader& shader) void Mesh::drawMesh(const gfx::Pipeline* pipeline)
{ {
bindVAO(); gfx->drawIndexed(pipeline, vb, ib, m_indices.size());
shader.makeActive();
#ifndef SDLTEST_NOGFX
glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(m_indices.size()), GL_UNSIGNED_INT, 0);
#endif
} }
Mesh::Mesh(const std::vector<Vertex>& vertices) : Resource("", "mesh") Mesh::Mesh(GFXDevice* gfx, const std::vector<Vertex>& vertices) : Resource("", "mesh"), gfx(gfx)
{ {
// constructor for custom meshes without an index array // constructor for custom meshes without an index array
m_vertices = vertices; // COPY over vertices m_vertices = vertices; // COPY over vertices
for (int i = 0; i < m_vertices.size(); i++) { for (uint32_t i = 0; i < m_vertices.size(); i++) {
m_indices.push_back(i); m_indices.push_back(i);
} }
initMesh(); initMesh();
} }
Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices) : Resource("", "mesh") Mesh::Mesh(GFXDevice* gfx, const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices) : Resource("", "mesh"), gfx(gfx)
{ {
m_vertices = vertices; // COPY over vertices m_vertices = vertices; // COPY over vertices
m_indices = indices; // COPY over indices; m_indices = indices; // COPY over indices;
@ -100,7 +63,7 @@ Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>&
} }
// To be used with the resource manager // To be used with the resource manager
Mesh::Mesh(const std::filesystem::path& resPath) : Resource(resPath, "mesh") Mesh::Mesh(GFXDevice* gfx, const std::filesystem::path& resPath) : Resource(resPath, "mesh"), gfx(gfx)
{ {
loadMeshFromFile(resPath, &m_vertices, &m_indices); loadMeshFromFile(resPath, &m_vertices, &m_indices);
initMesh(); initMesh();
@ -108,12 +71,8 @@ Mesh::Mesh(const std::filesystem::path& resPath) : Resource(resPath, "mesh")
Mesh::~Mesh() Mesh::~Mesh()
{ {
glDeleteVertexArrays(1, &m_vao); gfx->destroyBuffer(ib);
glDeleteBuffers(1, &m_vbo); gfx->destroyBuffer(vb);
glDeleteBuffers(1, &m_ebo);
if (s_active_vao == m_vao) {
s_active_vao = -1;
}
} }
} }