tinyrenderer/src/model/render.c

#include "render.h"
#include "shader.h"
#include "utils.h"
#include "vec.h"
#include <math.h>

#define TRIANGLE_VERTICES 3

typedef struct triangle_bbox TriangleBBox;
struct triangle_bbox {
  u64 x0;
  u64 y0;
  u64 x1;
  u64 y1;
};

internal void render_triangle(const Triangle *triangle, const Model *model,
                              ShaderID shader, Render *render,
                              RenderType render_type, Colour colour);
internal void fill_triangle(Render *render, ShaderID shader,
                            V3f vertices[TRIANGLE_VERTICES],
                            V3f normals[TRIANGLE_VERTICES],
                            V2f coordinates[TRIANGLE_VERTICES], Colour colour,
                            const Model *model, RenderType type);
internal TriangleBBox get_triangle_bbox(const Image *img,
                                        V3f vertices[TRIANGLE_VERTICES]);
internal V3f get_barycentric_coords(f32 d00, f32 d01, f32 d11, f32 denom,
                                    const V2i *ab, const V2i *ac,
                                    const V2i *ap);
internal V3f get_viewport_vertex(const V3f *vertex, const Image *img);

bool init_render(Arena *arena, Render *render, u64 width, u64 height) {
  render->img = (Image){.width = width, .height = height};
  if (!init_buffer(arena, &(render->img))) {
    return false;
  }

  render->depth = (Depth){.width = width, .height = height};
  if (!init_buffer(arena, &(render->depth))) {
    return false;
  }

  f32 inf = -INFINITY;
  clear_buffer(&(render->depth), &inf);

  return true;
}

void render_model(const Model *model, Render *render, ShaderID shader,
                  RenderType render_type, Colour colour) {
  Triangle triangle;
  for (u64 i = 0; i < model->triangles->count; ++i) {
    triangle = list_get(model->triangles, i);
    render_triangle(&triangle, model, shader, render, render_type, colour);
  }
}

internal void render_triangle(const Triangle *triangle, const Model *model,
                              ShaderID shader, Render *render,
                              RenderType render_type, Colour colour) {
  Image *img = &(render->img);
  V3f vertices[TRIANGLE_VERTICES] = {
      list_get(model->vertices, triangle->p0),
      list_get(model->vertices, triangle->p1),
      list_get(model->vertices, triangle->p2),
  };
  V3f normals[TRIANGLE_VERTICES] = {
      list_get(model->normals, triangle->n0),
      list_get(model->normals, triangle->n1),
      list_get(model->normals, triangle->n2),
  };
  V2f coordinates[TRIANGLE_VERTICES] = {
      list_get(model->texture_coordinates, triangle->tx0),
      list_get(model->texture_coordinates, triangle->tx1),
      list_get(model->texture_coordinates, triangle->tx2),
  };

  for (u64 i = 0; i < TRIANGLE_VERTICES; ++i) {
    vertices[i] =
        run_vertex_shader(shader, &vertices[i], (Buffer *)&render->img);
  }

  if (render_type == RENDER_TYPE_WIREFRAME) {
    V3f v0, v1;
    u64 x0, y0, x1, y1;
    for (u64 i = 0; i < TRIANGLE_VERTICES; ++i) {
      v0 = vertices[i];
      v1 = vertices[(i + 1) % TRIANGLE_VERTICES];

      draw_line(img, (u64)v0.x, (u64)v0.y, (u64)v1.x, (u64)v1.y, colour);
    }
  } else if (render_type == RENDER_TYPE_FILLED ||
             render_type == RENDER_TYPE_SHADED) {
    fill_triangle(render, shader, vertices, normals, coordinates, colour, model,
                  render_type);
  }
}

