move global render_group pointers in renderer to render_state

src/renderer.cpp

@@ -24,13 +24,13 @@
 #define DEFAULT_FRAGMENT_SHADER_FILE "../data/default.fs"
 #define MAX_LIGHTS 10 // NOTE: needs to match the fragment shader source
 
-typedef struct clear_col
+struct clear_col
 {
 	real32 R;
 	real32 G;
 	real32 B;
 	real32 A;
-} clear_col;
+};
 clear_col g_clear_col { 75.f / 255.f, 135.f / 255.f, 135.f / 255.f, 1.f };
 
 
@@ -44,15 +44,7 @@ void fillTriangleBufferFromHex(GLfloat buf[], int idx,  const hex_info &hex);
 void fillColorBuffer(GLfloat buf[], int len, std::vector<hex_info>* hexes);
 void fillHexLineBuffer(GLfloat buf[], int len, std::vector<hex_info>* hexes);
 
-
-// globals
-static render_group* g_filled_hex_render_group;
-static render_group* g_hex_line_render_group;
-static render_group* g_debug_render_group;
-static rg_shader_program g_default_shader;
-// NOTE: entity render_group pointers are kept in the entity struct
 static render_state* g_render_state;
-// TODO: maybe keep all these globals in the render_state object?
 
 
 // interface
@@ -121,7 +113,7 @@ initRenderer(render_state* rs)
 	const char* vs_code = utilDumpTextFile(DEFAULT_VERTEX_SHADER_FILE);
 	const char* fs_code = utilDumpTextFile(DEFAULT_FRAGMENT_SHADER_FILE);
 
-	bool shader_error = !rgInitShaderProgram(g_default_shader, vs_code, fs_code);
+	bool shader_error = !rgInitShaderProgram(rs->default_shader, vs_code, fs_code);
 
 	utilSafeFree(vs_code);
 	utilSafeFree(fs_code);
@@ -141,15 +133,9 @@ void
 freeBuffers(render_state* rs)
 {
 	utilSafeFree(rs->lights);
-
-	std::vector<render_group*> groups = {
-		g_filled_hex_render_group,
-		g_hex_line_render_group,
-		g_debug_render_group,
-	};
-
-	for (render_group* group : groups)
-		rgFree(group);
+	rgFree(rs->filled_hex_render_group);
+	rgFree(rs->hex_line_render_group);
+	rgFree(rs->debug_render_group);
 }
 
 bool
