joey
/
lunarium_OLD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Single quad working with batch system now.

Browse Source 
Only draws the first quad in a batch though (indices issues?)
master
Joey Pollack 3 years ago
parent 733c832b81
commit 12168850d5
8 changed files with 225 additions and 94 deletions
Show Stats Download Patch File Download Diff File

2
src/renderer/index_buffer.cpp
Unescape Escape View File

@ -70,7 +70,7 @@ namespace lunarium
} }
// NOTE: BE CAREFUL! mSize is the size in bytes, not number of vertices. // NOTE: BE CAREFUL! mSize is the size in bytes, not number of vertices.
if (mIndex + size >= mSize) if (mIndex + size > mSize)
{ {
// Vertices do not fit into the buffer // Vertices do not fit into the buffer
Logger::Warn(LogCategory::GRAPHICS, "Cannot push indices into buffer - not enough space left! Space left: %n, data size: %n", mSize - mIndex, size); Logger::Warn(LogCategory::GRAPHICS, "Cannot push indices into buffer - not enough space left! Space left: %n, data size: %n", mSize - mIndex, size);

184
src/renderer/renderer2D.cpp
Unescape Escape View File

@ -44,12 +44,13 @@ namespace lunarium
mQuadData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 2 }); // Tex_coords mQuadData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 2 }); // Tex_coords
mQuadData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 4 }); // Color mQuadData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 4 }); // Color
mQuadData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::INT32, 1 }); // Texture Sampler Index mQuadData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::INT32, 1 }); // Texture Sampler Index
mQuadData.mVertexBuffer = VertexBuffer::Create(mQuadData.mBufferLayout, mQuadData.MaxVertices); mQuadData.mVertexBuffer = VertexBuffer::Create(mQuadData.mBufferLayout, mQuadData.MaxVertices, nullptr, mQuadData.MaxIndices, nullptr);
mQuadData.mIndexBuffer = new IndexBuffer(mQuadData.MaxIndices * sizeof(u32)); //mQuadData.mIndexBuffer = new IndexBuffer(mQuadData.MaxIndices * sizeof(u32));
std::string vert_source = File::ReadTextFile("quad.vert");
mQuadData.mQuadShader = new Shader(OGLDefaultShaders.DefaultShapeVertex, nullptr, OGLDefaultShaders.DefaultShapeFragment); std::string frag_source = File::ReadTextFile("quad.frag");
mQuadData.mQuadShader = new Shader(vert_source.c_str(), nullptr, frag_source.c_str());
if (!mQuadData.mQuadShader->IsValid()) if (!mQuadData.mQuadShader->IsValid())
{ {
return OpRes::Fail("Failed to create the quad shader"); return OpRes::Fail("Failed to create the quad shader");
@ -63,37 +64,40 @@ namespace lunarium
mpDebugTexture = Texture::Create(data, 1, 1); mpDebugTexture = Texture::Create(data, 1, 1);
// DEBUG: INIT TEST DATA // DEBUG: INIT TEST DATA
mTestData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 2}); // Position // mTestData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 2}); // Position
GLfloat vertices[6][2] = { // GLfloat vertices[6][2] = {
{ -0.5f, 0.5f, }, // { -0.5f, 0.5f, },
{ 0.5f, -0.5f, }, // { 0.5f, -0.5f, },
{ -0.5f, -0.5f, }, // { -0.5f, -0.5f, },
{ -0.5f, 0.5f, }, // { -0.5f, 0.5f, },
{ 0.5f, 0.5f, }, // { 0.5f, 0.5f, },
{ 0.5f, -0.5f, } // { 0.5f, -0.5f, }
}; // };
mTestData.mVertexBuffer = VertexBuffer::Create(mTestData.mBufferLayout, 6, vertices); // u32 indices[6] = { 0, 1, 2, 3, 4, 5 };
std::string vert_source = File::ReadTextFile("test.vert");
std::string frag_source = File::ReadTextFile("test.frag"); // // mTestData.mIndexBuffer = new IndexBuffer(6, indices);
mTestData.mQuadShader = new Shader(vert_source.c_str(), nullptr, frag_source.c_str()); // mTestData.mVertexBuffer = VertexBuffer::Create(mTestData.mBufferLayout, 6, nullptr, 6, indices);
if (!mTestData.mQuadShader->IsValid()) // std::string vert_source = File::ReadTextFile("test.vert");
{ // std::string frag_source = File::ReadTextFile("test.frag");
return OpRes::Fail("Failed to create the test shader"); // mTestData.mQuadShader = new Shader(vert_source.c_str(), nullptr, frag_source.c_str());
} // if (!mTestData.mQuadShader->IsValid())
// {
glGenVertexArrays(1, &mTVAO); // return OpRes::Fail("Failed to create the test shader");
glGenBuffers(1, &mTVBO); // }
glBindBuffer(GL_ARRAY_BUFFER, mTVBO); // glGenVertexArrays(1, &mTVAO);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 12, vertices, GL_STATIC_DRAW); // glGenBuffers(1, &mTVBO);
glBindVertexArray(mTVAO); // glBindBuffer(GL_ARRAY_BUFFER, mTVBO);
glEnableVertexAttribArray(0); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 12, vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ARRAY_BUFFER, 0); // glBindVertexArray(mTVAO);
glBindVertexArray(0); // glEnableVertexAttribArray(0);
// glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
// glBindBuffer(GL_ARRAY_BUFFER, 0);
// glBindVertexArray(0);
return OpRes::OK(); return OpRes::OK();
} }
@ -101,7 +105,7 @@ namespace lunarium
void Renderer2D::Shutdown() void Renderer2D::Shutdown()
{ {
VertexBuffer::Destroy(&mQuadData.mVertexBuffer); VertexBuffer::Destroy(&mQuadData.mVertexBuffer);
delete[] mQuadData.mIndexBuffer; //delete[] mQuadData.mIndexBuffer;
} }
void Renderer2D::SetClearColor(Color color) void Renderer2D::SetClearColor(Color color)
@ -129,10 +133,10 @@ namespace lunarium
void Renderer2D::BeginDraw(OrthographicCamera* pCamera) void Renderer2D::BeginDraw(OrthographicCamera* pCamera)
{ {
mpCamera = pCamera; mpCamera = pCamera;
//glViewport(0, 0, pCamera->GetViewport().Width, pCamera->GetViewport().Height); glViewport(0, 0, pCamera->GetViewport().Width, pCamera->GetViewport().Height);
int w, h; // int w, h;
Core::MainWindow().GetFramebufferSize(&w, &h); // Core::MainWindow().GetFramebufferSize(&w, &h);
glViewport(0, 0, w, h); // glViewport(0, 0, w, h);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
//ResetFrameStats(); //ResetFrameStats();
} }
@ -147,7 +151,7 @@ namespace lunarium
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
void Renderer2D::DrawQuad(Rectangle quad, Color color, Texture* texture, float angle) void Renderer2D::DrawQuad(Rectangle quad, Color color, Texture* texture, float angle)
{ {
/*
mTestData.color = color; mTestData.color = color;
//mTestData.mVertexBuffer->Bind(); //mTestData.mVertexBuffer->Bind();
mTestData.mQuadShader->Use(); mTestData.mQuadShader->Use();
@ -155,40 +159,61 @@ namespace lunarium
Uniform uni { "spriteColor", UniformType::F3, -1 }; Uniform uni { "spriteColor", UniformType::F3, -1 };
mTestData.mQuadShader->SetUniform(uni, color.arr).LogIfFailed(LogCategory::GRAPHICS, "Failed to set uniform for the test shader!"); mTestData.mQuadShader->SetUniform(uni, color.arr).LogIfFailed(LogCategory::GRAPHICS, "Failed to set uniform for the test shader!");
glBindVertexArray(mTVAO); //glBindVertexArray(mTVAO);
glDrawArrays(GL_TRIANGLES, 0, 6); GLfloat vertices[6][2] = {
{ -0.5f, 0.5f, },
{ 0.5f, -0.5f, },
{ -0.5f, -0.5f, },
/* { -0.5f, 0.5f, },
int texture_slot = -1; { 0.5f, 0.5f, },
if (texture) { 0.5f, -0.5f, }
{ };
for (int i = 0; i < mLoadedTextures.size(); i++) mTestData.mVertexBuffer->PushVertices(vertices, 6);
{ mTestData.mVertexBuffer->Bind();
if (texture == mLoadedTextures[i]) // mTestData.mIndexBuffer->Bind();
{ glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
texture_slot = i; //glDrawArrays(GL_TRIANGLES, 0, 6);
break; mTestData.mVertexBuffer->Clear();
} */
}
if (-1 == texture_slot)
{ int texture_slot = 0;
mLoadedTextures.push_back(texture); // int texture_slot = -1;
texture_slot = mLoadedTextures.size() - 1; // if (texture)
} // {
} // for (int i = 0; i < mLoadedTextures.size(); i++)
// {
// if (texture == mLoadedTextures[i])
// {
// texture_slot = i;
// break;
// }
// }
// if (-1 == texture_slot)
// {
// mLoadedTextures.push_back(texture);
// texture_slot = mLoadedTextures.size() - 1;
// }
// }
float vertices[40]; float vertices[40];
unsigned char* vertices_wl = (unsigned char*)vertices; // vertices write location pointer unsigned char* vertices_wl = (unsigned char*)vertices; // vertices write location pointer
glm::mat4 model(1.0f); // glm::mat4 model(1.0f);
model = glm::translate(model, glm::vec3(quad.CenterPoint().x, quad.CenterPoint().y, 0.0f)); // model = glm::translate(model, glm::vec3(quad.CenterPoint().x, quad.CenterPoint().y, 0.0f));
// model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f));
glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, glm::vec3(quad.X, quad.Y, 0.0f));
model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f)); model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f));
model = glm::scale(model, glm::vec3(quad.HalfWidth * 2, quad.HalfHeight * 2, 1.0f));
// FIRST // FIRST
QuadData::Vertex v1; QuadData::Vertex v1;
int vert_size = sizeof(QuadData::Vertex); int vert_size = sizeof(QuadData::Vertex);
v1.pos = mQuadData.vert_pos[0];// * model; v1.pos = model * mQuadData.vert_pos[0];
v1.tex_coord = mQuadData.vert_tex[0]; v1.tex_coord = mQuadData.vert_tex[0];
v1.color = color; v1.color = color;
v1.tex_slot = texture_slot; v1.tex_slot = texture_slot;
@ -197,7 +222,7 @@ namespace lunarium
// SECOND // SECOND
QuadData::Vertex v2; QuadData::Vertex v2;
v2.pos = mQuadData.vert_pos[1];// * model; v2.pos = model * mQuadData.vert_pos[1];
v2.tex_coord = mQuadData.vert_tex[1]; v2.tex_coord = mQuadData.vert_tex[1];
v2.color = color; v2.color = color;
v2.tex_slot = texture_slot; v2.tex_slot = texture_slot;
@ -206,7 +231,7 @@ namespace lunarium
// THIRD // THIRD
QuadData::Vertex v3; QuadData::Vertex v3;
v3.pos = mQuadData.vert_pos[2];// * model; v3.pos =model * mQuadData.vert_pos[2];
v3.tex_coord = mQuadData.vert_tex[2]; v3.tex_coord = mQuadData.vert_tex[2];
v3.color = color; v3.color = color;
v3.tex_slot = texture_slot; v3.tex_slot = texture_slot;
@ -215,7 +240,7 @@ namespace lunarium
// FOURTH // FOURTH
QuadData::Vertex v4; QuadData::Vertex v4;
v4.pos = mQuadData.vert_pos[3];// * model; v4.pos = model * mQuadData.vert_pos[3];
v4.tex_coord = mQuadData.vert_tex[3]; v4.tex_coord = mQuadData.vert_tex[3];
v4.color = color; v4.color = color;
v4.tex_slot = texture_slot; v4.tex_slot = texture_slot;
@ -229,7 +254,7 @@ namespace lunarium
} }
// INDICES // INDICES
if (!mQuadData.mIndexBuffer->PushIndices(mQuadData.indices, 6 * sizeof(u32))) if (!mQuadData.mVertexBuffer->PushIndices(mQuadData.indices, 6))
{ {
Logger::Error(LogCategory::GRAPHICS, "Quad IndexBuffer is full - This shouldn't happen because the VertexBuffer should fill up first!"); Logger::Error(LogCategory::GRAPHICS, "Quad IndexBuffer is full - This shouldn't happen because the VertexBuffer should fill up first!");
return; return;
@ -237,7 +262,7 @@ namespace lunarium
mQuadData.mNumQuads++; mQuadData.mNumQuads++;
mFrameStats.NumTris += 2; mFrameStats.NumTris += 2;
*/
} }
@ -298,34 +323,39 @@ namespace lunarium
{ {
if (mQuadData.mNumQuads > 0) if (mQuadData.mNumQuads > 0)
{ {
mQuadData.mVertexBuffer->Bind(); //mQuadData.mIndexBuffer->Bind();
mQuadData.mIndexBuffer->Bind();
mQuadData.mQuadShader->Use(); mQuadData.mQuadShader->Use();
for (int i = 0; i < mLoadedTextures.size(); i++) for (int i = 0; i < mLoadedTextures.size(); i++)
{ {
mLoadedTextures[i]->Bind(i); mLoadedTextures[i]->Bind(i);
} }
Uniform umodel; // Uniform umodel;
umodel.Type = UniformType::FMAT4; // umodel.Type = UniformType::FMAT4;
umodel.Location = -1; // umodel.Location = -1;
umodel.Name = "model"; // umodel.Name = "model";
Uniform uprojview; Uniform uprojview;
uprojview.Type = UniformType::FMAT4; uprojview.Type = UniformType::FMAT4;
uprojview.Location = -1; uprojview.Location = -1;
uprojview.Name = "projview"; uprojview.Name = "projview";
mQuadData.mQuadShader->SetUniform(umodel, (void*)glm::value_ptr(glm::mat4(1.0f))).LogIfFailed(LogCategory::GRAPHICS); //mQuadData.mQuadShader->SetUniform(umodel, (void*)glm::value_ptr(glm::mat4(1.0f))).LogIfFailed(LogCategory::GRAPHICS);
mQuadData.mQuadShader->SetUniform(uprojview, (void*)glm::value_ptr(mpCamera->GetViewProjection())).LogIfFailed(LogCategory::GRAPHICS); mQuadData.mQuadShader->SetUniform(uprojview, (void*)glm::value_ptr(mpCamera->GetViewProjection())).LogIfFailed(LogCategory::GRAPHICS);
Uniform uni { "spriteColor", UniformType::F3, -1 };
//Color c = ;
//mQuadData.mQuadShader->SetUniform(uni, Color::Red().arr).LogIfFailed(LogCategory::GRAPHICS, "Failed to set uniform for the test shader!");
mQuadData.mVertexBuffer->Bind();
glDrawElements(GL_TRIANGLES, mQuadData.mNumQuads * 6, GL_UNSIGNED_INT, nullptr); glDrawElements(GL_TRIANGLES, mQuadData.mNumQuads * 6, GL_UNSIGNED_INT, nullptr);
//glDrawArrays(GL_TRIANGLES, 0, mQuadData.mNumQuads * 2);
mFrameStats.DrawCalls++; mFrameStats.DrawCalls++;
} }
// Reset drawing data // Reset drawing data
mLoadedTextures.clear(); mLoadedTextures.clear();
mQuadData.mVertexBuffer->Clear(); mQuadData.mVertexBuffer->Clear();
mQuadData.mIndexBuffer->Clear(); //mQuadData.mIndexBuffer->Clear();
mQuadData.mNumQuads = 0; mQuadData.mNumQuads = 0;
// TODO: Add the debug texture back to the map // TODO: Add the debug texture back to the map

2
src/renderer/renderer2D.h
Unescape Escape View File

@ -101,7 +101,7 @@ namespace lunarium
BufferLayout mBufferLayout; BufferLayout mBufferLayout;
VertexBuffer* mVertexBuffer; VertexBuffer* mVertexBuffer;
IndexBuffer* mIndexBuffer; //IndexBuffer* mIndexBuffer;
Shader* mQuadShader; Shader* mQuadShader;
} mQuadData; } mQuadData;

