update palette uv coords for hexgrid when selecting hexes

data/default.fs

@@ -25,7 +25,6 @@ uniform sampler2D sampler;
 
 void main()
 {
-	// https://www.tomdalling.com/blog/modern-opengl/06-diffuse-point-lighting
 	vec3 normal = normalize(normal_matrix * fragNormal);
 	vec3 fragPosition = vec3(model * vec4(fragVertex, 1));
 	float totalBrightness = 0;
@@ -36,8 +35,6 @@ void main()
 		totalBrightness += brightness;
 	}
 
-	vec4 sampled_color = texture(sampler, fragUV.st);
-	color = clamp(totalBrightness, 0, 1) * sampled_color;
-	//color = vec4(clamp(totalBrightness, 0, 1) * fragColor, 0);
+	color = clamp(totalBrightness, 0, 1) * texture(sampler, fragUV.st);
 }
 

src/hexgame.cpp

@@ -417,7 +417,7 @@ int main(int argc, char* argv[])
 		cameraMove(r->cam, g->is_moveup, g->is_moveleft, g->is_movedown, g->is_moveright,
 				g->is_moveforward, g->is_movebackward);
 
-		renRenderFrame(r, g->grid.hex_array, g->entities, g->entity_count);
+		renRenderFrame(r, g->grid, g->entities, g->entity_count);
 
 		if (r->is_debug_draw && g->grid.draw_mode == CONE_FILL)
 			renRenderDebug(r, g_polygon_select_vertices);

src/hexgrid.cpp

@@ -157,24 +157,21 @@ hgUpdateHexConeFill(hexgrid& hg, int32 x, int32 y, float cone_angle, std::vector
 }
 
 void
