3dtoys/scene.c

#include "haloo3d/haloo3d.h"
// #include "haloo3d/haloo3dex_easy.h"
#include "haloo3d/haloo3dex_gen.h"
#include "haloo3d/haloo3dex_img.h"
#include "haloo3d/haloo3dex_obj.h"
#include "haloo3d/haloo3dex_print.h"

#include "unigi/main.h"
// #include "unigi/unigi.ext/src/main.c"

#include "camera.h"
#include "resources/flower.h"

#include <stdlib.h>
#include <time.h>

#define DOLIGHTING
// #define FASTTRIS

// IDK you probably have to change this based on your display.
// Maybe there's a way to fix this?
#define UNIGIBITDEPTH 0
#define TARGETFPS 60

#define DITHERSTART 100
#define DITHEREND 101
#define PCTSTART 100

#define WIDTH 640
#define HEIGHT 480
#define ASPECT ((float)WIDTH / HEIGHT)
#define FOV 90.0
#define NEARCLIP 0.01
#define FARCLIP 100.0
#define LIGHTANG -MPI / 4.0
#define MINLIGHT 0.25
#define SKYSCALE 30
#define AVGWEIGHT 0.85

// this is the number of DYNAMIC objects..
#define NUMOBJECTS 4
#define NUMFLOWERS 300
#define PLANESIZE 61
#define FLOWERIND (NUMOBJECTS - 1)
#define NUMINSTANCES (NUMOBJECTS - 1 + NUMFLOWERS)
#define MAXCAM 1200

// #ifdef FASTTRIS
// #define WBUFCLEAR FARCLIP
// #define TRIFUNC haloo3d_texturedtriangle_fast
// #else
// #define WBUFCLEAR 0
// #define TRIFUNC haloo3d_texturedtriangle
// #endif

#define CALCTIME(thistime, start, end, sum)                                    \
  thistime = 1000.0 * (float)(end - start) / CLOCKS_PER_SEC;                   \
  if (sum == 0)                                                                \
    sum = thistime;                                                            \
  sum = AVGWEIGHT * sum + (1 - AVGWEIGHT) * thistime;

uint16_t redflower[64] = H3D_FLOWER(0xFE55, 0xF6C4, 0xFFE0, 0xFD44, 0xF492);