internal void fill_triangle(Render *render, ShaderID shader,
                            V3f vertices[TRIANGLE_VERTICES],
                            V3f normals[TRIANGLE_VERTICES],
                            V2f coordinates[TRIANGLE_VERTICES], Colour colour,
                            const Model *model, RenderType type) {
  Image *img = &(render->img);
  Depth *depth = &(render->depth);
  TriangleBBox bbox = get_triangle_bbox(img, vertices);

  V3f v0 = vertices[0];
  V3f v1 = vertices[1];
  V3f v2 = vertices[2];

  V2i ab = V2(V2i, i64, v0.x, v0.y, v1.x, v1.y);
  V2i ac = V2(V2i, i64, v0.x, v0.y, v2.x, v2.y);
  f32 d00 = dot_v2(ab, ab);
  f32 d01 = dot_v2(ab, ac);
  f32 d11 = dot_v2(ac, ac);
  f32 denom = d00 * d11 - d01 * d01;
  V2i ap;
  V3f coords;
  f32 z;
  f32 zbuf;
  f32 px, py, pz;
  V3f position;
  f32 nx, ny, nz;
  V3f normal;
  f32 tx_u, tx_v;
  u64 tx_x, tx_y;
  V2f tex_coords;
  FragmentData data = {0};
  FragmentResult result;

  f32 intensity = 1.0f;

  for (u64 y = bbox.y0; y <= bbox.y1; ++y) {
    for (u64 x = bbox.x0; x <= bbox.x1; ++x) {
      ap = V2(V2i, i64, v0.x, v0.y, x, y);
      coords = get_barycentric_coords(d00, d01, d11, denom, &ab, &ac, &ap);
      if (coords.x < 0.0f || coords.y < 0.0f || coords.x + coords.y > 1.0f) {
        continue;
      }

      z = 0.0f;
      z += v0.z * coords.x + v1.z * coords.y + v2.z * coords.z;
      zbuf = get_pixel(f32, &(render->depth), x, y);

      if (z <= zbuf) {
        continue;
      }

      px = vertices[0].x * coords.x + vertices[1].x * coords.y +
           vertices[2].x * coords.z;
      py = vertices[0].y * coords.x + vertices[1].y * coords.y +
           vertices[2].y * coords.z;
      pz = vertices[0].z * coords.x + vertices[1].z * coords.y +
           vertices[2].z * coords.z;
      position = (V3f){px, py, pz};
      normalise_v3(position);
      data.position = position;

      nx = normals[0].x * coords.x + normals[1].x * coords.y +
           normals[2].x * coords.z;
      ny = normals[0].y * coords.x + normals[1].y * coords.y +
           normals[2].y * coords.z;
      nz = normals[0].z * coords.x + normals[1].z * coords.y +
           normals[2].z * coords.z;
      normal = (V3f){nx, ny, nz};
      data.normal = normal;

      tx_u = coordinates[0].u * coords.x + coordinates[1].u * coords.y +
             coordinates[2].u * coords.z;
      tx_v = coordinates[0].v * coords.x + coordinates[1].v * coords.y +
             coordinates[2].v * coords.z;
      tex_coords = (V2f){tx_u, tx_v};
      data.tex_coords = tex_coords;

      result = run_fragment_shader(shader, &data, &colour, model);
      if (DISCARD_FRAGMENT(result)) {
        continue;
      }

      set_pixel(depth, x, y, &z);
      set_pixel(img, x, y, &result.colour);
    }
  }
}

internal TriangleBBox get_triangle_bbox(const Image *img,
                                        V3f vertices[TRIANGLE_VERTICES]) {
  f32 x0 = min(vertices[0].x, min(vertices[1].x, vertices[2].x));
  f32 x1 = max(vertices[0].x, max(vertices[1].x, vertices[2].x));
  f32 y0 = min(vertices[0].y, min(vertices[1].y, vertices[2].y));
  f32 y1 = max(vertices[0].y, max(vertices[1].y, vertices[2].y));

  return (TriangleBBox){
      .x0 = x0,
      .y0 = y0,
      .x1 = x1,
      .y1 = y1,
  };
}

internal V3f get_barycentric_coords(f32 d00, f32 d01, f32 d11, f32 denom,
                                    const V2i *ab, const V2i *ac,
                                    const V2i *ap) {
  if (denom == 0.0f) {
    return (V3f){-INFINITY, -INFINITY, -INFINITY};
  }

  f32 d20 = dot_v2((*ap), (*ab));
  f32 d21 = dot_v2((*ap), (*ac));

  f32 v = (d11 * d20 - d01 * d21) / denom;
  f32 w = (d00 * d21 - d01 * d20) / denom;
  f32 u = 1.0f - v - w;

  return (V3f){v, w, u};
}

internal V3f get_viewport_vertex(const V3f *vertex, const Image *img) {
  V4f vh = {.x = vertex->x, .y = 0.0f - vertex->y, .z = vertex->z, .w = 1.0f};
  vh = mat4x4_mul_vec4(viewport(vh.x, vh.y, img->width, img->height), vh);
  return project_vec4(vh);
}