re-add world_transform

include/entity.h

@@ -14,12 +14,7 @@
 // 	level functions based on the mesh_type property
 struct entity
 {
-#if 0
-	mesh_t mesh_type;
-	simple_render_object* simple_ro;
-	GLenum draw_mode;
-#endif
-
+	glm::mat4 world_transform;
 	simple_mesh* mesh;
 
 	// TODO: should be a pointer into a global array of mesh_info(s) or

include/render_object.h

@@ -21,20 +21,12 @@ roInitSimpleMesh(simple_mesh& mesh_in, GLenum draw_mode);
 void
 roFree(render_objects* r_objs);
 
-void
-roTranslate(render_objects* r_objs, glm::mat4 xform);
-
-void
-roScale(render_object* ro, glm::mat4 xform);
-
-void
-roRotate(render_object* ro, glm::mat4 xform);
-
 // TODO: we probably want to re-introduce a world_transform matrix here again
 // 	so we can do: projection * view * world_transform * model_transform
 // 	that way model animations and world orientation/position can be separated
 void
 roDraw(render_objects* r_ojbs,
+	glm::mat4 world_transform,
 	camera& cam,
 	shader_wrapper sw,
 	light_group* lights);

include/renderer.h

@@ -56,7 +56,7 @@ struct render_state
 
 render_state*
 renInit(const char* title = "Tangerine",
-		glm::vec2 viewport_dims = glm::vec2(1280, 720));
+	glm::vec2 viewport_dims = glm::vec2(1280, 720));
 
 void renShutdown(render_state* rs);
 

include/shader_program.h

@@ -23,6 +23,7 @@ struct default_shader_program
 struct simple_shader_program
 {
 	GLuint program_id;
+	GLuint world_transform_id;
 	GLuint MVP_id;
 	GLuint vertex_array_id;
 };

src/default_shaders.cpp

@@ -71,13 +71,14 @@ layout (location = 1) in vec3 color;
 
 out vec3 frag_color;
 
+uniform mat4 world_transform;
 uniform mat4 MVP;
 
 
 void main()
 {
 	frag_color = color;
-	gl_Position = MVP * vec4(position, 1);
+	gl_Position =  MVP * world_transform * vec4(position, 1);
 }
 )SVS";
 

src/entity.cpp

@@ -57,72 +57,27 @@ entFree(entity& e)
 void
 entSetWorldPosition(entity& e, glm::vec3 v)
 {
-#if 0
 	e.world_transform[3][0] = v.x;
 	e.world_transform[3][1] = v.y;
 	e.world_transform[3][2] = v.z;
-	if (e.mesh_type == SIMPLE_MESH) {
-		//
-	}
-
-	if (e.mesh_type == DEFAULT_MESHES) {
-		//
-	}
-#endif
 }
 
 void
 entTranslate(entity& e, glm::vec3 v)
 {
-#if 0
 	e.world_transform = glm::translate(e.world_transform, v);
-	if (e.mesh_type == SIMPLE_MESH) {
-		//
-	}
-
-	if (e.mesh_type == DEFAULT_MESHES) {
-		//
-	}
-#endif
 }
 
 void
 entScale(entity& e, glm::vec3 v)
 {
-#if 0
-	//e.world_transform = glm::scale(e.world_transform, v);
-
-	if (e.mesh_type == SIMPLE_MESH) {
-		//
-	}
-
-	if (e.mesh_type == DEFAULT_MESHES) {
-		for (uint i = 0; i < e.meshes.num_meshes; i++) {
-			render_object& ro = e.render_objs[i];
-			ro.node_xform = glm::scale(ro.node_xform, v);
-		}
-	}
-#endif
+	e.world_transform = glm::scale(e.world_transform, v);
 }
 
 void
 entRotate(entity& e, float angle, glm::vec3 axis)
 {
-#if 0
-	//e.world_transform = glm::rotate(e.world_transform, angle, axis);
-
-	if (e.mesh_type == SIMPLE_MESH) {
-		glm::mat4& xform = roGetTransform(e.simple_ro);
-		xform = glm::rotate(xform, angle, axis);
-	}
-
-	if (e.mesh_type == DEFAULT_MESHES) {
-		for (uint i = 0; i < e.meshes.num_meshes; i++) {
-			render_object& ro = e.render_objs[i];
-			ro.node_xform = glm::rotate(ro.node_xform, angle, axis);
-		}
-	}
-#endif
+	e.world_transform = glm::rotate(e.world_transform, angle, axis);
 }
 
 
@@ -131,6 +86,7 @@ entRotate(entity& e, float angle, glm::vec3 axis)
 void
 initDefaults(entity& e)
 {
+	e.world_transform = glm::mat4(1.0);
 	entScale(e, glm::vec3(1.0));
 	entSetWorldPosition(e, glm::vec3(0, 0, 0));
 }

src/render_object.cpp

@@ -35,11 +35,13 @@ struct render_objects
 	mesh_t mesh_type;
 };
 
-void drawSimple(render_objects* r_objs,
+void drawDefault(render_objects* r_objs,
+	glm::mat4 world_transform,
 	camera& cam,
 	shader_wrapper sw,
 	light_group* lights);
-void drawDefault(render_objects* r_objs,
+void drawSimple(render_objects* r_objs,
+	glm::mat4 world_transform,
 	camera& cam,
 	shader_wrapper sw,
 	light_group* lights);
@@ -128,68 +130,26 @@ roFree(render_objects* r_objs)
 	}
 }
 