@@ -187,7 +173,7 @@ createScene(render_state* rs, std::vector<hex_info>* hexes, Entity* entities, ui
 
 	for (uint i = 0; i < entity_count; i++) {
 		rgInitEntity(&entities[i]);
-		entities[i].ren_group->shader = g_default_shader;
+		entities[i].ren_group->shader = rs->default_shader;
 	}
 
 	if (!initHexGridBuffers(hexes))
@@ -196,14 +182,14 @@ createScene(render_state* rs, std::vector<hex_info>* hexes, Entity* entities, ui
 	// debug draw vertices
 
 	uint debug_buf_len = 12; // 4 vertices, 3 floats per vertex
-	g_debug_render_group = rgInitSingle(g_default_shader, debug_buf_len, true, 0, GL_LINE_LOOP);
+	rs->debug_render_group = rgInitSingle(rs->default_shader, debug_buf_len, true, 0, GL_LINE_LOOP);
 
-	if (g_debug_render_group == nullptr)
+	if (rs->debug_render_group == nullptr)
 		return false;
 
-	gl_buffer& debug_vertex_buf = g_debug_render_group->render_objects[0]->vertex_buffer;
-	gl_buffer& debug_color_buf = g_debug_render_group->render_objects[0]->color_buffer;
-	gl_buffer& debug_normal_buf = g_debug_render_group->render_objects[0]->normal_buffer;
+	gl_buffer& debug_vertex_buf = rs->debug_render_group->render_objects[0]->vertex_buffer;
+	gl_buffer& debug_color_buf = rs->debug_render_group->render_objects[0]->color_buffer;
+	gl_buffer& debug_normal_buf = rs->debug_render_group->render_objects[0]->normal_buffer;
 
 	for (uint i = 0; i < debug_buf_len; i += 3) {
 		debug_color_buf.buffer[i] = 1.f;
@@ -235,7 +221,7 @@ renderFrame(render_state* rs, std::vector<hex_info> *hexes, Entity* entities, ui
 	// filled hexes
 
 	// get new colors every frame
-	render_group* rg = g_filled_hex_render_group;
+	render_group* rg = rs->filled_hex_render_group;
 	gl_buffer& color_buf = rg->render_objects[0]->color_buffer;
 	// TODO: this needs optimization for large grids, very performance intensive
 	fillColorBuffer(color_buf.buffer, color_buf.buffer_len, hexes);
@@ -243,7 +229,7 @@ renderFrame(render_state* rs, std::vector<hex_info> *hexes, Entity* entities, ui
 		rs->lights, rs->num_lights, false, true);
 
 	// hex lines
-	rgDraw(g_hex_line_render_group, m_model, m_view, m_projection,
+	rgDraw(rs->hex_line_render_group, m_model, m_view, m_projection,
 			rs->lights, rs->num_lights);
 
 	// entities
@@ -256,13 +242,13 @@ renderFrame(render_state* rs, std::vector<hex_info> *hexes, Entity* entities, ui
 void
 renderDebug(render_state* rs, std::vector<Point> &vertices)
 {
-	GLfloat* buf = g_debug_render_group->render_objects[0]->vertex_buffer.buffer;
+	GLfloat* buf = rs->debug_render_group->render_objects[0]->vertex_buffer.buffer;
 	buf[0] = vertices[0].x; buf[1] = vertices[0].y; buf[2] = 0;
 	buf[3] = vertices[1].x; buf[4] = vertices[1].y; buf[2] = 0;
 	buf[6] = vertices[2].x; buf[7] = vertices[2].y; buf[8] = 0;
 	buf[9] = vertices[3].x; buf[10] = vertices[3].y; buf[11] = 0;
 
-	rgDraw(g_debug_render_group, g_render_state->cam.model, g_render_state->cam.view,
+	rgDraw(rs->debug_render_group, g_render_state->cam.model, g_render_state->cam.view,
 		g_render_state->cam.projection, rs->lights, rs->num_lights, true);
 }
 
@@ -290,14 +276,15 @@ initHexGridBuffers(std::vector<hex_info>* hexes)
 	uint line_buf_len = hexes->size() * line_vertices_per_hex * 3; // 3 floats per vertex
 	uint vbuf_len = hexes->size() * 6 * 3 * 3;
 
-	g_filled_hex_render_group = rgInitSingle(g_default_shader, vbuf_len, true);
+	render_state* rs = g_render_state;
+	rs->filled_hex_render_group = rgInitSingle(rs->default_shader, vbuf_len, true);
 
-	if (g_filled_hex_render_group == nullptr)
+	if (rs->filled_hex_render_group == nullptr)
 		return false;
 
-	gl_buffer& vbuf = g_filled_hex_render_group->render_objects[0]->vertex_buffer;
-	gl_buffer& cbuf = g_filled_hex_render_group->render_objects[0]->color_buffer;
-	gl_buffer& normal_buf = g_filled_hex_render_group->render_objects[0]->normal_buffer;
+	gl_buffer& vbuf = rs->filled_hex_render_group->render_objects[0]->vertex_buffer;
+	gl_buffer& cbuf = rs->filled_hex_render_group->render_objects[0]->color_buffer;
+	gl_buffer& normal_buf = rs->filled_hex_render_group->render_objects[0]->normal_buffer;
 
 	for (uint i = 0; i < hexes->size(); i++)
 		fillTriangleBufferFromHex(vbuf.buffer, i * 54, (*hexes)[i]);
@@ -317,14 +304,14 @@ initHexGridBuffers(std::vector<hex_info>* hexes)
 
 	// hex lines
 
-	g_hex_line_render_group = rgInitSingle(g_default_shader, line_buf_len, true, 0, GL_LINES);
+	rs->hex_line_render_group = rgInitSingle(rs->default_shader, line_buf_len, true, 0, GL_LINES);
 
-	if (g_hex_line_render_group == nullptr)
+	if (rs->hex_line_render_group == nullptr)
 		return false;
 
-	gl_buffer& line_buf = g_hex_line_render_group->render_objects[0]->vertex_buffer;
-	gl_buffer& line_color_buf = g_hex_line_render_group->render_objects[0]->color_buffer;
-	gl_buffer& line_normal_buf = g_hex_line_render_group->render_objects[0]->normal_buffer;
+	gl_buffer& line_buf = rs->hex_line_render_group->render_objects[0]->vertex_buffer;
+	gl_buffer& line_color_buf = rs->hex_line_render_group->render_objects[0]->color_buffer;
+	gl_buffer& line_normal_buf = rs->hex_line_render_group->render_objects[0]->normal_buffer;
 	fillHexLineBuffer(line_buf.buffer, line_buf_len, hexes);
 	rgBufferData(&line_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
 

src/renderer.h

@@ -33,6 +33,11 @@ struct render_state
 	SDL_Handles handles;
 	camera cam;
 
+	render_group* filled_hex_render_group;
+	render_group* hex_line_render_group;
+	render_group* debug_render_group;
+	rg_shader_program default_shader;
+
 	// TODO: testing lighting
 	rg_point_light* lights = nullptr;
 	uint num_lights = 0;
@@ -42,7 +47,6 @@ struct render_state
 bool initRenderer(render_state* rs);
 void freeBuffers(render_state* rs);
 bool addTexture(SDL_Handles &handles, const char * path);
-v2f getUnprojectedCoords(int32 x, int32 y, int32 vp_width, int32 vp_height);
 bool createScene(render_state* rs, std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count);
 void renderFrame(render_state* rs, std::vector<hex_info> *hexes, Entity* entities, uint32 entity_count);
 void renderDebug(render_state* rs, std::vector<Point> &vertices);