cinnaboot
/
hexgame
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

got indexed drawing w/ assimp working

master
cinnaboot 8 years ago
parent
5c162f7163
commit
b26ff2145b
3 changed files with 73 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 92
      src/render_group.cpp
  2. 13
      src/render_group.h
  3. 23
      src/renderer.cpp

92
src/render_group.cpp
Unescape View File

@ -70,24 +70,8 @@ rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char *
return true; return true;
} }
// NOTE: this will only work after a call to glBindBuffer void
bool rgInitGLBufferObject(gl_buffer* buf_obj, int len, GLenum usage, GLenum target, GLfloat data[])
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[])
{ {
buf_obj->buffer_len = (size_t) len; buf_obj->buffer_len = (size_t) len;
buf_obj->buffer = (GLfloat*) std::calloc(len, sizeof(GLfloat)); 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); glGenBuffers(1, &buf_obj->buffer_id);
glBindBuffer(GL_ARRAY_BUFFER, buf_obj->buffer_id); glBindBuffer(target, buf_obj->buffer_id);
glBufferData(GL_ARRAY_BUFFER, len * sizeof(GLfloat), buf_obj->buffer, usage); glBufferData(target, len * sizeof(GLfloat), buf_obj->buffer, usage);
if (!checkGLBufferSize(GL_ARRAY_BUFFER, len * sizeof(GLfloat), __LINE__))
return false;
return true;
} }
// NOTE: helper for fillColorBuffer() to convert uint32 color to GLfloat triplet // 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 1
if (!rgInitGLBufferObject(&rg->vertex_buffer, entity_buf_len, rgInitGLBufferObject(&rg->vertex_buffer, entity_buf_len,
GL_DYNAMIC_DRAW, entity_buf)) GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, entity_buf);
retVal = false;
if (!rgInitGLBufferObject(&rg->color_buffer, entity_buf_len, rgInitGLBufferObject(&rg->color_buffer, entity_buf_len,
GL_STATIC_DRAW, entity_color_buf)) GL_STATIC_DRAW, GL_ARRAY_BUFFER, entity_color_buf);
retVal = false;
#endif #endif
// TODO: testing indexed draw // TODO: testing indexed draw
gl_buffer index_buffer; gl_index_buffer index_buffer;
index_buffer.num_indices = e->num_indices; index_buffer.buffer_len = e->num_indices;
// TODO: there's no associated call to free this alloc until we remake
index_buffer.indices = (uint *) std::calloc(e->num_indices, sizeof(uint)); index_buffer.indices = (uint *) std::calloc(e->num_indices, sizeof(uint));
for (uint i = 0; i < e->num_indices; i++) 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; 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); std::free(entity_buf);
@ -246,28 +229,57 @@ rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
glDisableVertexAttribArray(1); glDisableVertexAttribArray(1);
} }
// TODO: testing indexed drawing
void void
rgDrawIndexed(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix, rgDrawIndexed(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
glm::mat4 view_matrix, glm::mat4 projection_matrix, bool update_vertex_data) 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 void
rgFree(gl_render_group* rg) rgFree(gl_render_group* rg)
{ {
assert(rg != nullptr); assert(rg != nullptr);
gl_buffer bufs[] = {rg->vertex_buffer, rg->color_buffer, rg->index_buffer}; gl_buffer bufs[] = {rg->vertex_buffer, rg->color_buffer};
for (uint i = 0; i < 3; i++) { for (uint i = 0; i < 2; i++) {
gl_buffer& buf = bufs[i]; gl_buffer& buf = bufs[i];
if (buf.buffer != nullptr) { if (buf.buffer != nullptr) {
std::free(buf.buffer); std::free(buf.buffer);
buf.buffer = nullptr; 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) { if (rg->entities != nullptr) {

13
src/render_group.h
Unescape View File

@ -3,12 +3,18 @@
//#include "types.h" //#include "types.h"
#include "hexgame.h" #include "hexgame.h"
struct gl_buffer struct gl_buffer
{ {
GLuint buffer_id = 0; GLuint buffer_id = 0;
size_t buffer_len = 0; // NOTE: number of elements in buffer size_t buffer_len = 0; // NOTE: number of elements in buffer
GLfloat* buffer = nullptr; GLfloat* buffer = nullptr;
uint num_indices = 0; };
struct gl_index_buffer
{
GLuint buffer_id = 0;
size_t buffer_len = 0;
uint* indices = nullptr; uint* indices = nullptr;
}; };
@ -17,7 +23,7 @@ struct gl_render_group
// NOTE: For now the renderFrame function will assume these are the same size // NOTE: For now the renderFrame function will assume these are the same size
gl_buffer vertex_buffer; gl_buffer vertex_buffer;
gl_buffer color_buffer; gl_buffer color_buffer;
gl_buffer index_buffer; gl_index_buffer index_buffer;
GLuint program_id = 0; GLuint program_id = 0;
GLuint model_matrix_id = 0; GLuint model_matrix_id = 0;
GLuint view_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_buffer gl_buffer;
typedef struct gl_index_buffer gl_index_buffer;
typedef struct gl_render_group gl_render_group; typedef struct gl_render_group gl_render_group;
gl_render_group* rgCreateGroup(); 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, 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); 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); bool rgInitEntity(gl_render_group* rg, Entity* e);

23
src/renderer.cpp
Unescape View File

@ -392,7 +392,6 @@ createScene(std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count)
// and still use one buffer for multiple shapes/paths gldrawarraysintanced?, gldrawelements? // 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 // 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 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 int line_buf_len = hexes->size() * line_vertices_per_hex * 3; // 3 floats per vertex
// temporary buffers // temporary buffers
@ -404,24 +403,20 @@ createScene(std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count)
fillTriangleBufferFromHex(vbuf, 54 * i, (*hexes)[i]); fillTriangleBufferFromHex(vbuf, 54 * i, (*hexes)[i]);
if (!rgInitGLBufferObject(&g_filled_hex_render_group->vertex_buffer, vbuf_len, rgInitGLBufferObject(&g_filled_hex_render_group->vertex_buffer, vbuf_len,
GL_DYNAMIC_DRAW, vbuf)) GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, vbuf);
return false;
// color data for hex vertices // color data for hex vertices
rgFillColorBuffer(cbuf, vbuf_len, hexes); rgFillColorBuffer(cbuf, vbuf_len, hexes);
rgInitGLBufferObject(&g_filled_hex_render_group->color_buffer, vbuf_len,
if (!rgInitGLBufferObject(&g_filled_hex_render_group->color_buffer, vbuf_len, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, cbuf);
GL_DYNAMIC_DRAW, cbuf))
return false;
// hex line vertex data // hex line vertex data
fillHexLineBuffer(line_buf, line_buf_len, hexes); fillHexLineBuffer(line_buf, line_buf_len, hexes);
if (!rgInitGLBufferObject(&g_hex_line_render_group->vertex_buffer, line_buf_len, rgInitGLBufferObject(&g_hex_line_render_group->vertex_buffer, line_buf_len,
GL_STATIC_DRAW, line_buf)) GL_STATIC_DRAW, GL_ARRAY_BUFFER, line_buf);
return false;
// free temporary buffers // free temporary buffers
// TODO: temp buffers won't be freed if exit early is hit // TODO: temp buffers won't be freed if exit early is hit
@ -434,8 +429,8 @@ createScene(std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count)
// 4 vertices, 3 floats per vertex // 4 vertices, 3 floats per vertex
int len = 4 * 3; int len = 4 * 3;
if (!rgInitGLBufferObject(&g_debug_render_group->vertex_buffer, len, GL_DYNAMIC_DRAW, 0)) rgInitGLBufferObject(&g_debug_render_group->vertex_buffer, len,
return false; GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, 0);
/////////////// ///////////////
// TODO: Testing Entities/assimp model loading // TODO: Testing Entities/assimp model loading
@ -556,7 +551,7 @@ renderFrame(std::vector<hex_info> *hexes)
// TODO: testing entity rendering // TODO: testing entity rendering
rg = g_entity_render_group; 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 void

Write Preview
Loading…
Cancel
Save