12
src/renderer/shaders/quad.frag
Unescape Escape View File

@ -0,0 +1,12 @@
#version 450 core
//in vec2 TexCoords;
in vec4 vert_color;
out vec4 color;
//uniform sampler2D image;
uniform vec3 spriteColor;
void main()
{
color = vert_color; //vec4(spriteColor, 1.0); // * texture(image, TexCoords);
}

17
src/renderer/shaders/quad.vert
Unescape Escape View File

@ -0,0 +1,17 @@
#version 450 core
layout(location = 0) in vec3 pos;
layout(location = 1) in vec2 tex_coords;
layout(location = 2) in vec4 color;
layout(location = 3) in int tex_slot;
//out vec2 TexCoords;
out vec4 vert_color;
uniform mat4 projview;
void main()
{
vert_color = color;
gl_Position = projview * vec4(pos, 1.0);
}

81
src/renderer/vertex_buffer.cpp
Unescape Escape View File

@ -78,9 +78,9 @@ namespace lunarium
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
// VERTEX BUFFER // VERTEX BUFFER
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
VertexBuffer* VertexBuffer::Create(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices) VertexBuffer* VertexBuffer::Create(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices, u32 num_indices, u32* indices)
{ {
return new VertexBuffer(VertexLayout, num_vertices, vertices); return new VertexBuffer(VertexLayout, num_vertices, vertices, num_indices, indices);
} }
void VertexBuffer::Destroy(VertexBuffer** ppBuf) void VertexBuffer::Destroy(VertexBuffer** ppBuf)
@ -90,8 +90,8 @@ namespace lunarium
*ppBuf = nullptr; *ppBuf = nullptr;
} }
VertexBuffer::VertexBuffer(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices) VertexBuffer::VertexBuffer(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices, u32 num_indices, u32* indices)
: mLayout(VertexLayout), mSize(0), mIndex(0), mIsStatic(false) : mLayout(VertexLayout), mSize(0), mIndex(0), mEBO(0), mEBOSize(num_indices * sizeof(u32)), mEBOIndex(0), mNumIndices(0), mIsStatic(false)
{ {
mIsStatic = vertices != nullptr; mIsStatic = vertices != nullptr;
@ -101,8 +101,14 @@ namespace lunarium
glGenVertexArrays(1, &mVAO); glGenVertexArrays(1, &mVAO);
glGenBuffers(1, &mVBO); glGenBuffers(1, &mVBO);
Bind(); if (mEBOSize > 0)
{
glGenBuffers(1, &mEBO);
}
Bind();
BindVBO();
if (vertices) if (vertices)
{ {
glBufferData(GL_ARRAY_BUFFER, mSize, vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, mSize, vertices, GL_STATIC_DRAW);
@ -112,7 +118,18 @@ namespace lunarium
glBufferData(GL_ARRAY_BUFFER, mSize, nullptr, GL_DYNAMIC_DRAW); glBufferData(GL_ARRAY_BUFFER, mSize, nullptr, GL_DYNAMIC_DRAW);
} }
if (mEBOSize > 0)
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mEBO);
u32 mode = indices ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;
mEBOIsStatic = indices ? true : false;
mNumIndices = indices ? num_indices : 0;
glBufferData(GL_ELEMENT_ARRAY_BUFFER, mEBOSize, indices, mode);
}
mLayout.ImplementLayout(); mLayout.ImplementLayout();
Unbind();
UnbindVBO();
} }
@ -124,17 +141,30 @@ namespace lunarium
} }
mIndex = 0; mIndex = 0;
mEBOIndex = 0;
if (!mEBOIsStatic)
mNumIndices = 0;
} }
void VertexBuffer::Bind() void VertexBuffer::Bind()
{ {
glBindVertexArray(mVAO); glBindVertexArray(mVAO);
glBindBuffer(GL_ARRAY_BUFFER, mVBO);
} }
void VertexBuffer::Unbind() void VertexBuffer::Unbind()
{ {
glBindVertexArray(0); glBindVertexArray(0);
}
void VertexBuffer::BindVBO()
{
glBindBuffer(GL_ARRAY_BUFFER, mVBO);
}
void VertexBuffer::UnbindVBO()
{
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
} }
@ -149,22 +179,53 @@ namespace lunarium
int data_size = mLayout.GetLayoutSizeInBytes() * num_verts; int data_size = mLayout.GetLayoutSizeInBytes() * num_verts;
// TODO: BE CAREFUL! mSize is the size in bytes, not number of vertices. // TODO: BE CAREFUL! mSize is the size in bytes, not number of vertices.
if (mIndex + data_size >= mSize) if (mIndex + data_size > mSize)
{ {
// Vertices do not fit into the buffer // Vertices do not fit into the buffer
Logger::Warn(LogCategory::GRAPHICS, "Cannot push vertices into buffer - not enough space left! Space left: %n, data size: %n", mSize - mIndex, data_size); Logger::Warn(LogCategory::GRAPHICS, "Cannot push vertices into buffer - not enough space left! Space left: %d, data size: %d", mSize - mIndex, data_size);
return false; return false;
} }
// Add verts to the buffer // Add verts to the buffer
Bind(); BindVBO();
glBufferSubData(GL_ARRAY_BUFFER, mIndex, data_size, vertices); glBufferSubData(GL_ARRAY_BUFFER, mIndex, data_size, vertices);
Unbind(); UnbindVBO();
mIndex += data_size; mIndex += data_size;
return true; return true;
} }
bool VertexBuffer::PushIndices(const u32* indices, u32 num_indices)
{
if (mEBOIsStatic)
{
Logger::Warn(LogCategory::GRAPHICS, "Cannot push indices into a static buffer!");
return false;
}
int data_size = sizeof(u32) * num_indices;
if (mEBOIndex + data_size > mEBOSize)
{
// Indices do not fit into the buffer
Logger::Warn(LogCategory::GRAPHICS, "Cannot push indices into buffer - not enough space left! Space left: %d, data size: %d", mEBOSize - mEBOIndex, data_size);
return false;
}
Bind();
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, mEBOIndex, data_size, indices);
Unbind();
int error = glGetError();
if (error > 0)
{
Logger::Error(LogCategory::GRAPHICS, "OGL ERROR!");
}
mNumIndices += num_indices;
mEBOIndex += data_size;
return true;
}
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
// HELPER METHODS // HELPER METHODS
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

