#include "software_ta.hpp"

#if defined(__dreamcast__)
#include "sh7091/serial.hpp"
#define print__character serial::character
#define print__string serial::string
#define print__integer serial::integer<int32_t>
#define assert(b)                                                       \
  do {                                                                  \
    if (!(b)) {                                                         \
      print__string(__FILE__);                                          \
      print__character(':');                                            \
      print__integer(__LINE__, ' ');                                    \
      print__string(__func__);                                          \
      print__string(": assertion failed: ");                            \
      print__string(#b);                                                \
      print__character('\n');                                           \
      while (1);                                                        \
    }                                                                   \
  } while (0);
#else
#include <stdio.h>
#include <assert.h>
#endif

union i32_f {
  int32_t i;
  float f;
};

namespace para_type {
  constexpr int end_of_list = 0;
  constexpr int user_tile_clip = 1;
  constexpr int object_list_set = 2;
  constexpr int polygon_or_modifier_volume = 4;
  constexpr int sprite = 5;
  constexpr int vertex = 7;
};

namespace list_type {
  constexpr int opaque = 0;
  constexpr int opaque_modifier_volume = 1;
  constexpr int translucent = 2;
  constexpr int translucent_modifier_volume = 3;
  constexpr int punch_through = 4;
};

namespace col_type {
  constexpr int packed_color = 0;
  constexpr int floating_color = 1;
  constexpr int intensity_mode_1 = 2;
  constexpr int intensity_mode_2 = 3;
};

namespace object_list_data {
  constexpr int triangle_strip = (0b0 << 31);
  constexpr int triangle_array = (0b100 << 29);
  constexpr int quad_array = (0b101 << 29);
  constexpr int object_pointer_block_link = (0b111 << 29);
};

// if entry == 0; calculate ol_current from ol_base
struct tile_state {
  int8_t entry;
  int8_t current_list_type;
  int32_t ol_base;       // words
  int32_t ol_current;    // words
};

struct alloc {
  union {
    int opaque;                         // words
    int opaque_modifier_volume;         // words
    int translucent;                    // words
    int translucent_modifier_volume;    // words
    int punch_through;                  // words
  };
  int list_type[5];
};

struct ta_state {
  int8_t tile_x_num;
  int8_t tile_y_num;

  int8_t current_list_type;
  int8_t list_end;

  int32_t ol_base;
  int32_t ol_limit;
  int32_t param_base;
  int32_t param_limit;   // words
  int32_t param_current; // words

  int32_t next_opb;    // words
  int32_t entry;
  struct alloc alloc;
  struct tile_state tile[64 * 64];
};

static struct ta_state state;

static inline int alloc_ctrl_units(int n)
{
  return (n == 0) ? 0 : (1 << (n + 2)); // words
}

static inline void terminate_ta_tiles(int list_type, void * _dst)
{
  union i32_f * dst = (union i32_f *)_dst;
  for (int y = 0; y < state.tile_y_num; y++) {
    for (int x = 0; x < state.tile_x_num; x++) {
      struct tile_state * tile = &state.tile[y * 64 + x];
      assert(tile->current_list_type == list_type || tile->current_list_type == -1);

      // end of list
      assert(tile->ol_current >= state.ol_base && tile->ol_current < state.ol_limit);
      fprintf(stderr, "eol %d %d %08x\n", x, y, tile->ol_current * 4);
      dst[tile->ol_current].i = object_list_data::object_pointer_block_link | (1 << 28);

      tile->current_list_type = -1;
    }
  }
}

static inline void tile_ol_current_for_list(struct tile_state * tile, int list_type_ix)
{
  assert(list_type_ix >= 0 && list_type_ix <= 5);
  tile->ol_current = tile->ol_base + state.alloc.list_type[list_type_ix];
  { // removeme
    int32_t ix = tile - state.tile;
    int x = ix & 63;
    int y = ix >> 6;
    fprintf(stderr, "ol_current_for_list %d %d %08x\n", x, y, tile->ol_current * 4);
  }
}

static inline void flush_ta_tile(int list_type, int length, int shadow, int skip, struct tile_state * tile, void * _dst)
{
  union i32_f * dst = (union i32_f *)_dst;

  if (tile->current_list_type != list_type) {
    tile_ol_current_for_list(tile, list_type);
    tile->current_list_type = list_type;
  }

  if (!tile->entry)
    return;

  assert(length > 0);
  assert(length <= 16);

  int32_t ix = tile - state.tile;
  int x = ix & 63;
  int y = ix >> 6;

  fprintf(stderr, "flush_ta_tile %d %d %08x\n", x, y, tile->ol_current * 4);
  if ((tile->ol_current & 15) == 15) {
    fprintf(stderr, "overflow %d\n", (int32_t)(tile - state.tile));
    tile->entry = 0;
  }
  //assert((tile->ol_current & 15) != 15);

  dst[tile->ol_current].i = (object_list_data::triangle_array |
                             (length - 1) << 25 |
                             (shadow << 24) |
                             (skip << 21) |
                             state.param_current);
  fprintf(stderr, "l1 %d\n", (length - 1));
  fprintf(stderr, "oldta %d\n", object_list_data::triangle_array);
  fprintf(stderr, "param_current %d\n", state.param_current);
  fprintf(stderr, "dst tile ol_current %d %08x\n", tile->ol_current * 4, dst[tile->ol_current].i);

  tile->ol_current += 1;
  tile->entry = 0;
}

void flush_ta_tiles(int list_type, int length, int shadow, int skip, void * dst)
{
  for (int y = 0; y < state.tile_y_num; y++) {
    for (int x = 0; x < state.tile_x_num; x++) {
      struct tile_state * tile = &state.tile[y * 64 + x];
      flush_ta_tile(list_type, length, shadow, skip, tile, dst);
    }
  }
}

void software_ta_init(const struct ta_configuration * config)
{
  state.tile_x_num = config->tile_x_num;
  state.tile_y_num = config->tile_y_num;
  state.current_list_type = -1;
  state.list_end = 0;

  state.ol_base = config->ol_base >> 2;  // words
  state.ol_limit = config->ol_limit >> 2;  // words
  state.param_base = config->isp_base >> 2;  // words
  state.param_limit = config->isp_limit >> 2;  // words
  state.param_current = state.param_base; // words
  assert(state.param_limit <= 0x1fffff);

  state.next_opb = config->next_opb_init;

  int alloc_opaque                      = alloc_ctrl_units((config->alloc_ctrl >> 0 ) & 0b11);
  int alloc_opaque_modifier_volume      = alloc_ctrl_units((config->alloc_ctrl >> 4 ) & 0b11);
  int alloc_translucent                 = alloc_ctrl_units((config->alloc_ctrl >> 8 ) & 0b11);
  int alloc_translucent_modifier_volume = alloc_ctrl_units((config->alloc_ctrl >> 12) & 0b11);
  int alloc_punch_through               = alloc_ctrl_units((config->alloc_ctrl >> 16) & 0b11);

  // bytes
  int alloc_total_size = (alloc_opaque +
                          alloc_opaque_modifier_volume +
                          alloc_translucent +
                          alloc_translucent_modifier_volume +
                          alloc_punch_through);

  state.alloc.opaque = 0;
  state.alloc.opaque_modifier_volume = state.alloc.opaque + alloc_opaque;
  state.alloc.translucent = state.alloc.opaque_modifier_volume + alloc_opaque_modifier_volume;
  state.alloc.translucent_modifier_volume = state.alloc.translucent + alloc_translucent;
  state.alloc.punch_through = state.alloc.translucent_modifier_volume + alloc_translucent_modifier_volume;

  int ol_offset = config->ol_base >> 2; // words
  for (int y = 0; y < config->tile_y_num; y++) {
    for (int x = 0; x < config->tile_x_num; x++) {
      struct tile_state * tile = &state.tile[y * 64 + x];
      fprintf(stderr, "ol_offset %d %d %08x\n", x, y, ol_offset);
      tile->entry = 0;
      tile->ol_base = ol_offset;
      tile->ol_current = -1;
      tile->current_list_type = -1;
      ol_offset += alloc_total_size;
    }
  }
}

static inline int decode_skip(int texture, int offset, int _16bit_uv)
{
  if (texture == 0)
    return 0b001;

  int skip;
  int control_word = (offset << 1) | (_16bit_uv << 0);
  switch (control_word) {
  default: [[fallthrough]];
  case 0b00: skip = 0b011; break;
  case 0b01: skip = 0b010; break;
  case 0b10: skip = 0b100; break;
  case 0b11: skip = 0b011; break;
  }

  return skip;
}

/*
int modifier_volume(union i32_f * parameter,
                    int list_type,
                    int parameter_control_word,
                    void * dst)
{
  int skip = 0;
}
*/

static inline int32_t pack_floating_color(float a, float r, float g, float b)
{
  /* The TA converts each element of ARGB data into a fixed decimal value
     between 0.0 and 1.0, multiples the value by 255, and packs the result in a
     32-bit value.
  */

  if (a > 1.f) a = 1.f;
  if (a < 0.f) a = 0.f;
  if (r > 1.f) r = 1.f;
  if (r < 0.f) r = 0.f;
  if (g > 1.f) g = 1.f;
  if (g < 0.f) g = 0.f;
  if (b > 1.f) b = 1.f;
  if (b < 0.f) b = 0.f;

  int ai = (int)(a * 255.f);
  int ri = (int)(r * 255.f);
  int gi = (int)(g * 255.f);
  int bi = (int)(b * 255.f);

  return ((ai & 0xff) << 24) | ((ri & 0xff) << 16) | ((gi & 0xff) << 8) | ((bi & 0xff) << 0);
}

static inline int32_t pack_intensity_color(float a, float r, float g, float b, float intensity)
{
  /* Regarding alpha values, the TA converts the specified Face Color Alpha
     value into a fixed decimal value between 0.0 and 1.0, multiples the value
     by 255, and derives an 8-bit value.  Regarding RGB values, the TA converts
     the specified Face Color R/G/B value into a fixed decimal value between 0.0
     and 1.0, multiples the value by 255, converts the intensity value into a
     fixed decimal value between 0.0 and 1.0, multiplies the converted R/G/B
     value and the converted intensity value together, multiplies that result by
     255, and derives an 8-bit value for each of R, G, and B.  Finally, the TA
     packs each 8-bit value into a 32-bit value.
  */

  // this description is probably incorrect. multiplying by 255 twice does not
  // make sense.

  if (a > 1.f) a = 1.f;
  if (a < 0.f) a = 0.f;
  if (r > 1.f) r = 1.f;
  if (r < 0.f) r = 0.f;
  if (g > 1.f) g = 1.f;
  if (g < 0.f) g = 0.f;
  if (b > 1.f) b = 1.f;
  if (b < 0.f) b = 0.f;
  if (intensity > 1.f) intensity = 1.f;
  if (intensity < 0.f) intensity = 0.f;

  int ai = (int)(a * 255.f);
  int ri = (int)(r * intensity * 255.f);
  int gi = (int)(g * intensity * 255.f);
  int bi = (int)(b * intensity * 255.f);

  if (ri > 255) ri = 255;
  if (gi > 255) gi = 255;
  if (bi > 255) bi = 255;

  return ((ai & 0xff) << 24) | (ri << 16) | (gi << 8) | (bi << 0);
}

struct bounding_box {
  int min_x; // in tile units
  int min_y; // in tile units
  int max_x; // in tile units
  int max_y; // in tile units
};

static inline float min(float a, float b, float c)
{
  if (a < b)
    return (a < c) ? a : c;
  else
    return (b < c) ? b : c;
}

static inline float max(float a, float b, float c)
{
  if (a > b)
    return (a > c) ? a : c;
  else
    return (b > c) ? b : c;
}

static inline int floor(float f)
{
  return (int)f;
}

static inline int ceil(float f)
{
  int fi = (int)f;
  float fn = (float)fi;
  return fi + (fn < f);
}

static inline struct bounding_box calculate_bounding_box(float ax, float ay,
                                                         float bx, float by,
                                                         float cx, float cy)
{
  int min_x = floor(min(ax, bx, cx));
  int min_y = floor(min(ay, by, cy));
  int max_x = ceil(max(ax, bx, cx));
  int max_y = ceil(max(ay, by, cy));

  return (bounding_box){
    min_x >> 5, // round down
    min_y >> 5, // round down
    max_x >> 5, // round down
    max_y >> 5, // round down
  };
}

struct previous_vertex {
  float x;
  float y;
  float z;
  int32_t base_color_0;
  int32_t offset_color_0;
  int32_t base_color_1;
  int32_t offset_color_1;
};

int polygon(union i32_f * parameter,
            int list_type,
            int parameter_control_word,
            void * _dst)
{
  union i32_f * dst = (union i32_f *)_dst;

  assert(((parameter_control_word >> 27) & 1) == 0);
  int group_en     = (parameter_control_word >> 23) & 0b1;
  assert(((parameter_control_word >> 20) & 0b111) == 0);
  int strip_len    = (parameter_control_word >> 18) & 0b11;
  int user_clip    = (parameter_control_word >> 16) & 0b11;
  assert(((parameter_control_word >> 8) & 0xff) == 0);
  int shadow       = (parameter_control_word >> 7) & 0b1;
  int volume       = (parameter_control_word >> 6) & 0b1;
  int col_type     = (parameter_control_word >> 4) & 0b11;
  int texture      = (parameter_control_word >> 3) & 0b1;
  int offset       = (parameter_control_word >> 2) & 0b1;
  int gouraud      = (parameter_control_word >> 1) & 0b1;
  int _16bit_uv    = (parameter_control_word >> 0) & 0b1;

  fprintf(stderr, "sv %d %d\n", shadow, volume);
  assert(!volume || shadow); // for polygons, shadow and volume must be the same value

  int32_t isp_tsp_instruction_word = parameter[1].i;
  isp_tsp_instruction_word &= ~(0b1111 << 22);
  isp_tsp_instruction_word |= (parameter_control_word & 0b1111) << 22;

#define tsp_instruction_word_0 parameter[2].i
#define texture_control_word_0 parameter[3].i
#define tsp_instruction_word_1 parameter[4].i
#define texture_control_word_1 parameter[5].i

  static float face_color_a_0;
  static float face_color_r_0;
  static float face_color_g_0;
  static float face_color_b_0;
  static float face_offset_color_a;
  static float face_offset_color_r;
  static float face_offset_color_g;
  static float face_offset_color_b;
#define face_color_a_1 face_offset_color_a
#define face_color_r_1 face_offset_color_r
#define face_color_g_1 face_offset_color_g
#define face_color_b_1 face_offset_color_b

  int vertex_index = 8;
  if (col_type == col_type::intensity_mode_1) {
    if (offset || volume) {
      face_color_a_0 = parameter[8].f;
      face_color_r_0 = parameter[9].f;
      face_color_g_0 = parameter[10].f;
      face_color_b_0 = parameter[11].f;
      face_offset_color_a = parameter[12].f;
      face_offset_color_r = parameter[13].f;
      face_offset_color_g = parameter[14].f;
      face_offset_color_b = parameter[15].f;
      vertex_index = 16;
    } else {
      face_color_a_0 = parameter[4].f;
      face_color_r_0 = parameter[5].f;
      face_color_g_0 = parameter[6].f;
      face_color_b_0 = parameter[7].f;
    }
  }

  int skip = decode_skip(texture, offset, _16bit_uv);

  int param_index = state.param_current;

  struct previous_vertex previous_vertex[2];

  int color_control_word = volume << 1 | texture << 0;
  int vertex_length = 8 * (1 + (texture && (volume || col_type == col_type::floating_color)));

  int strip_index = 0;

  int32_t base_color_0;
  int32_t offset_color_0;
  int32_t base_color_1;
  int32_t offset_color_1;
  float x;
  float y;
  float z;

  while (true) {
    int parameter_control_word = parameter[vertex_index + 0].i;
    fprintf(stderr, "vi %d %08x\n", vertex_index, parameter_control_word);

    int para_type    = (parameter_control_word >> 29) & 0b111;
    assert(para_type == para_type::vertex);
    int end_of_strip = (parameter_control_word >> 28) & 0b1;

    x = parameter[vertex_index + 1].f;
    y = parameter[vertex_index + 2].f;
    z = parameter[vertex_index + 3].f;

    switch (col_type) {
    case col_type::packed_color:
      switch (color_control_word) {
      case 0b00: // one volume, non-textured
        base_color_0 = parameter[vertex_index + 6].i;
        break;
      case 0b01: // one volume, textured
        base_color_0 = parameter[vertex_index + 6].i;
        offset_color_0 = parameter[vertex_index + 7].i;
        break;
      case 0b10: // two volumes, non-textured
        base_color_0 = parameter[vertex_index + 4].i;
        base_color_1 = parameter[vertex_index + 5].i;
        break;
      case 0b11: // two volumes, textured
        base_color_0 = parameter[vertex_index + 6].i;
        offset_color_0 = parameter[vertex_index + 7].i;
        base_color_1 = parameter[vertex_index + 10].i;
        offset_color_1 = parameter[vertex_index + 11].i;
        break;
      }
      break;
    case col_type::floating_color:
      {
        float base_color_a;
        float base_color_r;
        float base_color_g;
        float base_color_b;
        float offset_color_a;
        float offset_color_r;
        float offset_color_g;
        float offset_color_b;
        switch (color_control_word) {
        case 0b00: // one volume, non-textured
          base_color_a = parameter[vertex_index + 4].f;
          base_color_r = parameter[vertex_index + 5].f;
          base_color_g = parameter[vertex_index + 6].f;
          base_color_b = parameter[vertex_index + 7].f;

          base_color_0 = pack_floating_color(base_color_a, base_color_r, base_color_g, base_color_b);
          break;
        case 0b01: // one volume, textured
          base_color_a = parameter[vertex_index + 8].f;
          base_color_r = parameter[vertex_index + 9].f;
          base_color_g = parameter[vertex_index + 10].f;
          base_color_b = parameter[vertex_index + 11].f;
          base_color_a = parameter[vertex_index + 12].f;
          base_color_r = parameter[vertex_index + 13].f;
          base_color_g = parameter[vertex_index + 14].f;
          base_color_b = parameter[vertex_index + 15].f;

          base_color_0 = pack_floating_color(base_color_a, base_color_r, base_color_g, base_color_b);
          offset_color_0 = pack_floating_color(offset_color_a, offset_color_r, offset_color_g, offset_color_b);
          break;
        case 0b10: // two volumes, non-textured
          assert(!"two volume non-textured floating color");
          break;
        case 0b11: // two volumes, textured
          assert(!"two volume textured floating color");
          break;
        }
      }
      break;
    case col_type::intensity_mode_1: [[fallthrough]];
    case col_type::intensity_mode_2:
      {
        float base_intensity_0;
        float base_intensity_1;
        float offset_intensity_0;
        float offset_intensity_1;
        switch (color_control_word) {
        case 0b00: // one volume, non-textured
          base_intensity_0 = parameter[vertex_index + 6].f;
          base_color_0 = pack_intensity_color(face_color_a_0, face_color_r_0, face_color_g_0, face_color_b_0, base_intensity_0);
          break;
        case 0b01: // one volume, textured
          base_intensity_0 = parameter[vertex_index + 6].f;
          offset_intensity_0 = parameter[vertex_index + 7].f;
          base_color_0 = pack_intensity_color(face_color_a_0, face_color_r_0, face_color_g_0, face_color_b_0, base_intensity_0);
          offset_color_0 = pack_intensity_color(face_offset_color_a, face_offset_color_r, face_offset_color_g, face_offset_color_b, offset_intensity_0);
          break;
        case 0b10: // two volumes, non-textured
          base_intensity_0 = parameter[vertex_index + 4].f;
          base_intensity_1 = parameter[vertex_index + 5].f;
          base_color_0 = pack_intensity_color(face_color_a_0, face_color_r_0, face_color_g_0, face_color_b_0, base_intensity_0);
          base_color_1 = pack_intensity_color(face_color_a_1, face_color_r_1, face_color_g_1, face_color_b_1, base_intensity_0);
          break;
        case 0b11: // two volumes, textured
          base_intensity_0 = parameter[vertex_index + 6].f;
          offset_intensity_0 = parameter[vertex_index + 7].f;
          base_color_0 = pack_intensity_color(face_color_a_0, face_color_r_0, face_color_g_0, face_color_b_0, base_intensity_0);
          offset_color_0 = pack_intensity_color(face_offset_color_a, face_offset_color_r, face_offset_color_g, face_offset_color_b, offset_intensity_0);

          base_intensity_1 = parameter[vertex_index + 10].f;
          offset_intensity_1 = parameter[vertex_index + 11].f;
          base_color_1 = pack_intensity_color(face_color_a_1, face_color_r_1, face_color_g_1, face_color_b_1, base_intensity_1);
          offset_color_1 = pack_intensity_color(face_offset_color_a, face_offset_color_r, face_offset_color_g, face_offset_color_b, offset_intensity_1);
          break;
        }
      } // switch col_type
    }

    if (strip_index >= 2) {
      // write an entire triangle to params:
      dst[param_index + 0].i = isp_tsp_instruction_word;
      dst[param_index + 1].i = tsp_instruction_word_0;
      dst[param_index + 2].i = texture_control_word_0;
      param_index += 3;

      dst[param_index + 0].f = previous_vertex[1].x;
      dst[param_index + 1].f = previous_vertex[1].y;
      dst[param_index + 2].f = previous_vertex[1].z;
      dst[param_index + 3].i = previous_vertex[1].base_color_0;
      assert(skip + 3 == 4);
      param_index += 4;

      dst[param_index + 0].f = previous_vertex[0].x;
      dst[param_index + 1].f = previous_vertex[0].y;
      dst[param_index + 2].f = previous_vertex[0].z;
      dst[param_index + 3].i = previous_vertex[0].base_color_0;
      assert(skip + 3 == 4);
      param_index += 4;

      dst[param_index + 0].f = x;
      dst[param_index + 1].f = y;
      dst[param_index + 2].f = z;
      dst[param_index + 3].i = base_color_0;
      assert(skip + 3 == 4);
      param_index += 4;
    }

    if (strip_index >= 2) {
      // find new tiles to includes

      // 2: {v1, v0}
      // 3: {v1, v2}
      // 4: {v3, v2}
      // 5: {v3, v4}


      /*
       1 p0 B         p0 B---D _
           / \            \ /
     0 p1 A---C 2 _    p1  C
       */

      assert(texture == 0);

      // calculate bounding box
      struct bounding_box bb = calculate_bounding_box(x, y,
                                                      previous_vertex[0].x, previous_vertex[0].y,
                                                      previous_vertex[1].x, previous_vertex[1].y);
      fprintf(stderr, "bb: min %d %d max %d %d\n", bb.min_x, bb.min_y, bb.max_x, bb.max_y);
      for (int ty = bb.min_y; ty <= bb.max_y; ty++) {
        for (int tx = bb.min_x; tx <= bb.max_x; tx++) {
          int tile_ix = ty * 64 + tx;
          struct tile_state * tile = &state.tile[tile_ix];
          tile->entry = 1;
        }
      }
    }

    // check for possible end of strip
    strip_index += 1;
    if (end_of_strip) {
      assert(strip_index >= 2);
      int num_triangles = strip_index - 2;
      assert(num_triangles >= 0);
      flush_ta_tiles(list_type, num_triangles, shadow, skip, dst);
      state.param_current = param_index;
      strip_index = 0;
    }

    // next_vertex (possible end of polygon array)
    vertex_index += vertex_length;
    parameter_control_word = parameter[vertex_index + 0].i;
    para_type    = (parameter_control_word >> 29) & 0b111;
    if (para_type != para_type::vertex) {
      assert(end_of_strip);
      break;
    }

    // write previous vertex parameters to triangle strip array
    // 0: 1 & (strip_index & 1) → 1
    // 1: 2 & (strip_index & 1) → 0
    // 2: 3 & (strip_index & 1) → 1
    // 3: 4 & (strip_index & 1) → 0
    // 4: 5 & (strip_index & 1) → 1
    // 5: 6 & (strip_index & 1) → 0
    previous_vertex[strip_index & 1].x = x;
    previous_vertex[strip_index & 1].y = y;
    previous_vertex[strip_index & 1].z = z;
    previous_vertex[strip_index & 1].base_color_0 = base_color_0;
    previous_vertex[strip_index & 1].offset_color_0 = offset_color_0;
    previous_vertex[strip_index & 1].base_color_1 = base_color_1;
    previous_vertex[strip_index & 1].offset_color_1 = offset_color_1;
  }

  return vertex_index << 2;
}

void software_ta_transfer(void * src, int32_t src_size,
                          void * dst)
{
  int32_t src_offset = 0;
  while (src_offset < src_size) {
    fprintf(stderr, "src_offset: %08x\n", src_offset);
    union i32_f * parameter = (union i32_f *)(((int8_t *)src) + src_offset);
    int32_t parameter_control_word = parameter[0].i;
    int para_type    = (parameter_control_word >> 29) & 0b111;
    int list_type    = (parameter_control_word >> 24) & 0b111;

    switch (para_type) {
    case para_type::end_of_list:
      assert(state.current_list_type != -1);
      state.list_end |= (1 << state.current_list_type);
      terminate_ta_tiles(state.current_list_type, dst);
      state.current_list_type = -1;
      src_offset += 32;
      break;
    case para_type::user_tile_clip:
      src_offset += 32;
      assert(!"user tile clip");
      break;
    case para_type::object_list_set:
      src_offset += 32;
      assert(!"object list set");
      break;
    case para_type::polygon_or_modifier_volume:
      fprintf(stderr, "%d %d\n", state.current_list_type, list_type);
      fflush(stdout);
      assert(state.current_list_type == -1 || state.current_list_type == list_type);
      state.current_list_type = list_type;
      if (list_type == list_type::opaque_modifier_volume || list_type == list_type::translucent_modifier_volume) {
        assert(!"modifier_volume");
        //src_offset += modifier_volume(parameter, list_type, parameter_control_word, dst);
      } else {
        src_offset += polygon(parameter, list_type, parameter_control_word, dst);
      }
      break;
    case para_type::sprite:
      assert(!"sprite");
      break;
    case para_type::vertex:
      assert(!"vertex parameter with no global");
      break;
    default:
      assert(!"invalid para_type");
      break;
    }
  }

  assert(src_offset == src_size);
}