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.
if (mIndex + size >= mSize)
if (mIndex + size > mSize)
{
// 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);

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, 4 }); // Color
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));
mQuadData.mQuadShader = new Shader(OGLDefaultShaders.DefaultShapeVertex, nullptr, OGLDefaultShaders.DefaultShapeFragment);
std::string vert_source = File::ReadTextFile("quad.vert");
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())
{
return OpRes::Fail("Failed to create the quad shader");
@ -63,37 +64,40 @@ namespace lunarium
mpDebugTexture = Texture::Create(data, 1, 1);
// DEBUG: INIT TEST DATA
mTestData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 2}); // Position
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, }
};
mTestData.mVertexBuffer = VertexBuffer::Create(mTestData.mBufferLayout, 6, vertices);
std::string vert_source = File::ReadTextFile("test.vert");
std::string frag_source = File::ReadTextFile("test.frag");
mTestData.mQuadShader = new Shader(vert_source.c_str(), nullptr, frag_source.c_str());
if (!mTestData.mQuadShader->IsValid())
{
return OpRes::Fail("Failed to create the test shader");
}
glGenVertexArrays(1, &mTVAO);
glGenBuffers(1, &mTVBO);
glBindBuffer(GL_ARRAY_BUFFER, mTVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 12, vertices, GL_STATIC_DRAW);
glBindVertexArray(mTVAO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
// mTestData.mBufferLayout.PushVertexAttribute(VertexAttribute { VertexAttributeType::FLOAT32, 2}); // Position
// 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, }
// };
// u32 indices[6] = { 0, 1, 2, 3, 4, 5 };
// // mTestData.mIndexBuffer = new IndexBuffer(6, indices);
// mTestData.mVertexBuffer = VertexBuffer::Create(mTestData.mBufferLayout, 6, nullptr, 6, indices);
// std::string vert_source = File::ReadTextFile("test.vert");
// std::string frag_source = File::ReadTextFile("test.frag");
// mTestData.mQuadShader = new Shader(vert_source.c_str(), nullptr, frag_source.c_str());
// if (!mTestData.mQuadShader->IsValid())
// {
// return OpRes::Fail("Failed to create the test shader");
// }
// glGenVertexArrays(1, &mTVAO);
// glGenBuffers(1, &mTVBO);
// glBindBuffer(GL_ARRAY_BUFFER, mTVBO);
// glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 12, vertices, GL_STATIC_DRAW);
// glBindVertexArray(mTVAO);
// glEnableVertexAttribArray(0);
// glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
// glBindBuffer(GL_ARRAY_BUFFER, 0);
// glBindVertexArray(0);
return OpRes::OK();
}
@ -101,7 +105,7 @@ namespace lunarium
void Renderer2D::Shutdown()
{
VertexBuffer::Destroy(&mQuadData.mVertexBuffer);
delete[] mQuadData.mIndexBuffer;
//delete[] mQuadData.mIndexBuffer;
}
void Renderer2D::SetClearColor(Color color)
@ -129,10 +133,10 @@ namespace lunarium
void Renderer2D::BeginDraw(OrthographicCamera* pCamera)
{
mpCamera = pCamera;
//glViewport(0, 0, pCamera->GetViewport().Width, pCamera->GetViewport().Height);
int w, h;
Core::MainWindow().GetFramebufferSize(&w, &h);
glViewport(0, 0, w, h);
glViewport(0, 0, pCamera->GetViewport().Width, pCamera->GetViewport().Height);
// int w, h;
// Core::MainWindow().GetFramebufferSize(&w, &h);
// glViewport(0, 0, w, h);
glClear(GL_COLOR_BUFFER_BIT);
//ResetFrameStats();
}
@ -147,7 +151,7 @@ namespace lunarium
/////////////////////////////////////////////////////////////////////
void Renderer2D::DrawQuad(Rectangle quad, Color color, Texture* texture, float angle)
{
/*
mTestData.color = color;
//mTestData.mVertexBuffer->Bind();
mTestData.mQuadShader->Use();
@ -155,40 +159,61 @@ namespace lunarium
Uniform uni { "spriteColor", UniformType::F3, -1 };
mTestData.mQuadShader->SetUniform(uni, color.arr).LogIfFailed(LogCategory::GRAPHICS, "Failed to set uniform for the test shader!");
glBindVertexArray(mTVAO);
glDrawArrays(GL_TRIANGLES, 0, 6);
//glBindVertexArray(mTVAO);
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, }
};
mTestData.mVertexBuffer->PushVertices(vertices, 6);
mTestData.mVertexBuffer->Bind();
// mTestData.mIndexBuffer->Bind();
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
//glDrawArrays(GL_TRIANGLES, 0, 6);
mTestData.mVertexBuffer->Clear();
*/
/*
int texture_slot = -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;
}
}
int texture_slot = 0;
// int texture_slot = -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];
unsigned char* vertices_wl = (unsigned char*)vertices; // vertices write location pointer
glm::mat4 model(1.0f);
model = glm::translate(model, glm::vec3(quad.CenterPoint().x, quad.CenterPoint().y, 0.0f));
// glm::mat4 model(1.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::scale(model, glm::vec3(quad.HalfWidth * 2, quad.HalfHeight * 2, 1.0f));
// FIRST
QuadData::Vertex v1;
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.color = color;
v1.tex_slot = texture_slot;
@ -197,7 +222,7 @@ namespace lunarium
// SECOND
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.color = color;
v2.tex_slot = texture_slot;
@ -206,7 +231,7 @@ namespace lunarium
// THIRD
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.color = color;
v3.tex_slot = texture_slot;
@ -215,7 +240,7 @@ namespace lunarium
// FOURTH
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.color = color;
v4.tex_slot = texture_slot;
@ -229,7 +254,7 @@ namespace lunarium
}
// 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!");
return;
@ -237,7 +262,7 @@ namespace lunarium
mQuadData.mNumQuads++;
mFrameStats.NumTris += 2;
*/
}
@ -298,34 +323,39 @@ namespace lunarium
{
if (mQuadData.mNumQuads > 0)
{
mQuadData.mVertexBuffer->Bind();
mQuadData.mIndexBuffer->Bind();
//mQuadData.mIndexBuffer->Bind();
mQuadData.mQuadShader->Use();
for (int i = 0; i < mLoadedTextures.size(); i++)
{
mLoadedTextures[i]->Bind(i);
}
Uniform umodel;
umodel.Type = UniformType::FMAT4;
umodel.Location = -1;
umodel.Name = "model";
// Uniform umodel;
// umodel.Type = UniformType::FMAT4;
// umodel.Location = -1;
// umodel.Name = "model";
Uniform uprojview;
uprojview.Type = UniformType::FMAT4;
uprojview.Location = -1;
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);
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);
//glDrawArrays(GL_TRIANGLES, 0, mQuadData.mNumQuads * 2);
mFrameStats.DrawCalls++;
}
// Reset drawing data
mLoadedTextures.clear();
mQuadData.mVertexBuffer->Clear();
mQuadData.mIndexBuffer->Clear();
//mQuadData.mIndexBuffer->Clear();
mQuadData.mNumQuads = 0;
// 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;
VertexBuffer* mVertexBuffer;
IndexBuffer* mIndexBuffer;
//IndexBuffer* mIndexBuffer;
Shader* mQuadShader;
} 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
/////////////////////////////////////////////////////////////////////
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)
@ -90,8 +90,8 @@ namespace lunarium
*ppBuf = nullptr;
}
VertexBuffer::VertexBuffer(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices)
: mLayout(VertexLayout), mSize(0), mIndex(0), mIsStatic(false)
VertexBuffer::VertexBuffer(BufferLayout& VertexLayout, u32 num_vertices, const void* vertices, u32 num_indices, u32* indices)
: mLayout(VertexLayout), mSize(0), mIndex(0), mEBO(0), mEBOSize(num_indices * sizeof(u32)), mEBOIndex(0), mNumIndices(0), mIsStatic(false)
{
mIsStatic = vertices != nullptr;
@ -101,8 +101,14 @@ namespace lunarium
glGenVertexArrays(1, &mVAO);
glGenBuffers(1, &mVBO);
Bind();
if (mEBOSize > 0)
{
glGenBuffers(1, &mEBO);
}
Bind();
BindVBO();
if (vertices)
{
glBufferData(GL_ARRAY_BUFFER, mSize, vertices, GL_STATIC_DRAW);
@ -112,7 +118,18 @@ namespace lunarium
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();
Unbind();
UnbindVBO();
}
@ -124,17 +141,30 @@ namespace lunarium
}
mIndex = 0;
mEBOIndex = 0;
if (!mEBOIsStatic)
mNumIndices = 0;
}
void VertexBuffer::Bind()
{
glBindVertexArray(mVAO);
glBindBuffer(GL_ARRAY_BUFFER, mVBO);
}
void VertexBuffer::Unbind()
{
glBindVertexArray(0);
}
void VertexBuffer::BindVBO()
{
glBindBuffer(GL_ARRAY_BUFFER, mVBO);
}
void VertexBuffer::UnbindVBO()
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
@ -149,22 +179,53 @@ namespace lunarium
int data_size = mLayout.GetLayoutSizeInBytes() * num_verts;
// 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
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;
}
// Add verts to the buffer
Bind();
BindVBO();
glBufferSubData(GL_ARRAY_BUFFER, mIndex, data_size, vertices);
Unbind();
UnbindVBO();
mIndex += data_size;
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
/////////////////////////////////////////////////////////////////////

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

@ -62,7 +62,7 @@ namespace lunarium
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);
void Clear();
@ -70,9 +70,13 @@ namespace lunarium
void Bind();
void Unbind();
void BindVBO();
void UnbindVBO();
/// Returns false if the data does not fit in the buffer
/// size is the size in bytes
bool PushVertices(const void* vertices, u32 num_verts);
bool PushIndices(const u32* indices, u32 num_indices);
private:
@ -83,9 +87,15 @@ namespace lunarium
u32 mSize; // Size of the buffer in bytes
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
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();
};
}

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()),
// 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(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());
//Rectangle src = Rectangle::MakeFromTopLeft(0.0f, 0.0f, (float)mpTestImageLoad->GetWidth(), (float)mpTestImageLoad->GetHeight());

Write Preview
Loading…
Cancel
Save