14
src/renderer/vertex_buffer.h
Unescape Escape View File

@ -62,7 +62,7 @@ namespace lunarium
public: public:
static VertexBuffer* Create(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices = nullptr); static VertexBuffer* Create(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices = nullptr, u32 num_indices = 0, u32* indices = nullptr);
static void Destroy(VertexBuffer** ppBuf); static void Destroy(VertexBuffer** ppBuf);
void Clear(); void Clear();
@ -70,9 +70,13 @@ namespace lunarium
void Bind(); void Bind();
void Unbind(); void Unbind();
void BindVBO();
void UnbindVBO();
/// Returns false if the data does not fit in the buffer /// Returns false if the data does not fit in the buffer
/// size is the size in bytes /// size is the size in bytes
bool PushVertices(const void* vertices, u32 num_verts); bool PushVertices(const void* vertices, u32 num_verts);
bool PushIndices(const u32* indices, u32 num_indices);
private: private:
@ -83,9 +87,15 @@ namespace lunarium
u32 mSize; // Size of the buffer in bytes u32 mSize; // Size of the buffer in bytes
u32 mIndex; // The next spot to push data into for a dynamic buffer u32 mIndex; // The next spot to push data into for a dynamic buffer
u32 mEBO;
u32 mEBOSize;
u32 mEBOIndex;
u32 mEBOIsStatic;
u32 mNumIndices; // Number of indices currently in the buffer
private: // HELPER METHODS private: // HELPER METHODS
VertexBuffer(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices = nullptr); VertexBuffer(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices = nullptr, u32 num_indices = 0, u32* indices = nullptr);
void Free(); void Free();
}; };
} }

