example/testscene: add converted textures

example/example.mk

@@ -804,7 +804,8 @@ TESTSCENE_OBJ = \
 	holly/background.o \
 	holly/ta_fifo_polygon_converter.o \
 	holly/video_output.o \
-	sh7091/serial.o
+	sh7091/serial.o \
+	model/testscene/texture/texBrick.data.o
 
 example/testscene.elf: LDSCRIPT = $(LIB)/main.lds
 example/testscene.elf: $(START_OBJ) $(TESTSCENE_OBJ)

example/testscene.cpp

@@ -20,10 +20,21 @@
 #include "systembus.hpp"
 #include "systembus_bits.hpp"
 
+#include "memory.hpp"
+
 #include "model/model.h"
+#include "model/material.h"
+#include "model/testscene/texture/texBrick.data.h"
+#include "model/testscene/texture/texFoliage.data.h"
+#include "model/testscene/texture/texGrass.data.h"
+#include "model/testscene/texture/texGrassClump.data.h"
+#include "model/testscene/texture/texRock.data.h"
+#include "model/testscene/texture/texWater.data.h"
+#include "model/testscene/material.h"
 #include "model/testscene/model.h"
 
 using vec3 = vec<3, float>;
+using vec2 = vec<2, float>;
 
 static float theta = 0;
 
@@ -58,82 +69,96 @@ static inline vec3 transform_vertex(vec3 vec)
 
 static uint32_t base_color = 0xffc0c000;
 
-static inline void transfer_triangle(vertex_position * position, union triangle * triangle)
+static inline void transfer_triangle(const vertex_position * position,
+                                     const vertex_texture * texture,
+                                     const union triangle * triangle)
 {
   base_color ^= base_color << 13;
   base_color ^= base_color >> 17;
   base_color ^= base_color << 5;
 
   vec3 v1 = transform_vertex(position[triangle->a.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
+  vec2 uv1 = texture[triangle->a.texture];
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(false),
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false),
                                         v1.x, v1.y, v1.z,
-                                        base_color);
+                                        uv1.x, uv1.y,
+                                        base_color,
+                                        0); // offset_color
   sq_transfer_32byte(ta_fifo_polygon_converter);
 
   vec3 v2 = transform_vertex(position[triangle->b.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
+  vec2 uv2 = texture[triangle->a.texture];
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(false),
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false),
                                         v2.x, v2.y, v2.z,
-                                        0xffc0c000);
+                                        uv2.x, uv2.y,
+                                        base_color,
+                                        0); // offset_color
   sq_transfer_32byte(ta_fifo_polygon_converter);
 
   vec3 v3 = transform_vertex(position[triangle->c.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
+  vec2 uv3 = texture[triangle->c.texture];
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(true),
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(true),
                                         v3.x, v3.y, v3.z,
-                                        base_color);
+                                        uv3.x, uv3.y,
+                                        base_color,
+                                        0); // offset_color
   sq_transfer_32byte(ta_fifo_polygon_converter);
 }
 
-static inline void transfer_quadrilateral(vertex_position * position, union quadrilateral * quadrilateral)
+static inline void transfer_quadrilateral(const vertex_position * position,
+                                          const vertex_texture * texture,
+                                          const union quadrilateral * quadrilateral)
 {
   base_color ^= base_color << 13;
   base_color ^= base_color >> 17;
   base_color ^= base_color << 5;
 
   vec3 v1 = transform_vertex(position[quadrilateral->a.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
+  vec2 uv1 = texture[quadrilateral->a.texture];
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(false),
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false),
                                         v1.x, v1.y, v1.z,
-                                        base_color);
+                                        uv1.x, uv1.y,
+                                        base_color,
+                                        0); // offset_color
   sq_transfer_32byte(ta_fifo_polygon_converter);
 
   vec3 v2 = transform_vertex(position[quadrilateral->b.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
+  vec2 uv2 = texture[quadrilateral->b.texture];
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(false),
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false),
                                         v2.x, v2.y, v2.z,
-                                        base_color);
+                                        uv2.x, uv2.y,
-  sq_transfer_32byte(ta_fifo_polygon_converter);
+                                        base_color,
-
+                                        0); // offset_color
-  vec3 v3 = transform_vertex(position[quadrilateral->c.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(true),
-                                        v3.x, v3.y, v3.z,
-                                        base_color);
-  sq_transfer_32byte(ta_fifo_polygon_converter);
-
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(false),
-                                        v1.x, v1.y, v1.z,
-                                        base_color);
-  sq_transfer_32byte(ta_fifo_polygon_converter);
-
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(false),
-                                        v3.x, v3.y, v3.z,
-                                        base_color);
   sq_transfer_32byte(ta_fifo_polygon_converter);
 
   vec3 v4 = transform_vertex(position[quadrilateral->d.position]);
