begin update with new libTangerine interface

ext/tangerine

@@ -1 +1 @@
-Subproject commit 7ac0e7be52672d729b0e79aea639b2f4d44e07f1
+Subproject commit 0821166a74a1db9e31d39cadd2eba47953a31a2d

src/main.cpp

@@ -5,11 +5,8 @@
 #include <SDL2/SDL.h>
 #include <glm/glm.hpp>
 
-#include "dumbLog.h"
 #include "input.h"
-#include "mesh.h"
+#include "tangerine.h"
-#include "renderer.h"
-#include "util.h"
 
 #include "gooey.h"
 #include "orbits.h"
@@ -17,24 +14,36 @@
 
 const double SCALING = 0.001;
 static system_2body g_sys = {0};
+static MemoryArena* g_arena = nullptr;
 
 
-simple_mesh*
+Mesh*
-constructEllipseMesh(ellipse_3d& e3d, glm::vec3 vertex_color)
+constructEllipseMesh(MemoryArena* arena, ellipse_3d& e3d, vec3 vertex_color)
 {
-	simple_mesh* sm = meInitMesh(e3d.vert_count);
+	// TODO: would be nice to add a helper in libTangerine to init a Mesh/Model
+	// 	from code
+	Mesh* m = ARENA_ALLOC(arena, Mesh, 1);
+	m->num_vertices = e3d.vert_count;
+	m->num_indices = e3d.vert_count;
+	m->vertices = ARENA_ALLOC(arena, vec3, e3d.vert_count);
+	m->colors = ARENA_ALLOC(arena, vec3, e3d.vert_count);
+	m->indices = ARENA_ALLOC(arena, u16, e3d.vert_count);
+	m->xform = ARENA_ALLOC(arena, mat4, 1);
+	*m->xform = mat4(1);
 
 	for (uint i = 0; i < e3d.vert_count; i++) {
-		sm->vertices[i] = e3d.vertices[i];
+		m->vertices[i] = e3d.vertices[i];
-		sm->vert_colors[i] = vertex_color;
+		m->colors[i] = vertex_color;
+		m->indices[i] = i;
 	}
 
-	return sm;
+	return m;
 }
 
-simple_mesh*
+Mesh*
 constructCircleMesh(float r, uint vert_count, glm::vec3 vertex_color)
 {
+#if 0
 	simple_mesh* sm = meInitMesh(vert_count);
 	float angle = (float) M_PI * 2 / vert_count;
 	r = r / SCALING;
@@ -45,11 +54,14 @@ constructCircleMesh(float r, uint vert_count, glm::vec3 vertex_color)
 	}
 
 	return sm;
+#endif
+	return nullptr;
 }
 
-simple_mesh*
+Mesh*
 createSatelliteMesh()
 {
+#if 0
 	simple_mesh* sm = meInitMesh(3);
 	glm::vec3 s_color(255, 0, 0);
 	sm->vertices[0] = glm::vec3(0, 1 / SCALING, 0);
@@ -60,6 +72,8 @@ createSatelliteMesh()
 	sm->vert_colors[2] = s_color;
 
 	return sm;
+#endif
+	return nullptr;
 }
 
 void
@@ -73,32 +87,35 @@ updateSatelliteModel(const system_2body& sys, satellite& sat)
 }
 
 void
-updateSatelliteEntity(entity& ent, const satellite& sat)
+updateSatelliteEntity(Entity& ent, const satellite& sat)
 {
+#if 0
 	// TODO: decouple framerate from time_step
 	const static glm::mat4 xform =
 		glm::rotate(glm::mat4(1.0), (float) M_PI_2, glm::vec3(1, 0, 0));
 	const glm::vec3& v = sat.position;
 	entSetWorldPosition(ent, xform * glm::vec4(v.x, v.y, v.z, 1));
+#endif
 }
 
 // NOTE: use ellipseValidate(ep) before calling to avoid failing assertions
 void
-updateOrbit(system_2body sys, entity& ellipse_entity)
+updateOrbit(system_2body sys, Entity& ellipse_entity)
 {
+#if 0
 	ellipse3DUpdate(sys.ep, sys.e3d);
 
 	for (uint i = 0; i < sys.e3d.vert_count; i++)
 		ellipse_entity.mesh->vertices[i] = sys.e3d.vertices[i];
 
 	entUpdateSimpleMesh(ellipse_entity, ellipse_entity.mesh, GL_LINE_LOOP);
+#endif
 }
 
 void
-preFrameCallback(render_state* rs)
+preFrameCallback(RenderState* rs)
 {
-	// handle input
+	static InputState is = {};
-	static input_state is = {};
 	SDL_Event e;
 	bool gooey_wants = false;
 
@@ -112,59 +129,89 @@ preFrameCallback(render_state* rs)
 }
 
 void
