poly.cpp

#include "poly.h"
#include "zelda_rtl.h"
#include "variables.h"

void Poly_ClearBuf();
void Poly_LoadFromLut();
void Poly_GetSinCos();
void Poly_ComputeXY();
void Poly_DrawAll();
void Poly_ComputeF();
void Poly_DivideF2();
void Poly_Rasterize_Polygon();
void Poly_Rasterize_Line();
bool Poly_Raster_NextX0();
bool Poly_Raster_NextX1();

static const int8 kPolySinCos[320] = {
  0,   2,   3,   5,   6,   8,   9,  11,  12,  14,  16,  17,  19,  20,  22,  23, 
  24,  26,  27,  29,  30,  32,  33,  34,  36,  37,  38,  39,  41,  42,  43,  44, 
  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  56,  57,  58,  59, 
  59,  60,  60,  61,  61,  62,  62,  62,  63,  63,  63,  64,  64,  64,  64,  64, 
  64,  64,  64,  64,  64,  64,  63,  63,  63,  62,  62,  62,  61,  61,  60,  60, 
  59,  59,  58,  57,  56,  56,  55,  54,  53,  52,  51,  50,  49,  48,  47,  46, 
  45,  44,  43,  42,  41,  39,  38,  37,  36,  34,  33,  32,  30,  29,  27,  26, 
  24,  23,  22,  20,  19,  17,  16,  14,  12,  11,   9,   8,   6,   5,   3,   2, 
  0,  -2,  -3,  -5,  -6,  -8,  -9, -11, -12, -14, -16, -17, -19, -20, -22, -23, 
  -24, -26, -27, -29, -30, -32, -33, -34, -36, -37, -38, -39, -41, -42, -43, -44, 
  -45, -46, -47, -48, -49, -50, -51, -52, -53, -54, -55, -56, -56, -57, -58, -59, 
  -59, -60, -60, -61, -61, -62, -62, -62, -63, -63, -63, -64, -64, -64, -64, -64, 
  -64, -64, -64, -64, -64, -64, -63, -63, -63, -62, -62, -62, -61, -61, -60, -60, 
  -59, -59, -58, -57, -56, -56, -55, -54, -53, -52, -51, -50, -49, -48, -47, -46, 
  -45, -44, -43, -42, -41, -39, -38, -37, -36, -34, -33, -32, -30, -29, -27, -26, 
  -24, -23, -22, -20, -19, -17, -16, -14, -12, -11,  -9,  -8,  -6,  -5,  -3,  -2, 
  0,   2,   3,   5,   6,   8,   9,  11,  12,  14,  16,  17,  19,  20,  22,  23, 
  24,  26,  27,  29,  30,  32,  33,  34,  36,  37,  38,  39,  41,  42,  43,  44, 
  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  56,  57,  58,  59, 
  59,  60,  60,  61,  61,  62,  62,  62,  63,  63,  63,  64,  64,  64,  64,  64, 
};

void Poly_ClearBuf() {
  memset(polyhedral_buffer, 0, 0x800);
}

struct Vertex3 {
  int8 x, y, z;
};

static const Vertex3 kPoly0_Vtx[6] = {
  {  0,  65,   0},
  {  0, -65,   0},
  {  0,   0, -40},
  {-40,   0,   0},
  {  0,   0,  40},
  { 40,   0,   0},
};

static const uint8 kPoly0_Polys[40] = {
  3, 0, 5, 2, 4,
  3, 0, 2, 3, 1,
  3, 0, 3, 4, 2,
  3, 0, 4, 5, 3,
  3, 1, 2, 5, 4,
  3, 1, 3, 2, 1,
  3, 1, 4, 3, 2,
  3, 1, 5, 4, 3,
};

static const Vertex3 kPoly1_Vtx[6] = {
  {  0,  40,  10},
  { 40, -40,  10},
  {-40, -40,  10},
  {  0,  40, -10},
  {-40, -40, -10},
  { 40, -40, -10},
};

