198 lines
7.3 KiB
C++
198 lines
7.3 KiB
C++
#include "memorymap.hpp"
|
|
|
|
#include "holly/core/object_list_bits.hpp"
|
|
#include "holly/core/region_array.hpp"
|
|
#include "holly/core/region_array_bits.hpp"
|
|
#include "holly/core/parameter_bits.hpp"
|
|
#include "holly/core/parameter.hpp"
|
|
#include "holly/holly.hpp"
|
|
#include "holly/holly_bits.hpp"
|
|
|
|
#include "sh7091/store_queue_transfer.hpp"
|
|
|
|
void transfer_object_list(uint32_t object_list_start, uint32_t triangle_array_offset)
|
|
{
|
|
using namespace holly::core;
|
|
|
|
volatile uint32_t * object_list = (volatile uint32_t *)&texture_memory32[object_list_start];
|
|
|
|
object_list[0] = object_list::pointer_type::triangle_array
|
|
| object_list::triangle_array::number_of_triangles(0)
|
|
| object_list::triangle_array::skip(1)
|
|
| object_list::triangle_array::start(triangle_array_offset / 4);
|
|
|
|
object_list[1] = object_list::pointer_type::object_pointer_block_link
|
|
| object_list::object_pointer_block_link::end_of_list;
|
|
}
|
|
|
|
void transfer_background_polygon(uint32_t isp_tsp_parameter_start, uint32_t texture_start)
|
|
{
|
|
using namespace holly::core::parameter;
|
|
|
|
using parameter = isp_tsp_parameter<3, texture>;
|
|
|
|
volatile parameter * polygon = (volatile parameter *)&texture_memory32[isp_tsp_parameter_start];
|
|
|
|
polygon->isp_tsp_instruction_word = isp_tsp_instruction_word::depth_compare_mode::always
|
|
| isp_tsp_instruction_word::culling_mode::no_culling
|
|
| isp_tsp_instruction_word::texture;
|
|
|
|
polygon->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::texture_shading_instruction::decal
|
|
| tsp_instruction_word::texture_u_size::_1024
|
|
| tsp_instruction_word::texture_v_size::_512;
|
|
|
|
polygon->texture_control_word = texture_control_word::pixel_format::rgb565
|
|
| texture_control_word::scan_order::non_twiddled
|
|
| texture_control_word::stride_select
|
|
| texture_control_word::texture_address(texture_start / 8);
|
|
|
|
polygon->vertex[0].x = 0.0f;
|
|
polygon->vertex[0].y = 0.0f;
|
|
polygon->vertex[0].z = 0.00001f;
|
|
polygon->vertex[0].u = 0.0f;
|
|
polygon->vertex[0].v = 0.0f;
|
|
polygon->vertex[0].base_color = 0;
|
|
|
|
polygon->vertex[1].x = 640.0f;
|
|
polygon->vertex[1].y = 0.0f;
|
|
polygon->vertex[1].z = 0.00001f;
|
|
polygon->vertex[1].u = 640.0f / 1024.0f;
|
|
polygon->vertex[1].v = 0.0f;
|
|
polygon->vertex[1].base_color = 0;
|
|
|
|
polygon->vertex[2].x = 640.0f;
|
|
polygon->vertex[2].y = 480.0f;
|
|
polygon->vertex[2].z = 0.00001f;
|
|
polygon->vertex[2].u = 640.0f / 1024.0f;
|
|
polygon->vertex[2].v = 480.0f / 512.0f;
|
|
polygon->vertex[2].base_color = 0;
|
|
}
|
|
|
|
void transfer_region_array(uint32_t region_array_start,
|
|
uint32_t opaque_list_pointer)
|
|
{
|
|
using namespace holly::core::region_array;
|
|
/*
|
|
Create a minimal region array with a single entry:
|
|
- one tile at tile coordinate (0, 0) with one opaque list pointer
|
|
*/
|
|
|
|
/*
|
|
Holly reads the region array from "32-bit" texture memory address space,
|
|
so the region array is correspondingly written from "32-bit" address space.
|
|
*/
|
|
volatile region_array_entry * region_array = (volatile region_array_entry *)&texture_memory32[region_array_start];
|
|
|
|
const int num_tiles_y = 480 / 32;
|
|
const int num_tiles_x = 640 / 32;
|
|
const int num_tiles = num_tiles_x * num_tiles_y;
|
|
|
|
for (int i = 0; i < num_tiles; i++) {
|
|
/* define one region array entry per 32×32 px tile over a 640x480 px area */
|
|
|
|
int y = i / num_tiles_x;
|
|
int x = i % num_tiles_x;
|
|
|
|
bool last_tile = (i == (num_tiles - 1));
|
|
|
|
region_array[i].tile
|
|
= (last_tile ? tile::last_region : 0)
|
|
| tile::y_position(y)
|
|
| tile::x_position(x);
|
|
|
|
/*
|
|
list pointers are offsets relative to the beginning of "32-bit" texture memory.
|
|
|
|
each list type uses different rasterization steps, "opaque" being the fastest and most efficient.
|
|
*/
|
|
region_array[i].list_pointer.opaque = list_pointer::empty;
|
|
region_array[i].list_pointer.opaque_modifier_volume = list_pointer::empty;
|
|
region_array[i].list_pointer.translucent = list_pointer::empty;
|
|
region_array[i].list_pointer.translucent_modifier_volume = list_pointer::empty;
|
|
region_array[i].list_pointer.punch_through = list_pointer::empty;
|
|
}
|
|
}
|
|
|
|
const uint8_t texture[] __attribute__((aligned(4))) = {
|
|
#embed "texture/tdk_head_cleaner_640x480.rgb565"
|
|
};
|
|
|
|
void transfer_texture(uint32_t texture_start)
|
|
{
|
|
// use 4-byte transfers to texture memory, for slightly increased transfer
|
|
// speed
|
|
//
|
|
// It would be even faster to use the SH4 store queue for this operation, or
|
|
// SH4 DMA.
|
|
|
|
sh7091::store_queue_transfer::copy((void *)&texture_memory64[texture_start], texture, (sizeof (texture)));
|
|
}
|
|
|
|
void main()
|
|
{
|
|
uint32_t framebuffer_start = 0x200000;
|
|
uint32_t isp_tsp_parameter_start = 0x400000;
|
|
uint32_t region_array_start = 0x500000;
|
|
uint32_t object_list_start = 0x100000;
|
|
|
|
uint32_t texture_start = 0x700000;
|
|
|
|
transfer_region_array(region_array_start,
|
|
object_list_start);
|
|
|
|
using polygon = holly::core::parameter::isp_tsp_parameter<3, holly::core::parameter::texture>;
|
|
|
|
uint32_t background_offset = (sizeof (polygon)) * 0;
|
|
uint32_t triangle_offset = (sizeof (polygon)) * 1;
|
|
|
|
transfer_object_list(object_list_start,
|
|
triangle_offset);
|
|
|
|
transfer_background_polygon(isp_tsp_parameter_start + background_offset,
|
|
texture_start);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// transfer the texture image to texture ram
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
transfer_texture(texture_start);
|
|
|
|
{
|
|
using namespace holly;
|
|
using holly::holly;
|
|
|
|
// REGION_BASE is the (texture memory-relative) address of the region array.
|
|
holly.REGION_BASE = region_array_start;
|
|
|
|
// PARAM_BASE is the (texture memory-relative) address of ISP/TSP parameters.
|
|
// Anything that references an ISP/TSP parameter does so relative to this
|
|
// address (and not relative to the beginning of texture memory).
|
|
holly.PARAM_BASE = isp_tsp_parameter_start;
|
|
|
|
// Set the offset of the background ISP/TSP parameter, relative to PARAM_BASE
|
|
// SKIP is related to the size of each vertex
|
|
holly.ISP_BACKGND_T = isp_backgnd_t::tag_address(background_offset / 4)
|
|
| isp_backgnd_t::tag_offset(0)
|
|
| isp_backgnd_t::skip(3);
|
|
|
|
holly.ISP_BACKGND_D = 0.000001f;
|
|
|
|
// FB_W_SOF1 is the (texture memory-relative) address of the framebuffer that
|
|
// will be written to when a tile is rendered/flushed.
|
|
holly.FB_W_SOF1 = framebuffer_start;
|
|
|
|
holly.TEXT_CONTROL = text_control::stride(640 / 32);
|
|
|
|
// start the actual render--the rendering process begins by interpreting the
|
|
// region array
|
|
holly.STARTRENDER = 1;
|
|
|
|
// without waiting for rendering to actually complete, immediately display the
|
|
// framebuffer.
|
|
holly.FB_R_SOF1 = framebuffer_start;
|
|
}
|
|
}
|