got indexed drawing w/ assimp working

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) {

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);
 

src/renderer.cpp

@@ -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?
 	// 	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<hex_info>* 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<hex_info>* 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<hex_info> *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