update rgDraw() pathway

src/hexgame.cpp

@@ -565,16 +565,20 @@ int main(int argc, char* argv[])
 		SDL_Delay(16);	// ~60hz
 		game_state* g = g_game_state;
 		render_state* r = g_render_state;
+		
 		moveCamera(g->is_moveup, g->is_moveleft, g->is_movedown, g->is_moveright,
 				g->is_moveforward, g->is_movebackward);
+		
 		rollCamera(g->is_rotateCW, g->is_rotateCCW);
+		
 		renderFrame(g->hex_array, g_render_state->entities, g_render_state->entity_count);
-#if 0
+		
 		if (r->is_debug_draw && g->draw_mode == CONE_FILL)
 			renderDebug(g_polygon_select_vertices);
-#endif
+		
 		renderGooey(handles, g->draw_mode, r->is_debug_draw, g->start_hex,
 					g->current_hex, g->is_selecting, getCameraPosition());
+		
 		SDL_GL_SwapWindow(handles.window);
 	}
 

src/render_group.cpp

@@ -204,30 +204,23 @@ rgInitEntity(gl_render_group* rg, Entity* e)
 void
 rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
 		glm::mat4 view_matrix, glm::mat4 projection_matrix,
-		glm::vec3 light_position, GLuint light_id)
+		glm::vec3 light_position, GLuint light_id, 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]);
 	
-	// TODO: testing lighting
-	glUniform3f(light_id, light_position.x, light_position.y, light_position.z);
-	glm::mat3 normal_matrix = glm::transpose(glm::inverse(glm::mat3(model_matrix)));
-	glUniformMatrix3fv(rg->normal_matrix_id, 1, GL_FALSE, &normal_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);
 	
-#if 0
 	if (update_vertex_data)
 	{
 		glBufferSubData(GL_ARRAY_BUFFER, 0, rg->vertex_buffer.buffer_len * sizeof(GLfloat),
 			rg->vertex_buffer.buffer);
 	}
-#endif
 
 	// 2nd attribute buffer : colors
 	if (rg->color_buffer.buffer)
@@ -246,6 +239,11 @@ rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
 		glEnableVertexAttribArray(2);
 		glBindBuffer(GL_ARRAY_BUFFER, rg->vertex_normals.buffer_id);
 		glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
+
+		// TODO: testing lighting
+		glUniform3f(light_id, light_position.x, light_position.y, light_position.z);
+		glm::mat3 normal_matrix = glm::transpose(glm::inverse(glm::mat3(model_matrix)));
+		glUniformMatrix3fv(rg->normal_matrix_id, 1, GL_FALSE, &normal_matrix[0][0]);
 	}
 
 	// draw
@@ -310,23 +308,10 @@ rgFree(gl_render_group* rg)
 	if (rg == nullptr)
 		return;
 
-	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 (rg->index_buffer.indices != nullptr) {
-		std::free(rg->index_buffer.indices);
-		rg->index_buffer.indices = nullptr;
-	}
-
-	// TODO: free vertex_normals here, and switch to using utilFree function
-
-	std::free(rg);
-	rg = nullptr;
+	utilSafeFree(rg->vertex_buffer.buffer);
+	utilSafeFree(rg->vertex_normals.buffer);
+	utilSafeFree(rg->index_buffer.indices);
+	utilSafeFree(rg->color_buffer.buffer);
+	utilSafeFree(rg);
 }
 

src/render_group.h

@@ -52,7 +52,7 @@ void rgFillColorBuffer(GLfloat buf[], int len, std::vector<hex_info>* hexes);
 
 void rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
 		glm::mat4 view_matrix, glm::mat4 projection_matrix,
-		glm::vec3 light_position, GLuint light_id);
+		glm::vec3 light_position, GLuint light_id, bool update_vertex_data = false);
 
 void rgDrawIndexed(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
 		glm::mat4 view_matrix, glm::mat4 projection_matrix,

src/renderer.cpp

@@ -560,7 +560,8 @@ renderFrame(std::vector<hex_info> *hexes, Entity* entities, uint32 entity_count)
 
 	// hex lines
 
-	//rgDraw(g_hex_line_render_group, GL_LINES, m_model, m_view, m_projection);
+	rgDraw(g_hex_line_render_group, GL_LINES, m_model, m_view, m_projection,
+		g_test_light.position, g_test_light.light_ID);
 
 	// TODO: update and send array of lights (pos, dir, color, intesity to shaders
 	// 	every frame through	rgDrawIndexed()
@@ -574,7 +575,6 @@ renderFrame(std::vector<hex_info> *hexes, Entity* entities, uint32 entity_count)
 	}
 }
 
-#if 0
 void
 renderDebug(std::vector<Point> &vertices)
 {
@@ -592,9 +592,8 @@ renderDebug(std::vector<Point> &vertices)
 		rg->vertex_buffer.buffer[i] = buf[i];
 
 	rgDraw(rg, GL_LINE_LOOP, g_scene_matrices.model, g_scene_matrices.view,
-			g_scene_matrices.projection, true);
+		g_scene_matrices.projection, g_test_light.position, g_test_light.light_ID, true);
 }
-#endif
 
 void
 freeBuffers()

src/renderer.h

@@ -27,6 +27,6 @@ void moveCamera(bool up, bool left, bool down, bool right, bool forward, bool ba
 void rollCamera(bool CW, bool CCW);
 void rotateCamera(int32	xrel, int32 yrel);
 void renderFrame(std::vector<hex_info> *hexes, Entity* entities, uint32 entity_count);
-//void renderDebug(std::vector<Point> &vertices);
+void renderDebug(std::vector<Point> &vertices);
 void freeBuffers();
 

src/util.cpp

@@ -33,8 +33,9 @@ utilDumpTextFile(const char* filename)
 void
 utilSafeFree(void* mem)
 {
-	assert(mem != nullptr);
-	std::free(mem);
-	mem = nullptr;
+	if (mem != nullptr) {
+		std::free(mem);
+		mem = nullptr;
+	}
 }