static const uint8 kPoly1_Polys[28] = {
  3, 0, 1, 2, 7,
  3, 3, 4, 5, 6,
  4, 0, 3, 5, 1, 5,
  4, 1, 5, 4, 2, 4,
  4, 3, 0, 2, 4, 3,
};

struct PolyConfig {
  uint8 num_vtx, num_poly;
  uint16 vtx_val, polys_val;
  const Vertex3 *vertex;
  const uint8 *poly;
};

static const PolyConfig kPolyConfigs[2] = {
  {6, 8, 0xff98, 0xffaa, kPoly0_Vtx, kPoly0_Polys},
  {6, 5, 0xffd2, 0xffe4, kPoly1_Vtx, kPoly1_Polys},
};

void Poly_LoadFromLut() {
  poly_var1 = poly_config1 * 2 + 0x80;
  poly_tmp0 = poly_which_model * 2;

  const PolyConfig *poly_config = &kPolyConfigs[poly_which_model];
  poly_config_num_vertex = poly_config->num_vtx;
  poly_config_num_polys = poly_config->num_poly;
  poly_fromlut_ptr2 = poly_config->vtx_val;
  poly_fromlut_ptr4 = poly_config->polys_val;
}

void Poly_GetSinCos() {
  poly_sin_a = kPolySinCos[poly_a];
  poly_cos_a = kPolySinCos[poly_a + 64];
  poly_sin_b = kPolySinCos[poly_b];
  poly_cos_b = kPolySinCos[poly_b + 64];
  poly_e0 = (int16)poly_sin_b * (int8)poly_sin_a >> 8 << 2;
  poly_e1 = (int16)poly_cos_b * (int8)poly_cos_a >> 8 << 2;
  poly_e2 = (int16)poly_cos_b * (int8)poly_sin_a >> 8 << 2;
  poly_e3 = (int16)poly_sin_b * (int8)poly_cos_a >> 8 << 2;
}

void Poly_ComputeF() {
  int x = (int8)poly_fromlut_x;
  int y = (int8)poly_fromlut_y;
  int z = (int8)poly_fromlut_z;

  poly_f0 =   (int16)poly_cos_b * z                         - (int16)poly_sin_b * x;
  poly_f1 =   (int16)poly_e0    * z + (int16)poly_cos_a * y + (int16)poly_e2    * x;
  poly_f2 = ((int16)poly_e3 * z >> 8) - ((int16)poly_sin_a * y >> 8) + ((int16)poly_e1 * x >> 8) + poly_var1;
}

uint16 Poly_Divide(uint16 a, uint16 b) {
  poly_tmp1 = sign16(a) ? -a : a;
  poly_tmp0 = b;
  while (poly_tmp0 >= 256)
    poly_tmp0 >>= 1, poly_tmp1 >>= 1;
  int q = poly_tmp1 / poly_tmp0;
  return sign16(a) ? -q : q;
}

void Poly_DivideF2() {
  poly_f0 = Poly_Divide(poly_f0, poly_f2);
  poly_f1 = Poly_Divide(poly_f1, poly_f2);
}

void Poly_ComputeXY() {
  const PolyConfig *poly_config = &kPolyConfigs[poly_which_model];
  const int8 *src = &poly_config->vertex[0].x;
  int i = poly_config_num_vertex;
  src += i * 3;
  do {
    src -= 3, i -= 1;
    poly_fromlut_x = src[2];
    poly_fromlut_y = src[1];
    poly_fromlut_z = src[0];
    Poly_ComputeF();
    Poly_DivideF2();
    poly_arr_x[i] = poly_base_x + poly_f0;
    poly_arr_y[i] = poly_base_y - poly_f1;
  } while (i);
}

