diff --git a/src/render_group.cpp b/src/render_group.cpp index dd00aad..8c91856 100644 --- a/src/render_group.cpp +++ b/src/render_group.cpp @@ -70,24 +70,8 @@ rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char * return true; } -// NOTE: this will only work after a call to glBindBuffer -bool -checkGLBufferSize(GLenum buf_type, int expected_size, int line_num) -{ - GLint gl_size; - glGetBufferParameteriv(buf_type, GL_BUFFER_SIZE ,&gl_size); - - if (expected_size != gl_size) - { - LOG(ERROR) << "line: " << line_num << "gl buffer size mismatch\n"; - return false; - } - - return true; -} - -bool -rgInitGLBufferObject(gl_buffer* buf_obj, int len, GLenum usage, GLfloat data[]) +void +rgInitGLBufferObject(gl_buffer* buf_obj, int len, GLenum usage, GLenum target, GLfloat data[]) { buf_obj->buffer_len = (size_t) len; buf_obj->buffer = (GLfloat*) std::calloc(len, sizeof(GLfloat)); @@ -99,13 +83,8 @@ rgInitGLBufferObject(gl_buffer* buf_obj, int len, GLenum usage, GLfloat data[]) } glGenBuffers(1, &buf_obj->buffer_id); - glBindBuffer(GL_ARRAY_BUFFER, buf_obj->buffer_id); - glBufferData(GL_ARRAY_BUFFER, len * sizeof(GLfloat), buf_obj->buffer, usage); - - if (!checkGLBufferSize(GL_ARRAY_BUFFER, len * sizeof(GLfloat), __LINE__)) - return false; - - return true; + glBindBuffer(target, buf_obj->buffer_id); + glBufferData(target, len * sizeof(GLfloat), buf_obj->buffer, usage); } // NOTE: helper for fillColorBuffer() to convert uint32 color to GLfloat triplet @@ -176,20 +155,17 @@ rgInitEntity(gl_render_group* rg, Entity* e) } #if 1 - if (!rgInitGLBufferObject(&rg->vertex_buffer, entity_buf_len, - GL_DYNAMIC_DRAW, entity_buf)) - retVal = false; + rgInitGLBufferObject(&rg->vertex_buffer, entity_buf_len, + GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, entity_buf); - if (!rgInitGLBufferObject(&rg->color_buffer, entity_buf_len, - GL_STATIC_DRAW, entity_color_buf)) - retVal = false; + rgInitGLBufferObject(&rg->color_buffer, entity_buf_len, + GL_STATIC_DRAW, GL_ARRAY_BUFFER, entity_color_buf); #endif // TODO: testing indexed draw - gl_buffer index_buffer; - index_buffer.num_indices = e->num_indices; - // TODO: there's no associated call to free this alloc until we remake + gl_index_buffer index_buffer; + index_buffer.buffer_len = e->num_indices; index_buffer.indices = (uint *) std::calloc(e->num_indices, sizeof(uint)); for (uint i = 0; i < e->num_indices; i++) @@ -197,6 +173,13 @@ rgInitEntity(gl_render_group* rg, Entity* e) rg->index_buffer = index_buffer; + glGenBuffers(1, &rg->index_buffer.buffer_id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rg->index_buffer.buffer_id); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, e->num_indices * sizeof(uint), + rg->index_buffer.indices, GL_STATIC_DRAW); + //rgInitGLBufferObject(&rg->index_buffer, rg->index_buffer.num_indices, + // GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER, rg->index_buffer.indices); + ////////// std::free(entity_buf); @@ -246,28 +229,57 @@ rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix, glDisableVertexAttribArray(1); } +// TODO: testing indexed drawing void rgDrawIndexed(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix, glm::mat4 view_matrix, glm::mat4 projection_matrix, bool update_vertex_data) { - // + glUseProgram(rg->program_id); + glUniformMatrix4fv(rg->model_matrix_id, 1, GL_FALSE, &model_matrix[0][0]); + glUniformMatrix4fv(rg->view_matrix_id, 1, GL_FALSE, &view_matrix[0][0]); + glUniformMatrix4fv(rg->projection_matrix_id, 1, GL_FALSE, &projection_matrix[0][0]); + + // 1st attribute buffer : vertices + glEnableVertexAttribArray(0); + glBindBuffer(GL_ARRAY_BUFFER, rg->vertex_buffer.buffer_id); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0); + + // 2nd attribute buffer : colors + if (rg->color_buffer.buffer) + { + glEnableVertexAttribArray(1); + glBindBuffer(GL_ARRAY_BUFFER, rg->color_buffer.buffer_id); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0); + } + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rg->index_buffer.buffer_id); + + // draw + //glDrawArrays(draw_mode, 0, rg->vertex_buffer.buffer_len / 3); + glDrawElements(draw_mode, rg->index_buffer.buffer_len, GL_UNSIGNED_INT, 0); + + // cleanup + glDisableVertexAttribArray(0); + if (rg->color_buffer.buffer) + glDisableVertexAttribArray(1); } void rgFree(gl_render_group* rg) { assert(rg != nullptr); - gl_buffer bufs[] = {rg->vertex_buffer, rg->color_buffer, rg->index_buffer}; - for (uint i = 0; i < 3; i++) { + gl_buffer bufs[] = {rg->vertex_buffer, rg->color_buffer}; + for (uint i = 0; i < 2; i++) { gl_buffer& buf = bufs[i]; if (buf.buffer != nullptr) { std::free(buf.buffer); buf.buffer = nullptr; } - if (buf.indices != nullptr) { - std::free(buf.indices); - buf.indices = nullptr; - } + } + + if (rg->index_buffer.indices != nullptr) { + std::free(rg->index_buffer.indices); + rg->index_buffer.indices = nullptr; } if (rg->entities != nullptr) { diff --git a/src/render_group.h b/src/render_group.h index eb806b6..fd72162 100644 --- a/src/render_group.h +++ b/src/render_group.h @@ -3,21 +3,27 @@ //#include "types.h" #include "hexgame.h" + struct gl_buffer { GLuint buffer_id = 0; size_t buffer_len = 0; // NOTE: number of elements in buffer GLfloat* buffer = nullptr; - uint num_indices = 0; +}; + +struct gl_index_buffer +{ + GLuint buffer_id = 0; + size_t buffer_len = 0; uint* indices = nullptr; -} ; +}; struct gl_render_group { // NOTE: For now the renderFrame function will assume these are the same size gl_buffer vertex_buffer; gl_buffer color_buffer; - gl_buffer index_buffer; + gl_index_buffer index_buffer; GLuint program_id = 0; GLuint model_matrix_id = 0; GLuint view_matrix_id = 0; @@ -27,6 +33,7 @@ struct gl_render_group }; typedef struct gl_buffer gl_buffer; +typedef struct gl_index_buffer gl_index_buffer; typedef struct gl_render_group gl_render_group; gl_render_group* rgCreateGroup(); @@ -36,7 +43,7 @@ gl_render_group* rgCreateGroup(); bool rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char * frag_code, const char* model_name, const char* view_name, const char* projection_name); -bool rgInitGLBufferObject(gl_buffer* buf_obj, int len, GLenum usage, GLfloat data[]); +void rgInitGLBufferObject(gl_buffer* buf_obj, int len, GLenum usage, GLenum target, GLfloat data[]); bool rgInitEntity(gl_render_group* rg, Entity* e); diff --git a/src/renderer.cpp b/src/renderer.cpp index 99bc795..9ccb791 100644 --- a/src/renderer.cpp +++ b/src/renderer.cpp @@ -392,7 +392,6 @@ createScene(std::vector* hexes, Entity* entities, uint32 entity_count) // and still use one buffer for multiple shapes/paths gldrawarraysintanced?, gldrawelements? // https://gamedev.stackexchange.com/questions/104310/opengl-4-5-primitive-restart-vs-base-index int line_vertices_per_hex = 6 * 2; // 12 vertices since we're using line segments atm - //gl_buffer *line_vertex_buffer = &g_hex_line_render_group.vertex_buffer; int line_buf_len = hexes->size() * line_vertices_per_hex * 3; // 3 floats per vertex // temporary buffers @@ -404,24 +403,20 @@ createScene(std::vector* hexes, Entity* entities, uint32 entity_count) fillTriangleBufferFromHex(vbuf, 54 * i, (*hexes)[i]); - if (!rgInitGLBufferObject(&g_filled_hex_render_group->vertex_buffer, vbuf_len, - GL_DYNAMIC_DRAW, vbuf)) - return false; + rgInitGLBufferObject(&g_filled_hex_render_group->vertex_buffer, vbuf_len, + GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, vbuf); // color data for hex vertices rgFillColorBuffer(cbuf, vbuf_len, hexes); - - if (!rgInitGLBufferObject(&g_filled_hex_render_group->color_buffer, vbuf_len, - GL_DYNAMIC_DRAW, cbuf)) - return false; + rgInitGLBufferObject(&g_filled_hex_render_group->color_buffer, vbuf_len, + GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, cbuf); // hex line vertex data fillHexLineBuffer(line_buf, line_buf_len, hexes); - if (!rgInitGLBufferObject(&g_hex_line_render_group->vertex_buffer, line_buf_len, - GL_STATIC_DRAW, line_buf)) - return false; + rgInitGLBufferObject(&g_hex_line_render_group->vertex_buffer, line_buf_len, + GL_STATIC_DRAW, GL_ARRAY_BUFFER, line_buf); // free temporary buffers // TODO: temp buffers won't be freed if exit early is hit @@ -434,8 +429,8 @@ createScene(std::vector* hexes, Entity* entities, uint32 entity_count) // 4 vertices, 3 floats per vertex int len = 4 * 3; - if (!rgInitGLBufferObject(&g_debug_render_group->vertex_buffer, len, GL_DYNAMIC_DRAW, 0)) - return false; + rgInitGLBufferObject(&g_debug_render_group->vertex_buffer, len, + GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, 0); /////////////// // TODO: Testing Entities/assimp model loading @@ -556,7 +551,7 @@ renderFrame(std::vector *hexes) // TODO: testing entity rendering rg = g_entity_render_group; - rgDraw(rg, GL_TRIANGLES, rg->entities[0].model_transform, m_view, m_projection); + rgDrawIndexed(rg, GL_TRIANGLES, rg->entities[0].model_transform, m_view, m_projection); } void