From bd8ff8fa838516582588d9129f522fceb8c65c79 Mon Sep 17 00:00:00 2001 From: Zack Buhman Date: Mon, 31 Mar 2025 01:34:08 -0500 Subject: [PATCH] example: add gradient --- common.lds | 14 +- example/example.mk | 14 ++ example/gradient.cpp | 417 +++++++++++++++++++++++++++++++ texture/gradient.png | Bin 0 -> 576 bytes texture/gradient/gradient.data | 1 + texture/gradient/gradient.data.h | 15 ++ texture/gradient/gradient.png | Bin 0 -> 576 bytes 7 files changed, 454 insertions(+), 7 deletions(-) create mode 100644 example/gradient.cpp create mode 100644 texture/gradient.png create mode 100644 texture/gradient/gradient.data create mode 100644 texture/gradient/gradient.data.h create mode 100644 texture/gradient/gradient.png diff --git a/common.lds b/common.lds index 545e6f4..0c7cef2 100644 --- a/common.lds +++ b/common.lds @@ -34,13 +34,6 @@ SECTIONS KEEP(*(.ctors.*)) } > p1ram - .bss ALIGN(4) (NOLOAD) : - { - *(.bss) - *(.bss.*) - *(COMMON) - } > p1ram - .text.vbr ALIGN(4) : SUBALIGN(4) { __vbr100 = .; @@ -51,6 +44,13 @@ SECTIONS KEEP(*(.vbr.600)) } > p1ram + .bss ALIGN(4) (NOLOAD) : + { + *(.bss) + *(.bss.*) + *(COMMON) + } > p1ram + INCLUDE "debug.lds" } diff --git a/example/example.mk b/example/example.mk index 11ba476..86e364e 100644 --- a/example/example.mk +++ b/example/example.mk @@ -907,3 +907,17 @@ CASTLE_OBJ = \ example/castle.elf: LDSCRIPT = $(LIB)/main.lds example/castle.elf: $(START_OBJ) $(CASTLE_OBJ) + +GRADIENT_OBJ = \ + example/gradient.o \ + holly/core.o \ + holly/region_array.o \ + holly/background.o \ + holly/ta_fifo_polygon_converter.o \ + holly/video_output.o \ + sh7091/serial.o \ + texture/gradient/gradient.data.o \ + $(LIBGCC) + +example/gradient.elf: LDSCRIPT = $(LIB)/main.lds +example/gradient.elf: $(START_OBJ) $(GRADIENT_OBJ) diff --git a/example/gradient.cpp b/example/gradient.cpp new file mode 100644 index 0000000..534c55f --- /dev/null +++ b/example/gradient.cpp @@ -0,0 +1,417 @@ +#include + +#include "holly/background.hpp" +#include "holly/core.hpp" +#include "holly/core_bits.hpp" +#include "holly/holly.hpp" +#include "holly/isp_tsp.hpp" +#include "holly/region_array.hpp" +#include "holly/ta_bits.hpp" +#include "holly/ta_fifo_polygon_converter.hpp" +#include "holly/ta_global_parameter.hpp" +#include "holly/ta_parameter.hpp" +#include "holly/ta_vertex_parameter.hpp" +#include "holly/texture_memory_alloc3.hpp" +#include "holly/video_output.hpp" + +#include "sh7091/sh7091.hpp" +#include "sh7091/sh7091_bits.hpp" +#include "sh7091/serial.hpp" +#include "sh7091/vbr.hpp" + +#include "systembus.hpp" +#include "systembus_bits.hpp" + +#include "memorymap.hpp" + +#include "math/vec2.hpp" +#include "math/vec3.hpp" +#include "math/vec4.hpp" +#include "math/mat4x4.hpp" + +using vec2 = vec<2, float>; +using vec3 = vec<3, float>; +using vec4 = vec<4, float>; +using mat4x4 = mat<4, 4, float>; + +#include "texture/gradient/gradient.data.h" + +void vbr100() +{ + serial::string("vbr100\n"); + serial::string("expevt "); + serial::integer(sh7091.CCN.EXPEVT); + serial::string("intevt "); + serial::integer(sh7091.CCN.INTEVT); + serial::string("tra "); + serial::integer(sh7091.CCN.TRA); + + uint32_t spc; + uint32_t ssr; + asm volatile ("stc spc,%0" : "=r" (spc)); + asm volatile ("stc ssr,%0" : "=r" (ssr)); + serial::string("spc "); + serial::integer(spc); + serial::string("ssr "); + serial::integer(ssr); + + while (1); +} + +void vbr400() +{ + serial::string("vbr400\n"); + serial::string("expevt "); + serial::integer(sh7091.CCN.EXPEVT); + serial::string("intevt "); + serial::integer(sh7091.CCN.INTEVT); + serial::string("tra "); + serial::integer(sh7091.CCN.TRA); + + uint32_t spc; + uint32_t ssr; + asm volatile ("stc spc,%0" : "=r" (spc)); + asm volatile ("stc ssr,%0" : "=r" (ssr)); + serial::string("spc "); + serial::integer(spc); + serial::string("ssr "); + serial::integer(ssr); + + while (1); +} + +static int render_done = 0; + +void vbr600() +{ + if (sh7091.CCN.EXPEVT == 0 && sh7091.CCN.INTEVT == 0x320) { + uint32_t istnrm = system.ISTNRM; + uint32_t isterr = system.ISTERR; + + if (isterr) { + serial::string("isterr: "); + serial::integer(system.ISTERR); + } + + if (istnrm & istnrm::end_of_render_tsp) { + system.ISTNRM = istnrm::end_of_render_tsp + | istnrm::end_of_render_isp + | istnrm::end_of_render_video; + render_done = 1; + return; + } + } + + serial::string("vbr600\n"); + serial::string("expevt "); + serial::integer(sh7091.CCN.EXPEVT); + serial::string("intevt "); + serial::integer(sh7091.CCN.INTEVT); + serial::string("tra "); + serial::integer(sh7091.CCN.TRA); + + serial::string("istnrm: "); + serial::integer(system.ISTNRM); + serial::string("isterr: "); + serial::integer(system.ISTERR); + + uint32_t spc; + uint32_t ssr; + asm volatile ("stc spc,%0" : "=r" (spc)); + asm volatile ("stc ssr,%0" : "=r" (ssr)); + serial::string("spc "); + serial::integer(spc); + serial::string("ssr "); + serial::integer(ssr); + + while (1); +} + +void interrupt_init() +{ + system.IML2NRM = 0; + system.IML2ERR = 0; + system.IML2EXT = 0; + + system.IML4NRM = 0; + system.IML4ERR = 0; + system.IML4EXT = 0; + + system.IML6NRM = 0; + system.IML6ERR = 0; + system.IML6EXT = 0; + + system.ISTERR = 0xffffffff; + system.ISTNRM = 0xffffffff; + + sh7091.CCN.INTEVT = 0; + sh7091.CCN.EXPEVT = 0; + + uint32_t vbr = reinterpret_cast(&__vbr_link_start) - 0x100; + + asm volatile ("ldc %0,vbr" + : + : "r" (vbr)); + + uint32_t sr; + asm volatile ("stc sr,%0" + : "=r" (sr)); + serial::string("sr "); + serial::integer(sr); + + sr &= ~sh::sr::bl; // BL + sr &= ~sh::sr::imask(15); // imask + + serial::string("sr "); + serial::integer(sr); + + asm volatile ("ldc %0,sr" + : + : "r" (sr)); +} + +void global_polygon_type_0(ta_parameter_writer& writer, uint32_t texture_address, int width, int height) +{ + 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::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::fog_control::no_fog + | tsp_instruction_word::src_alpha_instr::one + | tsp_instruction_word::dst_alpha_instr::zero + | tsp_instruction_word::texture_u_size::from_int(width) + | tsp_instruction_word::texture_v_size::from_int(height) + | tsp_instruction_word::clamp_uv::uv + | tsp_instruction_word::filter_mode::bilinear_filter + ; + + 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); + + writer.append() = + ta_global_parameter::polygon_type_0(parameter_control_word, + isp_tsp_instruction_word, + tsp_instruction_word, + texture_control_word, + 0, // data_size_for_sort_dma + 0 // next_address_for_sort_dma + ); +} + +static inline void render_quad(ta_parameter_writer& writer, + uint32_t base_color, + vec3 ap, + vec3 bp, + vec3 cp, + vec3 dp, + vec2 at, + vec2 bt, + vec2 ct, + vec2 dt) +{ + if (ap.z < 0 || bp.z < 0 || cp.z < 0) + return; + + writer.append() = + ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false), + ap.x, ap.y, ap.z, + at.x, at.y, + base_color, + 0); // offset_color + + writer.append() = + ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false), + bp.x, bp.y, bp.z, + bt.x, bt.y, + base_color, + 0); // offset_color + + writer.append() = + ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(false), + dp.x, dp.y, dp.z, + dt.x, dt.y, + base_color, + 0); // offset_color + + writer.append() = + ta_vertex_parameter::polygon_type_3(polygon_vertex_parameter_control_word(true), + cp.x, cp.y, cp.z, + ct.x, ct.y, + base_color, + 0); // offset_color +} + +struct vertex { + vec3 pos; + vec2 tex; +}; + +struct vertex quad[] = { + {{ 0, 0, 0.1}, {0, 0}}, + {{640, 0, 0.1}, {1, 0}}, + {{640, 480, 0.1}, {1, 1}}, + {{ 0, 480, 0.1}, {0, 1}}, +}; + +void transfer_scene(ta_parameter_writer& writer) +{ + uint32_t texture_address = texture_memory_alloc.texture.start; + global_polygon_type_0(writer, texture_address, 8, 8); + + render_quad(writer, 0, + quad[0].pos, + quad[1].pos, + quad[2].pos, + quad[3].pos, + quad[0].tex, + quad[1].tex, + quad[2].tex, + quad[3].tex); + + writer.append() = + ta_global_parameter::end_of_list(para_control::para_type::end_of_list); +} + +void transfer_ta_fifo_texture_memory_32byte(void * dst, const void * src, int length) +{ + uint32_t out_addr = (uint32_t)dst; + sh7091.CCN.QACR0 = ((reinterpret_cast(out_addr) >> 24) & 0b11100); + sh7091.CCN.QACR1 = ((reinterpret_cast(out_addr) >> 24) & 0b11100); + + volatile uint32_t * base = &store_queue[(out_addr & 0x03ffffc0) / 4]; + const uint32_t * src32 = reinterpret_cast(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"); + length -= 32; + base += 8; + src32 += 8; + } +} + +void transfer_texture() +{ + void * start = (void *)&_binary_texture_gradient_gradient_data_start; + int size = (int)&_binary_texture_gradient_gradient_data_size; + uint32_t offset = texture_memory_alloc.texture.start; + void * dst = (void *)(&texture_memory64[offset / 4]); + + transfer_ta_fifo_texture_memory_32byte(dst, start, size); +} + +void transfer_textures() +{ + system.LMMODE0 = 0; // 64-bit address space + system.LMMODE1 = 0; // 64-bit address space + + transfer_texture(); +} + +static uint8_t __attribute__((aligned(32))) ta_parameter_buf[1024 * 1024] = {0}; + +void main() +{ + serial::init(0); + + interrupt_init(); + + constexpr uint32_t ta_alloc = 0 + | ta_alloc_ctrl::pt_opb::no_list + | ta_alloc_ctrl::tm_opb::no_list + | ta_alloc_ctrl::t_opb::no_list + | ta_alloc_ctrl::om_opb::no_list + | ta_alloc_ctrl::o_opb::_16x4byte; + + constexpr int render_passes = 1; + constexpr struct opb_size opb_size[render_passes] = { + { + .opaque = 16 * 4, + .opaque_modifier = 0, + .translucent = 0, + .translucent_modifier = 0, + .punch_through = 0 + } + }; + + holly.SOFTRESET = softreset::pipeline_soft_reset + | softreset::ta_soft_reset; + holly.SOFTRESET = 0; + + core_init(); + + system.IML6NRM = istnrm::end_of_render_tsp; + + const int framebuffer_width = 640; + const int framebuffer_height = 480; + const int tile_width = framebuffer_width / 32; + const int tile_height = framebuffer_height / 32; + + for (int i = 0; i < 2; i++) { + region_array_multipass(tile_width, + tile_height, + opb_size, + render_passes, + texture_memory_alloc.region_array[i].start, + texture_memory_alloc.object_list[i].start); + + background_parameter2(texture_memory_alloc.background[i].start, + 0xff202040); + } + + int ta = 0; + int core = 0; + + ta_parameter_writer writer = ta_parameter_writer(ta_parameter_buf); + + transfer_textures(); + video_output::set_mode_vga(); + + while (1) { + ta_polygon_converter_init2(texture_memory_alloc.isp_tsp_parameters[ta].start, + texture_memory_alloc.isp_tsp_parameters[ta].end, + texture_memory_alloc.object_list[ta].start, + texture_memory_alloc.object_list[ta].end, + opb_size[0].total(), + ta_alloc, + tile_width, + tile_height); + writer.offset = 0; + transfer_scene(writer); + ta_polygon_converter_writeback(writer.buf, writer.offset); + ta_polygon_converter_transfer(writer.buf, writer.offset); + ta_wait_opaque_list(); + + render_done = 0; + core_start_render2(texture_memory_alloc.region_array[core].start, + texture_memory_alloc.isp_tsp_parameters[core].start, + texture_memory_alloc.background[core].start, + texture_memory_alloc.framebuffer[core].start, + framebuffer_width); + //serial::string("wait render_done"); + while (render_done == 0) { + asm volatile ("nop"); + }; + + while (!spg_status::vsync(holly.SPG_STATUS)); + holly.FB_R_SOF1 = texture_memory_alloc.framebuffer[ta].start; + while (spg_status::vsync(holly.SPG_STATUS)); + } +} diff --git a/texture/gradient.png b/texture/gradient.png new file mode 100644 index 0000000000000000000000000000000000000000..c374e96e7967e9ac36b3ddb62756b74470828257 GIT binary patch literal 576 zcmV-G0>AxEX>4Tx04R}tkvmAkP!xv$rbwL9PY<|@Bee|xq#59FwN?k1vK3@ z)5(OG&8>=|R|GLa6~nm9EMrcRQt(}0_XzO)F3z+3@BO*@)V#%jfJi*c4AUmwAfDc| z4bJ<-5mu5_;&b9LlNuy`KlnXct1vm?C500}_lx6vi~^xupjmgE?_G!(3*Ffg>2oB#j-32;bR za{vGf6951U69E94oEQKA00(qQO+^Rk10Dq|7q-xr6aWAK8FWQhbVF}#ZDnqB07G(R zVRU6=Aa`kWXdp*PO;A^X4i^9b02N6@K~xCWV_*P-&`^d|t3U|I03!f1 + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_gradient_gradient_data_start __asm("_binary_texture_gradient_gradient_data_start"); +extern uint32_t _binary_texture_gradient_gradient_data_end __asm("_binary_texture_gradient_gradient_data_end"); +extern uint32_t _binary_texture_gradient_gradient_data_size __asm("_binary_texture_gradient_gradient_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/gradient/gradient.png b/texture/gradient/gradient.png new file mode 100644 index 0000000000000000000000000000000000000000..c374e96e7967e9ac36b3ddb62756b74470828257 GIT binary patch literal 576 zcmV-G0>AxEX>4Tx04R}tkvmAkP!xv$rbwL9PY<|@Bee|xq#59FwN?k1vK3@ z)5(OG&8>=|R|GLa6~nm9EMrcRQt(}0_XzO)F3z+3@BO*@)V#%jfJi*c4AUmwAfDc| z4bJ<-5mu5_;&b9LlNuy`KlnXct1vm?C500}_lx6vi~^xupjmgE?_G!(3*Ffg>2oB#j-32;bR za{vGf6951U69E94oEQKA00(qQO+^Rk10Dq|7q-xr6aWAK8FWQhbVF}#ZDnqB07G(R zVRU6=Aa`kWXdp*PO;A^X4i^9b02N6@K~xCWV_*P-&`^d|t3U|I03!f1