diff --git a/ext/tangerine b/ext/tangerine index 7ac0e7b..0821166 160000 --- a/ext/tangerine +++ b/ext/tangerine @@ -1 +1 @@ -Subproject commit 7ac0e7be52672d729b0e79aea639b2f4d44e07f1 +Subproject commit 0821166a74a1db9e31d39cadd2eba47953a31a2d diff --git a/src/main.cpp b/src/main.cpp index cc67524..06b36e6 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -5,11 +5,8 @@ #include #include -#include "dumbLog.h" #include "input.h" -#include "mesh.h" -#include "renderer.h" -#include "util.h" +#include "tangerine.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* -constructEllipseMesh(ellipse_3d& e3d, glm::vec3 vertex_color) +Mesh* +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]; - sm->vert_colors[i] = vertex_color; + m->vertices[i] = e3d.vertices[i]; + 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 input_state is = {}; + static InputState 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", - glm::vec2(1280, 800), - SDL_INIT_TIMER); + RenderState* rs = initRenderState("orbital shipping", + uvec2(1600, 900), + 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, - glm::vec3(0, -75 / SCALING, 0), - glm::vec3(0, 0, 0), - glm::vec3(0,0,1), + rs->camera, + vec3(0, -75 / SCALING, 0), + vec3(0, 0, 0), + 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 - shader_wrapper sw = { SIMPLE_SHADER, nullptr, rs->simple_shader }; - rs->render_groups = renAllocateGroup(3, sw); - rs->render_group_count = 1; - - 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)); - + g_arena = arenaInit(16); + Entity* ellipse_entity = initEllipseEntity(rs, g_sys.ep, 256); + setEntityPosition(ellipse_entity, vec3(0, 0, 0)); + rotateEntity(ellipse_entity, vec3(1, 0, 0), (float) M_PI / 2); +#if 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]); - - renDoRenderLoop(rs, 60 , preFrameCallback, postFrameCallback); +#endif + doRenderLoop(rs, 60, preFrameCallback, postFrameCallback); gooFree(); - renShutdown(rs); + freeRenderState(rs); + return 0; }