maybe we should be able to rotate entities?

examples/assimp_loading/main.cpp

@@ -12,6 +12,11 @@
 void
 doFrameCallback(render_state* rs)
 {
+	// NOTE: rotate mesh on z-axis every frame
+	entity& e = rs->render_groups[0].entities[0];
+	static float angle = (float) M_PI_2 / 33;
+	static glm::vec3 axis(0, 0, 1);
+	entRotate(e, angle, axis);
 }
 
 // TODO: remove/refactor this when we get animation working
@@ -51,12 +56,7 @@ main()
 	logDebugAnimationInfo("../data/spaceship.glb");
 
 	if (entInitModel(spaceship, "../data/spaceship.glb")) {
-		// TODO: this should be handled in entInit
-		entSetWorldPosition(spaceship, glm::vec3(0, 0, 0));
 		entScale(spaceship, glm::vec3(20, 20, 20));
-		// TODO: implement setting rotation from entity
-		//spaceship.rotation = glm::vec4(0, 0, 0, 0);
-
 		renDoRenderLoop(rs, 60, doFrameCallback);
 	} else {
 		LOG(Error) << "Error initializing entity, exiting\n";

examples/simple_mesh/main.cpp

@@ -6,6 +6,16 @@
 #include "renderer.h"
 
 
+void
+doFrameCallback(render_state* rs)
+{
+	// NOTE: rotate mesh on z-axis every frame
+	entity& e = rs->render_groups[0].entities[0];
+	static float angle = (float) M_PI_2 / 33;
+	static glm::vec3 axis(0, 0, 1);
+	entRotate(e, angle, axis);
+}
+
 int
 main()
 {
@@ -23,7 +33,7 @@ main()
 
 	entity& e = rs->render_groups[0].entities[0];
 	// manually construct a simple mesh
-	simple_mesh mesh = {0};
+	simple_mesh mesh = { glm::mat4(1), 0, 0, 0 };
 	mesh.num_vertices = 4;
 	mesh.vertices = UTIL_ALLOC(mesh.num_vertices, glm::vec3);
 	mesh.vertices[0] = glm::vec3(-200, 0, 200);
@@ -47,7 +57,7 @@ main()
 		glm::vec3(0,0,1)
 	);
 
-	renDoRenderLoop(rs);
+	renDoRenderLoop(rs, 60, doFrameCallback);
 
 	renShutdown(rs);
 	return 0;

include/animation.h

@@ -4,7 +4,6 @@
 #include <glm/glm.hpp>
 
 #include "util.h"
-//#include "render_object.h"
 
 
 struct render_object;

include/entity.h

@@ -13,10 +13,12 @@ enum mesh_group_type
 	SIMPLE_MESH = 1
 };
 
+// TODO: having a separate code path for each shader is annoying and error
+// 	prone. could try using opaque pointers at high level (renderer, entity),
+// 	and then cast to the appropriate render_object/mesh/shader type in the lower
+// 	level functions based on the mesh_type property
 struct entity
 {
-	glm::mat4 world_transform;
-
 	mesh_group_type mesh_type;
 
 	simple_mesh mesh;
@@ -42,3 +44,4 @@ void entTranslate(entity& e, glm::vec3 v);
 
 void entScale(entity& e, glm::vec3 v);
 
+void entRotate(entity& e, float angle, glm::vec3 axis);

include/mesh.h

@@ -36,6 +36,7 @@ struct mesh_group
 
 struct simple_mesh
 {
+	glm::mat4 model_transform;
 	glm::vec3* vertices;
 	glm::vec3* vert_colors;
 	uint num_vertices;

include/render_object.h

@@ -24,6 +24,7 @@ struct render_object
 
 struct simple_render_object
 {
+	glm::mat4 model_transform;
 	GLuint vertex_buffer_id;
 	GLuint vertex_color_buffer_id;
 	uint vertex_count;

src/entity.cpp

@@ -43,6 +43,7 @@ entInitSimpleMesh(entity& e, simple_mesh& mesh, GLenum draw_mode)
 	e.mesh_type = SIMPLE_MESH;
 	e.draw_mode = draw_mode;
 
+	e.mesh.model_transform = mesh.model_transform;
 	e.mesh.num_vertices = mesh.num_vertices;
 	e.mesh.vertices = UTIL_ALLOC(mesh.num_vertices, glm::vec3);
 	e.mesh.vert_colors = UTIL_ALLOC(mesh.num_vertices, glm::vec3);
@@ -81,25 +82,70 @@ 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;
+#endif
+	if (e.mesh_type == SIMPLE_MESH) {
+		//
+	}
+
+	if (e.mesh_type == DEFAULT_MESHES) {
+		//
+	}
 }
 
 void
 entTranslate(entity& e, glm::vec3 v)
 {
+#if 0
 	e.world_transform = glm::translate(e.world_transform, v);
+#endif
+	if (e.mesh_type == SIMPLE_MESH) {
+		//
+	}
+
+	if (e.mesh_type == DEFAULT_MESHES) {
+		//
+	}
 }
 
 void
 entScale(entity& e, glm::vec3 v)
 {
+#if 0
 	e.world_transform = glm::scale(e.world_transform, v);
+#endif
+	if (e.mesh_type == SIMPLE_MESH) {
+		//
+	}
 
-	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);
+	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);
+		}
+	}
+
+}
+
+void
+entRotate(entity& e, float angle, glm::vec3 axis)
+{
+#if 0
+	e.world_transform = glm::rotate(e.world_transform, angle, axis);
+#endif
+	if (e.mesh_type == SIMPLE_MESH) {
+		e.simple_ro.model_transform =
+			glm::rotate(e.simple_ro.model_transform, 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);
+		}
 	}
 }
 
@@ -109,7 +155,6 @@ entScale(entity& e, glm::vec3 v)
 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

@@ -55,6 +55,7 @@ roInitSimpleMesh(simple_mesh& mesh_in, simple_render_object& ro_out)
 			mesh_in.num_vertices,
 			ro_out.vertex_color_buffer_id))
 	{
+		ro_out.model_transform = mesh_in.model_transform;
 		ro_out.vertex_count = mesh_in.num_vertices;
 		return true;
 	}
@@ -116,6 +117,7 @@ roDrawSimple(simple_render_object& ro,
 	GLenum draw_mode)
 {
 	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);