-hgUpdateColorBuffer(gl_buffer& color_buf, std::vector<hex_info>* hex_array)
+hgUpdateUVBuffer(hexgrid& hg, float* uv_buffer, uint buf_len)
 {
-	uint buf_idx = 0;
-	uint buf_len_per_hex = 54; // NOTE: 6 triangles * 3 vertices * 3 floats
-	GLfloat color[3];
-
-	for (uint i = 0; i < hex_array->size(); i++) {
-		buf_idx = i * buf_len_per_hex;
-		hex_info hxi = (*hex_array)[i];
-
-		// TODO: check performance of this since we call multiple times per frame
-		// 	maybe can cache glfloat triplets somewhere
-		utilConvertColor(color, hxi.current_color);
-
-		for (uint j = 0; j < buf_len_per_hex; j += 3) {
-			color_buf.buffer[buf_idx + j] = color[0];
-			color_buf.buffer[buf_idx + j + 1] = color[1];
-			color_buf.buffer[buf_idx + j + 2] = color[2];
+	// NOTE: 6 triangles * 3 vertices * 3 floats (not 2 to stay aligned with vbuffer)
+	uint buf_len_per_hex = 54;
+	assert(buf_len == hg.hex_array->size() * buf_len_per_hex);
+
+	for (uint i = 0; i < hg.hex_array->size(); i++) {
+		hex_info hxi = (*hg.hex_array)[i];
+		v2f uv_coords = (hxi.selected) ? hg.selected_fill_color_uv : hg.fill_color_uv;
+		uint buf_idx = i * buf_len_per_hex;
+
+		for (uint j = 0; j < buf_len_per_hex; j +=3) {
+			uv_buffer[buf_idx + j + 0] = uv_coords.x;
+			uv_buffer[buf_idx + j + 1] = uv_coords.y;
+			uv_buffer[buf_idx + j + 2] = 0;
 		}
 	}
 }

src/hexgrid.h

@@ -47,9 +47,13 @@ struct hexgrid
 	v3f position = v3f(0, 0, 0);
 	uint hex_size = 10;
 	uint hex_radius = 0;
+
 	uint32 fill_color = 0xFFFFFFFF;
 	uint32 selected_fill_color = 0xFFFFFFFF;
 	uint32 hex_line_color = 0xFFFFFFFF;
+	v2f fill_color_uv;
+	v2f selected_fill_color_uv;
+	v2f line_color_uv;
 
 	std::vector<hex_info>* hex_array = nullptr;
 	hex_info* start_hex = nullptr;
@@ -71,5 +75,4 @@ void hgUpdateHexLineDraw(hexgrid& hg, int32 x, int32 y);
 
 void hgUpdateHexConeFill(hexgrid& hg, int32 x, int32 y, float cone_angle, std::vector<Point>& debug_vertices);
 
-void hgUpdateColorBuffer(gl_buffer& color_buf, std::vector<hex_info>* hex_array);
-
+void hgUpdateUVBuffer(hexgrid& hg, float* uv_buffer, uint buf_len);

src/render_group.cpp

@@ -243,6 +243,11 @@ rgDraw(render_group* rg, glm::mat4 model_matrix,
 			glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
 			glBindTexture(GL_TEXTURE_2D, ro->tex_id);
 			glUniform1i(rg->shader.sampler_id, 0);
+
+			if (update_color_data) {
+				glBufferSubData(GL_ARRAY_BUFFER, 0, ro->uv_buffer.buffer_len * sizeof(GLfloat),
+						ro->uv_buffer.buffer);
+			}
 		}
 
 		// draw

src/renderer.cpp

@@ -178,7 +178,7 @@ renCreateScene(render_state* rs, Entity* entities, uint32 entity_count)
 }
 
 void
-renRenderFrame(render_state* rs, std::vector<hex_info> *hexes, Entity* entities, uint32 entity_count)
+renRenderFrame(render_state* rs, hexgrid& hg, Entity* entities, uint32 entity_count)
 {
 	glClearColor(g_clear_col.R, g_clear_col.G, g_clear_col.B, g_clear_col.A);
 	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
@@ -191,9 +191,8 @@ renRenderFrame(render_state* rs, std::vector<hex_info> *hexes, Entity* entities,
 
 	// get new colors every frame
 	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
-	hgUpdateColorBuffer(color_buf, hexes);
+	gl_buffer& uv_buf = rg->render_objects[0]->uv_buffer;
+	hgUpdateUVBuffer(hg, uv_buf.buffer, uv_buf.buffer_len);
 	rgDraw(rg, m_model, m_view, m_projection,
 		rs->lights, rs->num_lights, false, true);
 

src/renderer.h

@@ -53,7 +53,7 @@ void renFreeBuffers(render_state* rs);
 
 bool renCreateScene(render_state* rs, Entity* entities, uint32 entity_count);
 
-void renRenderFrame(render_state* rs, std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count);
+void renRenderFrame(render_state* rs, hexgrid& hg, Entity* entities, uint32 entity_count);
 
 void renRenderDebug(render_state* rs, std::vector<Point> &vertices);
 

src/scene_loader.cpp

@@ -27,8 +27,8 @@ glm::vec4 parseVec4(const rapidjson::Value& node);
 uint32 parseHex32(std::string s);
 bool validateScene(rapidjson::Document* schema_doc, rapidjson::Document* scene_doc,
 		const char* scene_file);
-void populateFilledHexGLBuffers(hexgrid& hg, render_group* rg_filled, util_image palette_image);
-void populateLineGLBuffers(hexgrid& hg, render_group* rg_lines, util_image palette_image);
+void populateFilledHexGLBuffers(hexgrid& hg, render_group* rg_filled);
+void populateLineGLBuffers(hexgrid& hg, render_group* rg_lines);
 
 
 // interface
@@ -163,8 +163,12 @@ slCreateHexRenderGroups(hexgrid& hg, render_state* rs)
 		return false;
 	}
 
-	populateFilledHexGLBuffers(hg, rg_filled, rs->palette_image);
-	populateLineGLBuffers(hg, rg_lines, rs->palette_image);
+	hg.fill_color_uv = utilGetPaletteCoords(rs->palette_image, hg.fill_color);
+	hg.selected_fill_color_uv = utilGetPaletteCoords(rs->palette_image, hg.selected_fill_color);
+	hg.line_color_uv = utilGetPaletteCoords(rs->palette_image, hg.hex_line_color);
+
+	populateFilledHexGLBuffers(hg, rg_filled);
+	populateLineGLBuffers(hg, rg_lines);
 
 	render_object* ro = rg_filled->render_objects[0];
 	ro->use_texture = true;
@@ -282,26 +286,17 @@ parseVec4(const rapidjson::Value& node)
 }
 
 void
-populateFilledHexGLBuffers(hexgrid& hg, render_group* rg_filled, util_image palette_image)
+populateFilledHexGLBuffers(hexgrid& hg, render_group* rg_filled)
 {
 	render_object* ro = rg_filled->render_objects[0];
 	gl_buffer& vbuf = ro->vertex_buffer;
-	gl_buffer& cbuf = ro->color_buffer;
 	gl_buffer& normal_buf = ro->normal_buffer;
 	gl_buffer& uv_buf = ro->uv_buffer;
 
 	assert((hg.hex_array->size() * 6 * 3 * 3) == vbuf.buffer_len);
 
 	// fill uv_buffer with palette texture coords
-	v2f fill_color_coords = utilGetPaletteCoords(palette_image, hg.fill_color);
-
-	for (uint i = 0; i < uv_buf.buffer_len; i += 3) {
-		uv_buf.buffer[i + 0] = fill_color_coords.x;
-		uv_buf.buffer[i + 1] = fill_color_coords.y;
-		uv_buf.buffer[i + 2] = 0;
-	}
-
-	hgUpdateColorBuffer(cbuf, hg.hex_array);
+	hgUpdateUVBuffer(hg, uv_buf.buffer, uv_buf.buffer_len);
 
 	// cheat at vertex normals since all hexes lay flat on z-axis
 	for (uint i = 0; i < normal_buf.buffer_len; i += 3) {
@@ -351,7 +346,7 @@ populateFilledHexGLBuffers(hexgrid& hg, render_group* rg_filled, util_image pale
 }
 
 void
-populateLineGLBuffers(hexgrid& hg, render_group* rg_lines, util_image palette_image)
+populateLineGLBuffers(hexgrid& hg, render_group* rg_lines)
 {
 	render_object* ro = rg_lines->render_objects[0];
 	gl_buffer& vbuf = ro->vertex_buffer;
@@ -373,11 +368,9 @@ populateLineGLBuffers(hexgrid& hg, render_group* rg_lines, util_image palette_im
 	}
 
 	// fill uv_buffer with palette texture coords
-	v2f uv_coords = utilGetPaletteCoords(palette_image, hg.hex_line_color);
-
 	for (uint i = 0; i < uv_buf.buffer_len; i += 3) {
-		uv_buf.buffer[i + 0] = uv_coords.x;
-		uv_buf.buffer[i + 1] = uv_coords.y;
+		uv_buf.buffer[i + 0] = hg.line_color_uv.x;
+		uv_buf.buffer[i + 1] = hg.line_color_uv.y;
 		uv_buf.buffer[i + 2] = 0;
 	}