Fix lighting demo

Author: Tiffany Bennett

src/lighting/Tupfile

@@ -1,4 +1,4 @@
 include_rules
 
-: foreach *.c |> !cc |>
+: foreach *.cpp |> !cxx |>
 : *.o |> !ld |> $(TOP)/lighting$(PROG_SUFFIX)

src/lighting/comp.c renamed to src/lighting/comp.cpp

@@ -1,3 +1,6 @@
+#include "comp.h"
+
+extern "C" {
 #include "graphics/context.h"
 #include "graphics/floatspace.h"
 #include "graphics/material.h"
@@ -6,6 +9,7 @@
 #include "graphics/tex.h"
 #include "math/matrix.h"
 #include "util/log.h"
+}
 
 #include "tgl/tgl.h"
 
@@ -158,51 +162,34 @@ enum {
     TEX_EMISSION,
 };
 
-typedef struct ilG_computer {
-    ilG_renderman *rm;
-    ilG_matid mat;
-    tgl_vao vao;
-    GLuint v_vbo, n_vbo, t_vbo;
-    GLuint mvp_loc, imt_loc;
-    ilG_tex tex_albedo, tex_normal, tex_refraction, tex_emission;
-} ilG_computer;
-
-static void comp_draw(void *obj, ilG_rendid id, il_mat **mats, const unsigned *objects, unsigned num_mats)
+void Computer::draw(il_mat mvp, il_mat imt)
 {
-    (void)id, (void)objects;
-    ilG_computer *self = obj;
-    ilG_material *mat = ilG_renderman_findMaterial(self->rm, self->mat);
+    ilG_material *mat = ilG_renderman_findMaterial(rm, this->mat);
 
-    ilG_tex_bind(&self->tex_albedo);
-    ilG_tex_bind(&self->tex_normal);
-    ilG_tex_bind(&self->tex_refraction);
-    ilG_tex_bind(&self->tex_emission);
+    ilG_tex_bind(&tex_albedo);
+    ilG_tex_bind(&tex_normal);
+    ilG_tex_bind(&tex_refraction);
+    ilG_tex_bind(&tex_emission);
 
     ilG_material_bind(mat);
-    tgl_vao_bind(&self->vao);
-    for (unsigned i = 0; i < num_mats; i++) {
-        ilG_material_bindMatrix(mat, self->mvp_loc, mats[0][i]);
-        ilG_material_bindMatrix(mat, self->imt_loc, mats[1][i]);
-        glDrawArrays(GL_TRIANGLES, 0, 36);
-    }
+    tgl_vao_bind(&vao);
+    ilG_material_bindMatrix(mat, mvp_loc, mvp);
+    ilG_material_bindMatrix(mat, imt_loc, imt);
+    glDrawArrays(GL_TRIANGLES, 0, 36);
 }
 
-static void comp_free(void *obj)
+void Computer::free()
 {
-    ilG_computer *self = obj;
-    ilG_renderman_delMaterial(self->rm, self->mat);
-    tgl_vao_free(&self->vao);
-    glDeleteBuffers(1, &self->v_vbo);
-    glDeleteBuffers(1, &self->n_vbo);
-    glDeleteBuffers(1, &self->t_vbo);
-    free(self);
+    ilG_renderman_delMaterial(rm, mat);
+    tgl_vao_free(&vao);
+    glDeleteBuffers(1, &v_vbo);
+    glDeleteBuffers(1, &n_vbo);
+    glDeleteBuffers(1, &t_vbo);
 }
 