3
src/run_modes/testbed/scenes/simple_render_scene.cpp
Unescape Escape View File

@ -197,9 +197,10 @@ namespace lunarium
// g.DrawImage(*mpRenderedImage, Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mpRenderedImage->GetWidth(), (float)mpRenderedImage->GetHeight()), // g.DrawImage(*mpRenderedImage, Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mpRenderedImage->GetWidth(), (float)mpRenderedImage->GetHeight()),
// Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mImageSize.Width, (float)mImageSize.Height), Color(1.0f, 1.0f, 1.0f, 1.0f), angle); // Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mImageSize.Width, (float)mImageSize.Height), Color(1.0f, 1.0f, 1.0f, 1.0f), angle);
g.DrawQuad(Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mImageSize.Width, (float)mImageSize.Height), Color(01.0f, 0.0f, 0.0f, 1.0f), nullptr, angle); //g.DrawQuad(Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mImageSize.Width, (float)mImageSize.Height), Color(1.0f, 1.0f, 0.0f, 1.0f), nullptr, angle);
g.DrawQuad(Rectangle(200, 200, 128.0f, 128.0f), Color(0.0f, 1.0f, 0.0f, 1.0f));//, nullptr, box_angle); g.DrawQuad(Rectangle(200, 200, 128.0f, 128.0f), Color(0.0f, 1.0f, 0.0f, 1.0f));//, nullptr, box_angle);
g.DrawQuad(Rectangle(400, 300, 64.0f, 64.0f), Color(0.0f, 1.0f, 1.0f, 1.0f), nullptr, box_angle);
//g->DrawImage(*mpTestImageLoad, glm::vec2(0.0f, 0.0f), Color::White()); //g->DrawImage(*mpTestImageLoad, glm::vec2(0.0f, 0.0f), Color::White());
//Rectangle src = Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mpTestImageLoad->GetWidth(), (float)mpTestImageLoad->GetHeight()); //Rectangle src = Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mpTestImageLoad->GetWidth(), (float)mpTestImageLoad->GetHeight());

Write Preview
Loading…
Cancel
Save