int main(int argc, char **argv) {

  if (argc != 4) {
    dieerr("You must pass in the following:\n- obj file .obj\n- texture file "
           ".ppm\n- camera file (xofs yofs zofs yawdeg pitchdeg)\n");
  }

  // Load the junk + generate stuff
  haloo3d_obj models[NUMOBJECTS];
  haloo3d_fb textures[NUMOBJECTS];
  haloo3d_obj_loadfile(models, argv[1]);
  haloo3d_img_loadppmfile(textures, argv[2]);
  haloo3d_fb_init_tex(textures + 1, 32, 32);
  haloo3d_apply_vgradient(textures + 1, 0xF001, 0xF44F);
  haloo3d_gen_skybox(models + 1);
  uint16_t checkcols[2] = {0xF0A0, 0xF270};
  haloo3d_fb_init_tex(textures + 2, 32, 32);
  haloo3d_apply_alternating(textures + 2, checkcols, 2);
  haloo3d_gen_sloped(models + 2, PLANESIZE, 1.0, 1.25);
  haloo3d_fb_init_tex(textures + 3, 8, 8);
  memcpy(textures[3].buffer, redflower, sizeof(uint16_t) * 64);
  haloo3d_gen_crossquad(models + 3, textures + 3,
                        (struct vec3){.x = 0, .y = 0, .z = 0});
  eprintf("Initialized models + textures");

  camset cams[MAXCAM];
  int numcams = readcam(cams, MAXCAM, argv[3]);

  // Create the camera matrix, which DOES change. In this one,
  // we move the camera instead of the model
  haloo3d_camera camera;
  haloo3d_camera_init(&camera);

  // Create the perspective matrix, which doesn't change
  mfloat_t perspective[MAT4_SIZE];
  haloo3d_perspective(perspective, FOV, ASPECT, NEARCLIP, FARCLIP);

  // Lighting. Note that for performance, the lighting is always calculated
  // against the base model, and is thus not realistic if the object rotates in
  // the world. This can be fixed easily, since each object gets its own
  // lighting vector, which can easily be rotated in the opposite direction of
  // the model
  struct vec3 light;
  vec3(light.v, 0, -MCOS(LIGHTANG), MSIN(LIGHTANG));

  int totalfaces = 0;
  int totalverts = 0;
  haloo3d_obj_instance objects[NUMINSTANCES];
  for (int i = 0; i < NUMINSTANCES; i++) {
    if (i < FLOWERIND) {
      haloo3d_objin_init(objects + i, models + i, textures + i);
    } else { // Setup the flowers
      haloo3d_objin_init(objects + i, models + FLOWERIND, textures + FLOWERIND);
      objects[i].cullbackface = 0;
      vec3(objects[i].scale.v, 0.5, 0.5, 0.5);
      int rvi = rand() % models[2].numvertices;
      vec3_assign(objects[i].pos.v, models[2].vertices[rvi].v);
      objects[i].pos.y += 0.5;
    }
    totalfaces += objects[i].model->numfaces;
    totalverts += objects[i].model->numvertices;
  }
#ifdef DOLIGHTING
  objects[0].lighting = &light;
  objects[2].lighting = &light;
#endif
  objects[0].pos.y = 1;
  vec3(objects[1].scale.v, SKYSCALE, SKYSCALE, SKYSCALE);
  eprintf("Initialized object instances\n");

  // Now we create a framebuffer to draw the triangle into
  haloo3d_fb fb;
  haloo3d_fb_init(&fb, WIDTH, HEIGHT);

  unigi_type_event event;
  unigi_type_resolution res;
  res.width = WIDTH;
  res.height = HEIGHT;
  res.depth = UNIGIBITDEPTH;

  // Printing to screen needs tracking
  haloo3d_print_tracker t;
  char printbuf[8192];
  haloo3d_print_initdefault(&t, printbuf, sizeof(printbuf));
  t.fb = &fb;
  // t.logprints = 1;

  // Storage stuff
  mfloat_t matrix3d[MAT4_SIZE], matrixcam[MAT4_SIZE], matrixscreen[MAT4_SIZE],
      matrixmodel[MAT4_SIZE];
  haloo3d_facef outfaces[H3D_FACEF_MAXCLIP];
  struct vec3 tmp1;
  haloo3d_facef face, baseface;
  struct vec4 *vert_precalc;
  mallocordie(vert_precalc, sizeof(struct vec4) * H3D_OBJ_MAXVERTICES);
  clock_t begin, end;
  // Measured in milliseconds
  float sumframe = 0, lastframe = 0;
  float msperframe = 1000.0 / TARGETFPS;
  int totaldrawn = 0;

  // Setup render config with defaults. We won't necessarily use all features
  // present in this
  haloo3d_trirender rendersettings;
  haloo3d_trirender_init(&rendersettings);
  rendersettings.ditherfar = DITHEREND;
  rendersettings.ditherclose = DITHERSTART;
  rendersettings.pctminsize = PCTSTART;

  eprintf("Scene has %d tris, %d verts\n", totalfaces, totalverts);

  // Init unigi system
  sprintf(printbuf, "scene.exe - %s %s %s", argv[1], argv[2], argv[3]);
  unigi_graphics_init();
  unigi_window_create(res, printbuf);

  // -----------------------------------
  //     Actual rendering
  // -----------------------------------

  int cami = 0;

  while (1) {
    begin = clock();

    unigi_event_get(&event);
    if (event.type == unigi_enum_event_input_keyboard) {
      exit(0);
    }

    totaldrawn = 0;

    haloo3d_print_refresh(&t);
    camera.pos.x = cams[cami].xofs;
    camera.pos.y = cams[cami].yofs;
    camera.pos.z = cams[cami].zofs;
    camera.yaw = cams[cami].yaw;
    camera.pitch = cams[cami].pitch + MPI_2;

    // REMEMBER TO CLEAR DEPTH BUFFER
    haloo3d_fb_cleardepth(&fb);

    // Screen matrix calc. We multiply the modelview matrix with this later
    haloo3d_camera_calclook(&camera, matrixcam);
    mat4_inverse(matrixcam, matrixcam);
    mat4_multiply(matrixscreen, perspective, matrixcam);

    // eprintf("BEGIN ITERATE OBJECTS\n");

    // Iterate over objects
    for (int i = 0; i < NUMINSTANCES; i++) {
      //  Setup final model matrix and the precalced vertices
      vec3_add(tmp1.v, objects[i].pos.v, objects[i].lookvec.v);
      haloo3d_my_lookat(matrixmodel, objects[i].pos.v, tmp1.v, camera.up.v);
      haloo3d_mat4_scalev(matrixmodel, objects[i].scale.v);
      mat4_multiply(matrix3d, matrixscreen, matrixmodel);
      haloo3d_precalc_verts(objects[i].model, matrix3d, vert_precalc);
      rendersettings.texture = objects[i].texture;
      //  Iterate over object faces
      for (int fi = 0; fi < objects[i].model->numfaces; fi++) {
        // Copy face values out of precalc array and clip them
        haloo3d_make_facef(objects[i].model->faces[fi], vert_precalc,
                           objects[i].model->vtexture, face);
        int tris = haloo3d_facef_clip(face, outfaces);
        if (tris > 0) {
          // haloo3d_getdither4x4(float dither, uint8_t *buf)
          //  haloo3d_easy_calcdither4x4(&rendersettings, face, DITHERSTART,
          //                             DITHEREND);
          rendersettings.intensity = 1.0;
          if (objects[i].lighting) {
            haloo3d_obj_facef(objects[i].model, objects[i].model->faces[fi],
                              baseface);
            rendersettings.intensity =
                haloo3d_calc_light(objects[i].lighting->v, MINLIGHT, baseface);
          }
        }
        for (int ti = 0; ti < tris; ti++) {
          int backface = !haloo3d_facef_finalize(outfaces[ti]);
          if (objects[i].cullbackface && backface) {
            continue;
          }
          totaldrawn++;
          //   We still have to convert the points into the view
          haloo3d_facef_viewport_into(outfaces[ti], WIDTH, HEIGHT);
          // eprintf("RENDER TRI\n");
          haloo3d_triangle(&fb, &rendersettings, outfaces[ti]);
        }
      }
    }
    // eprintf("OBJECTS COMPLETE\n");

    haloo3d_print(&t, "Last frame: %05.2f (%05.2f)\nTris: %d / %d\nVerts: %d\n",
                  lastframe, sumframe, totaldrawn, totalfaces, totalverts);

    unigi_graphics_blit(0, (unigi_type_color *)fb.buffer,
                        res.width * res.height);
    unigi_graphics_flush();

    cami = (cami + 1) % numcams;

    end = clock();
    CALCTIME(lastframe, begin, end, sumframe);

    float waittime = msperframe - lastframe;
    if (waittime > 0) {
      unigi_time_sleep(waittime * unigi_time_clocks_per_s / 1000);
    }
  }

  // Free after loop
  for (int i = 0; i < NUMOBJECTS; i++) {
    haloo3d_obj_free(models + i);
    haloo3d_fb_free(textures + i);
  }
}