int16 Poly_Check_Ordering() {
  int16 a = poly_xy_coords[3] - poly_xy_coords[1];
  poly_tmp0 = a * (int8)(poly_xy_coords[6] - poly_xy_coords[4]);
  a = poly_xy_coords[5] - poly_xy_coords[3];
  poly_tmp0 -= a * (int8)(poly_xy_coords[4] - poly_xy_coords[2]);
  return poly_tmp0;
}

static const uint32 kPoly_RasterColors[16] = {
  0x00, 0xff, 0xff00, 0xffff,
  0xff0000, 0xff00ff, 0xffff00, 0xffffff,
  0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
  0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff,
};

void Poly_SetRasterColor(int c) {
  uint32 v = kPoly_RasterColors[c];
  poly_raster_color0 = v;
  poly_raster_color1 = v >> 16;
}

void Poly_SetColor_Front() {
  uint8 t = poly_which_model ? (poly_config1 >> 5) : 0;
  uint8 a = (poly_tmp0 << (t + 1)) >> 8;
  Poly_SetRasterColor(a <= 1 ? 1 : a >= 7 ? 7 : a);
}

void Poly_Rasterize_Polygon();

void Poly_DrawAll() {
  const PolyConfig *poly_config = &kPolyConfigs[poly_which_model];
  const uint8 *src = poly_config->poly;
  do {
    poly_num_vertex_in_poly = *src++;
    BYTE(poly_tmp0) = poly_num_vertex_in_poly;
    poly_xy_coords[0] = poly_num_vertex_in_poly * 2;

    int i = 1;
    do {
      int j = *src++;
      poly_xy_coords[i + 0] = poly_arr_x[j];
      poly_xy_coords[i + 1] = poly_arr_y[j];
      i += 2;
    } while (--BYTE(poly_tmp0));

    poly_raster_color_config = *src++;
    int order = Poly_Check_Ordering();
    if (order > 0) {
      Poly_SetColor_Front();
      Poly_Rasterize_Polygon();
    }
  } while (--poly_config_num_polys);
}

bool Poly_Raster_NextX0() {
  int i;
  for (;;) {
    if (sign8(--poly_total_num_steps))
      return true;
    i = poly_cur_vertex_idx0 - 2;
    if (i == 0)
      i = poly_xy_coords[0];
    if (poly_xy_coords[i] < poly_y0_cur)
      return true;
    if (poly_xy_coords[i] != poly_y0_cur)
      break;
    poly_x0_cur = poly_xy_coords[i - 1];
    poly_cur_vertex_idx0 = i;
  }
  poly_y0_trig = poly_xy_coords[i];
  poly_x0_target = poly_xy_coords[i - 1];
  poly_cur_vertex_idx0 = i;
  int t = poly_x0_target - poly_x0_cur, u = t;
  if (t < 0)
    t = -t;
  t = ((t & 0xff) << 8) / (uint8)(poly_y0_trig - poly_y0_cur);
  poly_x0_frac = (poly_x0_cur << 8) | 0x80;
  poly_x0_step = (u < 0) ? -t : t;
  return false;
}

bool Poly_Raster_NextX1() {
  int i;
  for (;;) {
    if (sign8(--poly_total_num_steps))
      return true;
    i = poly_cur_vertex_idx1;
    if (i == poly_xy_coords[0])
      i = 0;
    i += 2;
    if (poly_xy_coords[i] < poly_y1_cur)
      return true;
    if (poly_xy_coords[i] != poly_y1_cur)
      break;
    poly_x1_cur = poly_xy_coords[i - 1];
    poly_cur_vertex_idx1 = i;
  }
  poly_y1_trig = poly_xy_coords[i];
  poly_x1_target = poly_xy_coords[i - 1];
  poly_cur_vertex_idx1 = i;
  int t = poly_x1_target - poly_x1_cur, u = t;
  if (t < 0)
    t = -t;
  t = ((t & 0xff) << 8) / (uint8)(poly_y1_trig - poly_y1_cur);
  poly_x1_frac = (poly_x1_cur << 8) | 0x80;
  poly_x1_step = (u < 0) ? -t : t;
  return false;
}