-void
-roTranslate(render_objects* r_objs, glm::mat4 xform)
-{
-	if (r_objs->mesh_type == SIMPLE_MESH) {
-		//
-	}
-
-	else if (r_objs->mesh_type == DEFAULT_MESHES) {
-		//
-	}
-}
-
-void
-roScale(render_object* ro, glm::mat4 xform)
-{
-
-}
-
-void
-roRotate(render_object* ro, glm::mat4 xform)
-{
-
-}
-
+// TODO: update projection * view matrices once per frame here
 void
 roDraw(render_objects* r_objs,
+	glm::mat4 world_transform,
 	camera& cam,
 	shader_wrapper sw,
 	light_group* lights)
 {
-	if (r_objs->mesh_type == SIMPLE_MESH) {
-		drawSimple(r_objs, cam, sw, lights);
-	} else if (r_objs->mesh_type == DEFAULT_MESHES) {
-		drawDefault(r_objs, cam, sw, lights);
-	}
+	if (r_objs->mesh_type == SIMPLE_MESH)
+		drawSimple(r_objs, world_transform, cam, sw, lights);
+	else if (r_objs->mesh_type == DEFAULT_MESHES)
+		drawDefault(r_objs, world_transform, cam, sw, lights);
 }
 
 
 // internal
 
-void
-drawSimple(render_objects* r_objs,
-	camera& cam,
-	shader_wrapper sw,
-	light_group* lights)
-{
-	simple_render_object* ro = (simple_render_object*) r_objs->objects;
-	simple_shader_program* shader =
-		(simple_shader_program*) sw.simple_shader;
-	glUseProgram(shader->program_id);
-	cam.MVP = cam.projection * cam.view * ro->model_transform;
-	glUniformMatrix4fv(shader->MVP_id, 1, GL_FALSE, &cam.MVP[0][0]);
-	enableGLFloatBuffer(ro->vertex_buffer_id, 0);
-	enableGLFloatBuffer(ro->vertex_color_buffer_id, 1);
-	glDrawArrays(ro->draw_mode, 0, ro->vertex_count);
-	glDisableVertexAttribArray(0);
-	glDisableVertexAttribArray(1);
-	glUseProgram(0);
-}
-
 void
 drawDefault(render_objects* r_objs,
+	glm::mat4 world_transform,
 	camera& cam,
 	shader_wrapper sw,
 	light_group* lights)
@@ -223,6 +183,37 @@ drawDefault(render_objects* r_objs,
 	glUseProgram(0);
 }
 
+void
+drawSimple(render_objects* r_objs,
+	glm::mat4 world_transform,
+	camera& cam,
+	shader_wrapper sw,
+	light_group* lights)
+{
+	simple_render_object* ro = (simple_render_object*) r_objs->objects;
+	simple_shader_program* shader =
+		(simple_shader_program*) sw.simple_shader;
+	glUseProgram(shader->program_id);
+	cam.MVP = cam.projection * cam.view * ro->model_transform;
+	glUniformMatrix4fv(
+		shader->world_transform_id, 1, GL_FALSE, &world_transform[0][0]);
+	glUniformMatrix4fv(shader->MVP_id, 1, GL_FALSE, &cam.MVP[0][0]);
+	enableGLFloatBuffer(ro->vertex_buffer_id, 0);
+	enableGLFloatBuffer(ro->vertex_color_buffer_id, 1);
+	glDrawArrays(ro->draw_mode, 0, ro->vertex_count);
+	glDisableVertexAttribArray(0);
+	glDisableVertexAttribArray(1);
+	glUseProgram(0);
+}
+
+inline void
+enableGLFloatBuffer(uint buffer_id, uint location)
+{
+	glEnableVertexAttribArray(location);
+	glBindBuffer(GL_ARRAY_BUFFER, buffer_id);
+	glVertexAttribPointer(location, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
+}
+
 bool
 initGLFloatBuffer(glm::vec3* buffer, uint count, GLuint& buffer_id)
 {
@@ -310,11 +301,3 @@ updateMatrices(default_shader_program* shader,
 		&normal_matrix[0][0]);
 }
 
-inline void
-enableGLFloatBuffer(uint buffer_id, uint location)
-{
-	glEnableVertexAttribArray(location);
-	glBindBuffer(GL_ARRAY_BUFFER, buffer_id);
-	glVertexAttribPointer(location, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
-}
-

src/renderer.cpp

@@ -143,7 +143,9 @@ renRenderFrame(render_state* rs)
 		render_group& rg = rs->render_groups[i];
 
 		for (uint j = 0; j < rg.entity_count; j++) {
-			roDraw(rg.entities[j].render_objs,
+			entity& e = rg.entities[j];
+			roDraw(e.render_objs,
+				e.world_transform,
 				rs->cam,
 				rg.shader,
 				rs->lights);

src/shader_program.cpp

@@ -58,6 +58,11 @@ shaderInitSimple(const char* vertex_code, const char* frag_code)
 	glGenVertexArrays(1, &sp->vertex_array_id);
 	glBindVertexArray(sp->vertex_array_id);
 
+	// assign uniforms
+	sp->world_transform_id =
+		glGetUniformLocation(sp->program_id, "world_transform");
+	sp->MVP_id = glGetUniformLocation(sp->program_id, "MVP");
+
 	if (!checkShaderErrors(sp->program_id)) {
 		glDeleteProgram(sp->program_id);
 		return nullptr;