-  *reinterpret_cast<ta_vertex_parameter::polygon_type_0 *>(store_queue) =
+  vec2 uv4 = texture[quadrilateral->d.texture];
-    ta_vertex_parameter::polygon_type_0(polygon_vertex_parameter_control_word(true),
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false),
                                         v4.x, v4.y, v4.z,
-                                        base_color);
+                                        uv4.x, uv4.y,
+                                        base_color,
+                                        0); // offset_color
   sq_transfer_32byte(ta_fifo_polygon_converter);
+
+  vec3 v3 = transform_vertex(position[quadrilateral->c.position]);
+  vec2 uv3 = texture[quadrilateral->c.texture];
+  *reinterpret_cast<ta_vertex_parameter::polygon_type_3 *>(store_queue) =
+    ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(true),
+                                        v3.x, v3.y, v3.z,
+                                        uv3.x, uv3.y,
+                                        base_color,
+                                        0); // offset_color
+  sq_transfer_32byte(ta_fifo_polygon_converter);
+
 }
 
-static inline void transfer_triangles(struct model * model, struct object * object)
+static inline void transfer_triangles(const struct model * model, const struct object * object)
 {
   if (object->triangle_count == 0)
     return;
@@ -141,16 +166,21 @@ static inline void transfer_triangles(struct model * model, struct object * obje
   const uint32_t parameter_control_word = para_control::para_type::polygon_or_modifier_volume
                                         | para_control::list_type::opaque
                                         | obj_control::col_type::packed_color
-                                        | obj_control::gouraud;
+                                        | obj_control::texture;
 
   const uint32_t isp_tsp_instruction_word = isp_tsp_instruction_word::depth_compare_mode::greater
                                           | isp_tsp_instruction_word::culling_mode::no_culling;
 
   const uint32_t tsp_instruction_word = tsp_instruction_word::src_alpha_instr::one
                                       | tsp_instruction_word::dst_alpha_instr::zero
-                                      | tsp_instruction_word::fog_control::no_fog;
+                                      | tsp_instruction_word::fog_control::no_fog
+                                      | tsp_instruction_word::texture_u_size::from_int(128)
+                                      | tsp_instruction_word::texture_v_size::from_int(128);
 
-  const uint32_t texture_control_word = 0;
+  const uint32_t texture_address = texture_memory_alloc.texture.start;
+  const uint32_t texture_control_word = texture_control_word::pixel_format::_565
+                                      | texture_control_word::scan_order::twiddled
+                                      | texture_control_word::texture_address(texture_address / 8);
 
   *reinterpret_cast<ta_global_parameter::polygon_type_0 *>(store_queue) =
     ta_global_parameter::polygon_type_0(parameter_control_word,
@@ -163,17 +193,17 @@ static inline void transfer_triangles(struct model * model, struct object * obje
   sq_transfer_32byte(ta_fifo_polygon_converter);
 
   for (int i = 0; i < object->triangle_count; i++) {
-    transfer_triangle(model->position, &object->triangle[i]);
+    transfer_triangle(model->position, model->texture, &object->triangle[i]);
   }
   for (int i = 0; i < object->quadrilateral_count; i++) {
-    transfer_quadrilateral(model->position, &object->quadrilateral[i]);
+    transfer_quadrilateral(model->position, model->texture, &object->quadrilateral[i]);
   }
 }
 
 void transfer_scene()
 {
-  struct model * model = &testscene_model;
+  const struct model * model = &testscene_model;
-  struct object * object = &testscene_Waterfall;
+  const struct object * object = &testscene_Waterfall;
   transfer_triangles(model, object);
 
   *reinterpret_cast<ta_global_parameter::end_of_list *>(store_queue) =
@@ -181,8 +211,53 @@ void transfer_scene()
   sq_transfer_32byte(ta_fifo_polygon_converter);
 }
 
+void transfer_ta_fifo_texture_memory_32byte(void * dst, void * src, int length)
+{
+  sh7091.CCN.QACR0 = ((reinterpret_cast<uint32_t>(dst) >> 24) & 0b11100);
+  sh7091.CCN.QACR1 = ((reinterpret_cast<uint32_t>(dst) >> 24) & 0b11100);
+
+  volatile uint32_t * base = &store_queue[texture_memory_alloc.texture.start / 4];
+  uint32_t * src32 = reinterpret_cast<uint32_t *>(src);
+
+  length = (length + 31) & ~31; // round up to nearest multiple of 32
+  while (length > 0) {
+    base[0] = src32[0];
+    base[1] = src32[1];
+    base[2] = src32[2];
+    base[3] = src32[3];
+    base[4] = src32[4];
+    base[5] = src32[5];
+    base[6] = src32[6];
+    base[7] = src32[7];
+    asm volatile ("pref @%0"
+                  :                // output
+                  : "r" (&base[0]) // input
+                  : "memory");
+    serial::integer<uint32_t>((uint32_t)base, ' ');
+    serial::integer<uint32_t>((uint32_t)src32, ' ');
+    serial::integer<uint32_t>(length);
+    length -= 32;
+    base += 8;
+    src32 += 8;
+  }
+}
+
+void transfer_textures()
+{
+  system.LMMODE0 = 0; // 64-bit address space
+  system.LMMODE1 = 0; // 64-bit address space
+
+  void * dst = reinterpret_cast<void *>(ta_fifo_texture_memory);
+  void * src = reinterpret_cast<void *>(&_binary_model_testscene_texture_texBrick_data_start);
+  transfer_ta_fifo_texture_memory_32byte(dst, src, 128 * 128 * 2);
+
+  //memory::copy<volatile uint32_t>(&texture_memory64[texture_memory_alloc.texture.start / 4], reinterpret_cast<uint32_t *>(src), 128 * 128 * 2);
+}
+
 void main()
 {
+  transfer_textures();
+
   constexpr uint32_t ta_alloc = ta_alloc_ctrl::pt_opb::no_list
 			      | ta_alloc_ctrl::tm_opb::no_list
 			      | ta_alloc_ctrl::t_opb::no_list

memorymap.hpp

@@ -7,7 +7,7 @@ extern volatile uint32_t texture_memory32[0x800000] __asm("texture_memory32");
 extern volatile uint32_t system_memory[0x1000000] __asm("system_memory");
 extern volatile uint32_t ta_fifo_polygon_converter[0x800000] __asm("ta_fifo_polygon_converter");
 extern volatile uint32_t ta_fifo_yuv_converter[0x800000] __asm("ta_fifo_yuv_converter");
-extern volatile uint32_t ta_fifo_texture_memory[0x800000] __asm("ta_fifo_texture_memory");
+extern uint32_t ta_fifo_texture_memory[0x800000] __asm("ta_fifo_texture_memory");
 extern volatile uint32_t ta_fifo_polygon_converter_mirror[0x800000] __asm("ta_fifo_polygon_converter_mirror");
 extern volatile uint32_t ta_fifo_yuv_converter_mirror[0x800000] __asm("ta_fifo_yuv_converter_mirror");
 extern volatile uint32_t ta_fifo_texture_memory_mirror[0x800000] __asm("ta_fifo_texture_memory_mirror");

model/model.h

@@ -35,19 +35,17 @@ using vertex_normal = vec<3, float>;
 using vertex_texture = vec<2, float>;
 
 struct object {
-  union triangle * triangle;
+  const union triangle * triangle;
-  union quadrilateral * quadrilateral;
+  const union quadrilateral * quadrilateral;
-  int triangle_count;
+  const int triangle_count;
-  int quadrilateral_count;
+  const int quadrilateral_count;
-
+  const int material;
-  int material;
 };
 
 struct model {
-  vertex_position * position;
+  const vertex_position * position;
-  vertex_texture * texture;
+  const vertex_texture * texture;
-  vertex_normal * normal;
+  const vertex_normal * normal;
-
+  const struct object ** object;
-  struct object ** object;
+  const int object_count;
-  int object_count;
 };

model/testscene/material.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "model/material.h"
+
+enum material {
+  testscene_matBrick,
+  testscene_matFoliage,
+  testscene_matGrass,
+  testscene_matGrassClump,
+  testscene_matWater,
+};
+
+const struct material_descriptor testscene_material[] = {
+  [testscene_matBrick] = {
+    .pixel = {
+      .start = (uint8_t *)&_binary_model_testscene_texture_texBrick_data_start,
+      .size = (int)&_binary_model_testscene_texture_texBrick_data_size,
+      .vram_offset = 0,
+      .width = 128,
+      .height = 128,
+    },
+  },
+  [testscene_matFoliage] = {
+    .pixel = {
+      .start = (uint8_t *)&_binary_model_testscene_texture_texFoliage_data_start,
+      .size = (int)&_binary_model_testscene_texture_texFoliage_data_size,
+      .vram_offset = 32768,
+      .width = 128,
+      .height = 128,
+    },
+  },
+  [testscene_matGrass] = {
+    .pixel = {
+      .start = (uint8_t *)&_binary_model_testscene_texture_texGrass_data_start,
+      .size = (int)&_binary_model_testscene_texture_texGrass_data_size,
+      .vram_offset = 65536,
+      .width = 128,
+      .height = 128,
+    },
+  },
+  [testscene_matGrassClump] = {
+    .pixel = {
+      .start = (uint8_t *)&_binary_model_testscene_texture_texGrassClump_data_start,
+      .size = (int)&_binary_model_testscene_texture_texGrassClump_data_size,
+      .vram_offset = 98304,
+      .width = 128,
+      .height = 128,
+    },
+  },
+  [testscene_matWater] = {
+    .pixel = {
+      .start = (uint8_t *)&_binary_model_testscene_texture_texWater_data_start,
+      .size = (int)&_binary_model_testscene_texture_texWater_data_size,
+      .vram_offset = 131072,
+      .width = 128,
+      .height = 128,
+    },
+  },
+};
+

model/testscene/model.h

@@ -1,4 +1,4 @@
-vertex_position testscene_position[] = {
+const vertex_position testscene_position[] = {
     {-2.726302f, 0.000000f, 2.726302f},
     {2.726302f, 0.000000f, 2.726302f},
     {-2.726302f, 0.000000f, -2.726302f},
@@ -1124,7 +1124,7 @@ vertex_position testscene_position[] = {
     {3.346258f, 0.354088f, 0.984101f},
 };
 
-vertex_texture testscene_texture[] = {
+const vertex_texture testscene_texture[] = {
     {-2.025739f, -2.025739f},
     {-0.870555f, -2.711017f},
     {0.500000f, 0.500000f},
@@ -1181,7 +1181,7 @@ vertex_texture testscene_texture[] = {
     {0.000000f, 1.000000f},
 };
 
-vertex_normal testscene_normal[] = {
+const vertex_normal testscene_normal[] = {
     {-0.000000f, 1.000000f, -0.000000f},
     {-0.000000f, 1.000000f, -0.000000f},
     {0.157200f, 0.911500f, 0.380100f},
@@ -1563,7 +1563,7 @@ vertex_normal testscene_normal[] = {
     {-0.833900f, -0.091000f, -0.544300f},
 };
 
-union triangle testscene_Ground_triangle[] = {
+const union triangle testscene_Ground_triangle[] = {
     { .v = {
         {7, 1, 0},
         {8, 4, 0},
@@ -1606,7 +1606,7 @@ union triangle testscene_Ground_triangle[] = {
     }},
 };
 
-union quadrilateral testscene_Ground_quadrilateral[] = {
+const union quadrilateral testscene_Ground_quadrilateral[] = {
     { .v = {
         {0, 0, 0},
         {7, 1, 0},
@@ -1633,15 +1633,15 @@ union quadrilateral testscene_Ground_quadrilateral[] = {
     }},
 };
 
-struct object testscene_Ground = {
+const struct object testscene_Ground = {
     .triangle = &testscene_Ground_triangle[0],
     .quadrilateral = &testscene_Ground_quadrilateral[0],
     .triangle_count = 8,
     .quadrilateral_count = 4,
-    .material = 0,
+    .material = testscene_matGrass,
 };
 
-union triangle testscene_Waterfall_triangle[] = {
+const union triangle testscene_Waterfall_triangle[] = {
     { .v = {
         {17, 17, 1},
         {25, 18, 9},
@@ -1684,7 +1684,7 @@ union triangle testscene_Waterfall_triangle[] = {
     }},
 };
 
-union quadrilateral testscene_Waterfall_quadrilateral[] = {
+const union quadrilateral testscene_Waterfall_quadrilateral[] = {
     { .v = {
         {25, 20, 9},
         {18, 17, 2},
@@ -2071,15 +2071,15 @@ union quadrilateral testscene_Waterfall_quadrilateral[] = {
     }},
 };
 
-struct object testscene_Waterfall = {
+const struct object testscene_Waterfall = {
     .triangle = &testscene_Waterfall_triangle[0],
     .quadrilateral = &testscene_Waterfall_quadrilateral[0],
     .triangle_count = 8,
     .quadrilateral_count = 64,
-    .material = 0,
+    .material = testscene_matWater,
 };
 
-union triangle testscene_Pole_triangle[] = {
+const union triangle testscene_Pole_triangle[] = {
     { .v = {
         {201, 25, 185},
         {202, 30, 186},
@@ -2122,7 +2122,7 @@ union triangle testscene_Pole_triangle[] = {
     }},
 };
 
-union quadrilateral testscene_Pole_quadrilateral[] = {
+const union quadrilateral testscene_Pole_quadrilateral[] = {
     { .v = {
         {109, 25, 93},
         {106, 26, 90},
@@ -2701,18 +2701,18 @@ union quadrilateral testscene_Pole_quadrilateral[] = {
     }},
 };
 
-struct object testscene_Pole = {
+const struct object testscene_Pole = {
     .triangle = &testscene_Pole_triangle[0],
     .quadrilateral = &testscene_Pole_quadrilateral[0],
     .triangle_count = 8,
     .quadrilateral_count = 96,
-    .material = 0,
+    .material = testscene_matBrick,
 };
 
-union triangle testscene_Foliage_triangle[] = {
+const union triangle testscene_Foliage_triangle[] = {
 };
 
-union quadrilateral testscene_Foliage_quadrilateral[] = {
+const union quadrilateral testscene_Foliage_quadrilateral[] = {
     { .v = {
         {211, 50, 195},
         {212, 51, 195},
@@ -3001,6 +3001,20 @@ union quadrilateral testscene_Foliage_quadrilateral[] = {
         {942, 52, 338},
         {940, 51, 338},
     }},
+};
+
+const struct object testscene_Foliage = {
+    .triangle = &testscene_Foliage_triangle[0],
+    .quadrilateral = &testscene_Foliage_quadrilateral[0],
+    .triangle_count = 0,
+    .quadrilateral_count = 48,
+    .material = testscene_matFoliage,
+};
+
+const union triangle testscene_Foliage_mtl_matGrassClump_triangle[] = {
+};
+
+const union quadrilateral testscene_Foliage_mtl_matGrassClump_quadrilateral[] = {
     { .v = {
         {259, 50, 201},
         {260, 51, 201},
@@ -4083,26 +4097,27 @@ union quadrilateral testscene_Foliage_quadrilateral[] = {
     }},
 };
 
-struct object testscene_Foliage = {
+const struct object testscene_Foliage_mtl_matGrassClump = {
-    .triangle = &testscene_Foliage_triangle[0],
+    .triangle = &testscene_Foliage_mtl_matGrassClump_triangle[0],
-    .quadrilateral = &testscene_Foliage_quadrilateral[0],
+    .quadrilateral = &testscene_Foliage_mtl_matGrassClump_quadrilateral[0],
     .triangle_count = 0,
-    .quadrilateral_count = 228,
+    .quadrilateral_count = 180,
-    .material = 0,
+    .material = testscene_matGrassClump,
 };
 
-struct object * testscene_object[] = {
+const struct object * testscene_object[] = {
     &testscene_Ground,
     &testscene_Waterfall,
     &testscene_Pole,
     &testscene_Foliage,
+    &testscene_Foliage_mtl_matGrassClump,
 };
 
-struct model testscene_model = {
+const struct model testscene_model = {
     .position = testscene_position,
     .texture = testscene_texture,
     .normal = testscene_normal,
     .object = testscene_object,
-    .object_count = 4
+    .object_count = 5
 };
 

model/testscene/texture/texBrick.data.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t _binary_model_testscene_texture_texBrick_data_start __asm("_binary_model_testscene_texture_texBrick_data_start");
+extern uint32_t _binary_model_testscene_texture_texBrick_data_end __asm("_binary_model_testscene_texture_texBrick_data_end");
+extern uint32_t _binary_model_testscene_texture_texBrick_data_size __asm("_binary_model_testscene_texture_texBrick_data_size");
+
+#ifdef __cplusplus
+}
+#endif

model/testscene/texture/texFoliage.data.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t _binary_model_testscene_texture_texFoliage_data_start __asm("_binary_model_testscene_texture_texFoliage_data_start");
+extern uint32_t _binary_model_testscene_texture_texFoliage_data_end __asm("_binary_model_testscene_texture_texFoliage_data_end");
+extern uint32_t _binary_model_testscene_texture_texFoliage_data_size __asm("_binary_model_testscene_texture_texFoliage_data_size");
+
+#ifdef __cplusplus
+}
+#endif

model/testscene/texture/texGrass.data.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t _binary_model_testscene_texture_texGrass_data_start __asm("_binary_model_testscene_texture_texGrass_data_start");
+extern uint32_t _binary_model_testscene_texture_texGrass_data_end __asm("_binary_model_testscene_texture_texGrass_data_end");
+extern uint32_t _binary_model_testscene_texture_texGrass_data_size __asm("_binary_model_testscene_texture_texGrass_data_size");
+
+#ifdef __cplusplus
+}
+#endif

model/testscene/texture/texGrassClump.data.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t _binary_model_testscene_texture_texGrassClump_data_start __asm("_binary_model_testscene_texture_texGrassClump_data_start");
+extern uint32_t _binary_model_testscene_texture_texGrassClump_data_end __asm("_binary_model_testscene_texture_texGrassClump_data_end");
+extern uint32_t _binary_model_testscene_texture_texGrassClump_data_size __asm("_binary_model_testscene_texture_texGrassClump_data_size");
+
+#ifdef __cplusplus
+}
+#endif

model/testscene/texture/texRock.data.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t _binary_model_testscene_texture_texRock_data_start __asm("_binary_model_testscene_texture_texRock_data_start");
+extern uint32_t _binary_model_testscene_texture_texRock_data_end __asm("_binary_model_testscene_texture_texRock_data_end");
+extern uint32_t _binary_model_testscene_texture_texRock_data_size __asm("_binary_model_testscene_texture_texRock_data_size");
+
+#ifdef __cplusplus
+}
+#endif

model/testscene/texture/texWater.data.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t _binary_model_testscene_texture_texWater_data_start __asm("_binary_model_testscene_texture_texWater_data_start");
+extern uint32_t _binary_model_testscene_texture_texWater_data_end __asm("_binary_model_testscene_texture_texWater_data_end");
+extern uint32_t _binary_model_testscene_texture_texWater_data_size __asm("_binary_model_testscene_texture_texWater_data_size");
+
+#ifdef __cplusplus
+}
+#endif

sh7091/store_queue.hpp

@@ -6,7 +6,7 @@
 static inline void sq_transfer_32byte(volatile void * dst)
 {
   // dst typically 0x10000000 (ta polygon converter)
-  sh7091.CCN.QACR0 = ((reinterpret_cast<uint32_t>(dst) >> 26) & 0b111) << 2;
+  sh7091.CCN.QACR0 = ((reinterpret_cast<uint32_t>(dst) >> 24) & 0b11100);
 
   // start 32-byte transfer from store queue 0 (SQ0) to QACR0
   asm volatile ("pref @%0"
@@ -19,8 +19,8 @@ static inline void sq_transfer_32byte(volatile void * dst)
 static inline void sq_transfer_64byte(volatile void * dst)
 {
   // dst typically 0x10000000 (ta polygon converter)
-  sh7091.CCN.QACR0 = ((reinterpret_cast<uint32_t>(dst) >> 26) & 0b111) << 2;
+  sh7091.CCN.QACR0 = ((reinterpret_cast<uint32_t>(dst) >> 24) & 0b11100);
-  sh7091.CCN.QACR1 = ((reinterpret_cast<uint32_t>(dst) >> 26) & 0b111) << 2;
+  sh7091.CCN.QACR1 = ((reinterpret_cast<uint32_t>(dst) >> 24) & 0b11100);
 
   // start 32-byte transfer from store queue 0 (SQ0) to QACR0
   asm volatile ("pref @%0"