static const uint16 kPoly_LeftSideMask[8] = {0xffff, 0x7f7f, 0x3f3f, 0x1f1f, 0xf0f, 0x707, 0x303, 0x101};
static const uint16 kPoly_RightSideMask[8] = {0x8080, 0xc0c0, 0xe0e0, 0xf0f0, 0xf8f8, 0xfcfc, 0xfefe, 0xffff};

void Poly_Rasterize_Line() {
  uint16 left = kPoly_LeftSideMask[(poly_x0_frac >> 8) & 7];
  uint16 right = kPoly_RightSideMask[(poly_x1_frac >> 8) & 7];
  poly_tmp2 = (poly_x0_frac >> 8) & 0x38;
  int d0 = ((poly_x1_frac >> 8) & 0x38);
  uint16 *ptr = (uint16*)&g_ram[poly_raster_dst_ptr + d0 * 4];
  if ((d0 -= poly_tmp2) == 0) {
    poly_tmp1 = left & right;
    ptr[0] ^= (ptr[0] ^ poly_raster_color0) & poly_tmp1;
    ptr[8] ^= (ptr[8] ^ poly_raster_color1) & poly_tmp1;
    return;
  }
  if (d0 < 0)
    return;
  int n = d0 >> 3;
  ptr[0] ^= (ptr[0] ^ poly_raster_color0) & right;
  ptr[8] ^= (ptr[8] ^ poly_raster_color1) & right;
  ptr -= 0x10;
  while (--n) {
    ptr[0] = poly_raster_color0;
    ptr[8] = poly_raster_color1;
    ptr -= 0x10;
  }
  ptr[0] ^= (ptr[0] ^ poly_raster_color0) & left;
  ptr[8] ^= (ptr[8] ^ poly_raster_color1) & left;
  poly_tmp1 = left, poly_raster_numfull = 0;
}

void Poly_Rasterize_Polygon() {
  int n = poly_xy_coords[0];
  uint8 min_y = poly_xy_coords[n];
  int min_idx = n;
  while (n -= 2) {
    if (poly_xy_coords[n] < min_y)
      min_y = poly_xy_coords[n], min_idx = n;
  }
  poly_raster_dst_ptr = 0xe800 + (((min_y & 0x38) ^ (min_y & 0x20 ? 0x24 : 0)) << 6) + (min_y & 7) * 2;
  poly_cur_vertex_idx0 = poly_cur_vertex_idx1 = min_idx;
  poly_total_num_steps = poly_xy_coords[0] >> 1;
  poly_y0_cur = poly_y1_cur = poly_xy_coords[min_idx];
  poly_x0_cur = poly_x1_cur = poly_xy_coords[min_idx - 1];
  if (Poly_Raster_NextX0() || Poly_Raster_NextX1())
    return;
  for (;;) {
    Poly_Rasterize_Line();
    if (BYTE(poly_raster_dst_ptr) != 0xe) {
      poly_raster_dst_ptr += 2;
    } else {
      uint8 a = HIBYTE(poly_raster_dst_ptr) + 2;
      poly_raster_dst_ptr = (a ^ ((a & 8) ? 0 : 0x19)) << 8;
    }
    if (poly_y0_cur == poly_y0_trig) {
      poly_x0_cur = poly_x0_target;
      if (Poly_Raster_NextX0())
        return;
    }
    poly_y0_cur++;
    if (poly_y1_cur == poly_y1_trig) {
      poly_x1_cur = poly_x1_target;
      if (Poly_Raster_NextX1())
        return;
    }
    poly_y1_cur++;
    poly_x0_frac += poly_x0_step;
    poly_x1_frac += poly_x1_step;
  }
}

void Poly_RunFrame() {
  Poly_ClearBuf();
  Poly_LoadFromLut();
  Poly_GetSinCos();
  Poly_ComputeXY();
  Poly_DrawAll();
}