-static bool comp_build(void *obj, ilG_rendid id, ilG_renderman *rm, ilG_buildresult *out)
+bool Computer::build(ilG_renderman *rm, char **error)
 {
-    (void)id;
-    ilG_computer *self = obj;
-    self->rm = rm;
+    this->rm = rm;
 
     ilG_material m;
     ilG_material_init(&m);
@@ -219,36 +206,36 @@ static bool comp_build(void *obj, ilG_rendid id, ilG_renderman *rm, ilG_buildres
     ilG_material_textureUnit(&m, TEX_NORMAL,          "tex_Normal");
     ilG_material_textureUnit(&m, TEX_REFRACTION,      "tex_Reflect");
     ilG_material_textureUnit(&m, TEX_EMISSION,        "tex_Emission");
-    if (!ilG_renderman_addMaterialFromFile(rm, m, "comp.vert", "comp.frag", &self->mat, &out->error)) {
+    if (!ilG_renderman_addMaterialFromFile(rm, m, "comp.vert", "comp.frag", &mat, error)) {
         return false;
     }
-    ilG_material *mat = ilG_renderman_findMaterial(rm, self->mat);
-    self->mvp_loc = ilG_material_getLoc(mat, "mvp");
-    self->imt_loc = ilG_material_getLoc(mat, "imt");
+    ilG_material *mat = ilG_renderman_findMaterial(rm, this->mat);
+    mvp_loc = ilG_material_getLoc(mat, "mvp");
+    imt_loc = ilG_material_getLoc(mat, "imt");
 
-    tgl_vao_init(&self->vao);
-    tgl_vao_bind(&self->vao);
-    glGenBuffers(1, &self->v_vbo);
-    glBindBuffer(GL_ARRAY_BUFFER, self->v_vbo);
+    tgl_vao_init(&vao);
+    tgl_vao_bind(&vao);
+    glGenBuffers(1, &v_vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, v_vbo);
     glBufferData(GL_ARRAY_BUFFER, sizeof(cube), cube, GL_STATIC_DRAW);
     glVertexAttribPointer(ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, NULL);
     glEnableVertexAttribArray(ATTRIB_POSITION);
-    glGenBuffers(1, &self->n_vbo);
-    glBindBuffer(GL_ARRAY_BUFFER, self->n_vbo);
+    glGenBuffers(1, &n_vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, n_vbo);
     glBufferData(GL_ARRAY_BUFFER, sizeof(cube_n), cube_n, GL_STATIC_DRAW);
     glVertexAttribPointer(ATTRIB_NORMAL, 3, GL_FLOAT, GL_FALSE, 0, NULL);
     glEnableVertexAttribArray(ATTRIB_NORMAL);
-    glGenBuffers(1, &self->t_vbo);
-    glBindBuffer(GL_ARRAY_BUFFER, self->t_vbo);
+    glGenBuffers(1, &t_vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, t_vbo);
     glBufferData(GL_ARRAY_BUFFER, sizeof(cube_t), cube_t, GL_STATIC_DRAW);
     glVertexAttribPointer(ATTRIB_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, NULL);
     glEnableVertexAttribArray(ATTRIB_TEXCOORD);
 
     ilG_tex *texes[4] = {
-        &self->tex_albedo,
-        &self->tex_normal,
-        &self->tex_refraction,
-        &self->tex_emission
+        &tex_albedo,
+        &tex_normal,
+        &tex_refraction,
+        &tex_emission
     };
     static const char *const files[] = {
         "comp1a.png",
@@ -267,20 +254,5 @@ static bool comp_build(void *obj, ilG_rendid id, ilG_renderman *rm, ilG_buildres
         texes[i]->unit = i;
     }
 
-    int *types = calloc(2, sizeof(int));
-    types[0] = ILG_MVP;
-    types[1] = ILG_IMT;
-    out->free = comp_free;
-    out->draw = comp_draw;
-    out->types = types;
-    out->num_types = 2;
-    out->obj = obj;
-    out->name = strdup("Computer");
     return true;
 }
-
-ilG_builder ilG_computer_builder()
-{
-    ilG_computer *self = calloc(1, sizeof(ilG_computer));
-    return ilG_builder_wrap(self, comp_build);
-}

src/lighting/comp.h

@@ -0,0 +1,23 @@
+#ifndef DEMO_COMP_H
+#define DEMO_COMP_H
+
+extern "C" {
+#include "graphics/renderer.h"
+}
+
+class Computer {
+    ilG_renderman *rm;
+    ilG_matid mat;
+    tgl_vao vao;
+    GLuint v_vbo, n_vbo, t_vbo;
+    GLuint mvp_loc, imt_loc;
+    ilG_tex tex_albedo, tex_normal, tex_refraction, tex_emission;
+
+public:
+    void free();
+    bool build(ilG_renderman *rm, char **error);
+    void draw(il_mat mvp, il_mat imt);
+};
+
+
+#endif

src/lighting/lighting.c

@@ -0,0 +1,94 @@
+#include <SDL.h>
+#include <time.h>
+#include <sys/time.h>
+#include <math.h>
+
+#include "Graphics.h"
+#include "comp.h"
+
+extern "C" {
+#include "graphics/transform.h"
+#include "util/log.h"
+}
+
+#ifndef M_PI
+#define M_PI 3.1415926535
+#endif
+
+class ComputerRenderer : public Drawable {
+public:
+    ComputerRenderer(unsigned object, Computer &comp)
+        : object(object), comp(comp) {}
+
+    void draw(Graphics &graphics) override {
+        auto mvp = graphics.objmats(&object, ILG_MVP, 1);
+        auto imt = graphics.objmats(&object, ILG_IMT, 1);
+        comp.draw(mvp.front(), imt.front());
+    }
+
+private:
+    unsigned object;
+    Computer &comp;
+};
+
+int main(int argc, char **argv)
+{
+    demoLoad(argc, argv);
+    auto window = createWindow("Lighting");
+    Graphics graphics(window);
+    Graphics::Flags flags;
+    if (!graphics.init(flags)) {
+        return 1;
+    }
+    Computer comp;
+    char *error;
+    if (!comp.build(graphics.rm, &error)) {
+        il_error("Computer: %s", error);
+        free(error);
+        return 1;
+    }
+    il_pos compp = il_pos_new(&graphics.space);
+    ComputerRenderer compr(compp.id, comp);
+    graphics.drawables.push_back(&compr);
+
+    il_pos_setPosition(&graphics.space.camera, il_vec3_new(0, 0, 20));
+
+    il_pos lightp = il_pos_new(&graphics.space);
+    il_pos_setPosition(&lightp, il_vec3_new(20, 3, 20));
+
+    ilG_light lightl;
+    lightl.color = il_vec3_new(.8*2, .7*2, .2*2);
+    lightl.radius = 50;
+
+    State state;
+
+    unsigned lightp_id = lightp.id;
+    state.sunlight_lights = &lightl;
+    state.sunlight_locs = &lightp_id;
+    state.sunlight_count = 1;
+
+    while (1) {
+        SDL_Event ev;
+        while (SDL_PollEvent(&ev)) {
+            switch (ev.type) {
+            case SDL_QUIT:
+                return 0;
+            }
+        }
+
+        struct timeval ts;
+        gettimeofday(&ts, NULL);
+        int secs = 10;
+        const float dist = 10.0;
+        float delta = ((float)(ts.tv_sec%secs) + ts.tv_usec / 1000000.0) / secs;
+        il_vec3 v;
+        v.x = sinf(delta * M_PI * 2) * dist;
+        v.y = 0;
+        v.z = cosf(delta * M_PI * 2) * dist;
+        il_quat q = il_quat_fromAxisAngle(0, 1, 0, delta * M_PI * 2);
+        il_pos_setPosition(&graphics.space.camera, v);
+        il_pos_setRotation(&graphics.space.camera, q);
+
+        graphics.draw(state);
+    }
+}