-postFrameCallback(render_state* rs)
+postFrameCallback(RenderState* rs)
 {
-	gooDraw(rs->handles->window, g_sys);
+	gooDraw(rs->handles.window, g_sys);
 	g_sys.ep = ellipseInitAE(g_sys.ep.a, g_sys.ep.e);
+#if 0
 	entity& ellipse_entity = rs->render_groups[0].entities[0];
 	updateOrbit(g_sys, ellipse_entity);
 	updateSatelliteModel(g_sys, g_sys.sat);
 	updateSatelliteEntity(rs->render_groups[0].entities[2], g_sys.sat);
+#endif
+}
+
+Entity*
+initEllipseEntity(RenderState* rs,
+	const ellipse_parameters& ep,
+	u32 num_vertices)
+{
+	ShaderProgram* shader = getShaderByName("colored_vertices", rs->gl_ctx);
+	RenderGroup* rg = getFreeRenderGroup(rs);
+	assert(shader && rg);
+	initRenderGroup(rg, rs->rg_arena, shader, 16, "ellipse_rg");
+	Entity* e = getFreeEntity(rg);
+	assert(e);
+
+	g_sys.e3d = ellipseInit3D(g_sys.ep, num_vertices);
+	Mesh* m = constructEllipseMesh(rs->assets.arena,
+									g_sys.e3d,
+									vec3(255, 0, 255));
+	Model* mdl = ARENA_ALLOC(rs->assets.arena, Model, 1);
+	mdl->num_meshes = 1;
+	mdl->meshes = m;
+	initEntity(e, rs->gl_ctx,
+				rs->rg_arena,
+				mdl,
+				shader->num_vertex_attribs,
+				shader->attrib_mappings,
+				"ellipse 01",
+				GL_LINE_LOOP);
+
+	return e;
 }
 
 int
 main()
 {
-	render_state* rs = renInit("orbital shipping",
+	RenderState* rs = initRenderState("orbital shipping",
-		glm::vec2(1280, 800),
+		uvec2(1600, 900),
-		SDL_INIT_TIMER);
+		SDL_INIT_VIDEO | SDL_INIT_TIMER);
 
 	if (rs == nullptr) {
 		LOG(Error) << "Error Initialzing renderer\n";
 		return 1;
 	}
 
-	if (!gooInit(rs->handles->window, rs->handles->glContext)) {
+	if (!gooInit(rs->handles.window, rs->handles.sdl_gl_ctx)) {
 		LOG(Error) << "Error Initialzing gooey\n";
 		return 1;
 	}
 
-	glm::vec2 dims = renGetWindowDims(rs);
+	vec2 dims = rs->window_dims;
 	cameraInitPerspective(
-		rs->cam,
+		rs->camera,
-		glm::vec3(0, -75 / SCALING, 0),
+		vec3(0, -75 / SCALING, 0),
-		glm::vec3(0, 0, 0),
+		vec3(0, 0, 0),
-		glm::vec3(0,0,1),
+		vec3(0,0,1),
 		dims.x / dims.y
 	);
 
+	GLBuffer* xform_ubo = getUBOByName(rs->gl_ctx, "matrices");
+	assert(xform_ubo != nullptr);
+	updateGLBuffer(xform_ubo, &rs->camera->xforms);
+
 	double a = 26564.5;		// NOTE: semi-major axis in km
 	double e = 0.7411;		// NOTE: eccentricity
 	double mu = 398601.68;	// NOTE: gravitational parameter
 	double r = 6378;		// NOTE: body radius in km
 	g_sys = systemInit(gravBodyInit(mu, r), orbitInit(a, e));
 
-	// TODO: (renderer) this needs to be more convenient
+	g_arena = arenaInit(16);
-	shader_wrapper sw = { SIMPLE_SHADER, nullptr, rs->simple_shader };
+	Entity* ellipse_entity = initEllipseEntity(rs, g_sys.ep, 256);
-	rs->render_groups = renAllocateGroup(3, sw);
+	setEntityPosition(ellipse_entity, vec3(0, 0, 0));
-	rs->render_group_count = 1;
+	rotateEntity(ellipse_entity, vec3(1, 0, 0), (float) M_PI / 2);
-
+#if 0
-	entity& ellipse_entity = rs->render_groups[0].entities[0];
-	g_sys.e3d = ellipseInit3D(g_sys.ep, 256);
-	simple_mesh* sm = constructEllipseMesh(g_sys.e3d, glm::vec3(255, 0, 255));
-	entInitMesh(ellipse_entity, sm, GL_LINE_LOOP);
-	entRotate(ellipse_entity, (float) M_PI_2, glm::vec3(1, 0, 0));
-
 	entity& planet_entity = rs->render_groups[0].entities[1];
 	sm = constructCircleMesh(3, 24, glm::vec3(255, 255, 0));
 	entInitMesh(planet_entity, sm, GL_LINE_LOOP);
@@ -175,11 +222,12 @@ main()
 	entInitMesh(satellite_entity, sm, GL_TRIANGLES);
 	entRotate(satellite_entity, (float) M_PI_2, glm::vec3(1, 0, 0));
 	entSetWorldPosition(satellite_entity, g_sys.e3d.vertices[0]);
-
+#endif
-	renDoRenderLoop(rs, 60 , preFrameCallback, postFrameCallback);
+	doRenderLoop(rs, 60, preFrameCallback, postFrameCallback);
 
 	gooFree();
-	renShutdown(rs);
+	freeRenderState(rs);
+
 	return 0;
 }