bilbo/dreamcast
1
0
Fork 0
Code Pull Requests Activity

Compare commits

base: bilbo:9ecb8c6f5f17810e3da4c0b211cda64e6504fee2
Branches Tags
bilbo:main
bilbo:long-samples
..
compare: bilbo:45f8661b9368823ccb7069b26f9a54bd52e700fb
Branches Tags
bilbo:main
bilbo:long-samples

No commits in common. "9ecb8c6f5f17810e3da4c0b211cda64e6504fee2" and "45f8661b9368823ccb7069b26f9a54bd52e700fb" have entirely different histories.
9ecb8c6f5f ... 45f8661b93

26 changed files with 194 additions and 1846 deletions
Show Stats Expand all files Collapse all files

14
dreamcast2/example/example.mk
View File

@ -9,20 +9,8 @@ example/framebuffer_shaded.elf: LDSCRIPT = $(LIB)/main.lds
example/framebuffer_shaded.elf: $(START_OBJ) $(FRAMEBUFFER_SHADED_OBJ)
TRIANGLE_CORE_OBJ = \
holly/core/region_array.o \
example/triangle_core.o
example/triangle_core.elf: LDSCRIPT = $(LIB)/main.lds
example/triangle_core.elf: $(START_OBJ) $(TRIANGLE_CORE_OBJ)
TRIANGLE_TA_OBJ = \
example/triangle_ta.o
example/triangle_ta.elf: LDSCRIPT = $(LIB)/main.lds
example/triangle_ta.elf: $(START_OBJ) $(TRIANGLE_TA_OBJ)
TRIANGLE_TA_FULLSCREEN_OBJ = \
holly/core/region_array.o \
example/triangle_ta_fullscreen.o
example/triangle_ta_fullscreen.elf: LDSCRIPT = $(LIB)/main.lds
example/triangle_ta_fullscreen.elf: $(START_OBJ) $(TRIANGLE_TA_FULLSCREEN_OBJ)

4
dreamcast2/example/triangle_core.cpp
View File

@ -135,8 +135,8 @@ void main()
using polygon = holly::core::parameter::isp_tsp_parameter<3>;
uint32_t background_offset = (sizeof (polygon)) * 0;
uint32_t triangle_offset = (sizeof (polygon)) * 1;
uint32_t triangle_offset = (sizeof (polygon)) * 0;
uint32_t background_offset = (sizeof (polygon)) * 1;
transfer_object_list(object_list_start,
triangle_offset);

287
dreamcast2/example/triangle_ta.cpp
View File

@ -1,287 +0,0 @@
#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/ta/global_parameter.hpp"
#include "holly/ta/vertex_parameter.hpp"
#include "holly/ta/parameter_bits.hpp"
#include "holly/holly.hpp"
#include "holly/holly_bits.hpp"
#include "sh7091/sh7091.hpp"
#include "sh7091/pref.hpp"
void transfer_background_polygon(uint32_t isp_tsp_parameter_start)
{
using namespace holly::core::parameter;
using parameter = isp_tsp_parameter<3>;
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;
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;
polygon->texture_control_word = 0;
polygon->vertex[0].x = 0.0f;
polygon->vertex[0].y = 0.0f;
polygon->vertex[0].z = 0.00001f;
polygon->vertex[0].base_color = 0xff00ff;
polygon->vertex[1].x = 32.0f;
polygon->vertex[1].y = 0.0f;
polygon->vertex[1].z = 0.00001f;
polygon->vertex[1].base_color = 0xff00ff;
polygon->vertex[2].x = 32.0f;
polygon->vertex[2].y = 32.0f;
polygon->vertex[2].z = 0.00001f;
polygon->vertex[2].base_color = 0xff00ff;
}
void transfer_ta_triangle()
{
using namespace sh7091;
using sh7091::sh7091;
sh7091.CCN.QACR0 = sh7091::ccn::qacr0::address(ta_fifo_polygon_converter);
sh7091.CCN.QACR1 = sh7091::ccn::qacr1::address(ta_fifo_polygon_converter);
uint32_t store_queue_ix = 0;
using namespace holly::core::parameter;
using namespace holly::ta;
using namespace holly::ta::parameter;
//
// TA polygon global transfer
//
volatile global_parameter::polygon_type_0 * polygon = (volatile global_parameter::polygon_type_0 *)&store_queue[store_queue_ix];
store_queue_ix += (sizeof (global_parameter::polygon_type_0));
polygon->parameter_control_word = parameter_control_word::para_type::polygon_or_modifier_volume
| parameter_control_word::list_type::opaque
| parameter_control_word::col_type::packed_color
| parameter_control_word::gouraud;
polygon->isp_tsp_instruction_word = isp_tsp_instruction_word::depth_compare_mode::always
| isp_tsp_instruction_word::culling_mode::no_culling;
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;
pref(polygon);
//
// TA polygon vertex transfer
//
volatile vertex_parameter::polygon_type_0 * vertex = (volatile vertex_parameter::polygon_type_0 *)&store_queue[store_queue_ix];
store_queue_ix += (sizeof (vertex_parameter::polygon_type_0)) * 3;
// bottom left
vertex[0].parameter_control_word = parameter_control_word::para_type::vertex_parameter;
vertex[0].x = 1.0f;
vertex[0].y = 29.0f;
vertex[0].z = 0.1f;
vertex[0].base_color = 0xff0000; // red
// start store queue transfer of `vertex[0]` to the TA
pref(&vertex[0]);
// top center
vertex[1].parameter_control_word = parameter_control_word::para_type::vertex_parameter;
vertex[1].x = 16.0f;
vertex[1].y = 3.0f;
vertex[1].z = 0.1f;
vertex[1].base_color = 0x00ff00; // green
// start store queue transfer of `vertex[1]` to the TA
pref(&vertex[1]);
// bottom right
vertex[2].parameter_control_word = parameter_control_word::para_type::vertex_parameter
| parameter_control_word::end_of_strip;
vertex[2].x = 31.0f;
vertex[2].y = 29.0f;
vertex[2].z = 0.1f;
vertex[2].base_color = 0x0000ff; // blue
// start store queue transfer of `params[2]` to the TA
pref(&vertex[2]);
//
// TA "end of list" global transfer
//
volatile global_parameter::end_of_list * end_of_list = (volatile global_parameter::end_of_list *)&store_queue[store_queue_ix];
store_queue_ix += (sizeof (global_parameter::end_of_list));
end_of_list->parameter_control_word = parameter_control_word::para_type::end_of_list;
// start store queue transfer of `end_of_list` to the TA
pref(end_of_list);
}
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];
region_array[0].tile
= tile::last_region
| tile::y_position(0)
| tile::x_position(0);
/*
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[0].list_pointer.opaque = list_pointer::object_list(opaque_list_pointer);
region_array[0].list_pointer.opaque_modifier_volume = list_pointer::empty;
region_array[0].list_pointer.translucent = list_pointer::empty;
region_array[0].list_pointer.translucent_modifier_volume = list_pointer::empty;
region_array[0].list_pointer.punch_through = list_pointer::empty;
}
void main()
{
/*
a very simple memory map:
the ordering within texture memory is not significant, and could be
anything
*/
uint32_t framebuffer_start = 0x200000; // intentionally the same address that the boot rom used to draw the SEGA logo
uint32_t isp_tsp_parameter_start = 0x400000;
uint32_t region_array_start = 0x500000;
uint32_t object_list_start = 0x100000;
transfer_region_array(region_array_start,
object_list_start);
transfer_background_polygon(isp_tsp_parameter_start);
//////////////////////////////////////////////////////////////////////////////
// configure the TA
//////////////////////////////////////////////////////////////////////////////
const int tile_y_num = 1;
const int tile_x_num = 1;
using namespace holly;
using holly::holly;
// TA_GLOB_TILE_CLIP restricts which "object pointer blocks" are written
// to.
//
// This can also be used to implement "windowing", as long as the desired
// window size happens to be a multiple of 32 pixels. The "User Tile Clip" TA
// control parameter can also ~equivalently be used as many times as desired
// within a single TA initialization to produce an identical effect.
//
// See DCDBSysArc990907E.pdf page 183.
holly.TA_GLOB_TILE_CLIP = ta_glob_tile_clip::tile_y_num(tile_y_num - 1)
| ta_glob_tile_clip::tile_x_num(tile_x_num - 1);
// While CORE supports arbitrary-length object lists, the TA uses "object
// pointer blocks" as a memory allocation strategy. These fixed-length blocks
// can still have infinite length via "object pointer block links". This
// mechanism is illustrated in DCDBSysArc990907E.pdf page 188.
holly.TA_ALLOC_CTRL = ta_alloc_ctrl::opb_mode::increasing_addresses
| ta_alloc_ctrl::o_opb::_8x4byte;
// While building object lists, the TA contains an internal index (exposed as
// the read-only TA_ITP_CURRENT) for the next address that new ISP/TSP will be
// stored at. The initial value of this index is TA_ISP_BASE.
// reserve space in ISP/TSP parameters for the background parameter
using polygon = holly::core::parameter::isp_tsp_parameter<3>;
uint32_t ta_isp_base_offset = (sizeof (polygon)) * 1;
holly.TA_ISP_BASE = isp_tsp_parameter_start + ta_isp_base_offset;
holly.TA_ISP_LIMIT = isp_tsp_parameter_start + 0x100000;
// Similarly, the TA also contains, for up to 600 tiles, an internal index for
// the next address that an object list entry will be stored for each
// tile. These internal indicies are partially exposed via the read-only
// TA_OL_POINTERS.
holly.TA_OL_BASE = object_list_start;
// TA_OL_LIMIT, DCDBSysArc990907E.pdf page 385:
//
// > Because the TA may automatically store data in the address that is
// > specified by this register, it must not be used for other data. For
// > example, the address specified here must not be the same as the address
// > in the TA_ISP_BASE register.
holly.TA_OL_LIMIT = object_list_start + 0x100000 - 32;
holly.TA_LIST_INIT = ta_list_init::list_init;
// dummy TA_LIST_INIT read; DCDBSysArc990907E.pdf in multiple places says this
// step is required.
(void)holly.TA_LIST_INIT;
//////////////////////////////////////////////////////////////////////////////
// transfer triangles to texture memory via the TA polygon converter FIFO
//////////////////////////////////////////////////////////////////////////////
transfer_ta_triangle();
//////////////////////////////////////////////////////////////////////////////
// configure CORE
//////////////////////////////////////////////////////////////////////////////
// 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
uint32_t background_offset = 0;
holly.ISP_BACKGND_T = isp_backgnd_t::tag_address(background_offset / 4)
| isp_backgnd_t::tag_offset(0)
| isp_backgnd_t::skip(1);
// 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;
// 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;
// return from main; this will effectively jump back to the serial loader
while (1);
}

264
dreamcast2/example/triangle_ta_fullscreen.cpp
View File

@ -1,264 +0,0 @@
#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/ta/global_parameter.hpp"
#include "holly/ta/vertex_parameter.hpp"
#include "holly/ta/parameter_bits.hpp"
#include "holly/holly.hpp"
#include "holly/holly_bits.hpp"
#include "sh7091/sh7091.hpp"
#include "sh7091/pref.hpp"
void transfer_background_polygon(uint32_t isp_tsp_parameter_start)
{
using namespace holly::core::parameter;
using parameter = isp_tsp_parameter<3>;
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;
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;
polygon->texture_control_word = 0;
polygon->vertex[0].x = 0.0f;
polygon->vertex[0].y = 0.0f;
polygon->vertex[0].z = 0.00001f;
polygon->vertex[0].base_color = 0xff00ff;
polygon->vertex[1].x = 32.0f;
polygon->vertex[1].y = 0.0f;
polygon->vertex[1].z = 0.00001f;
polygon->vertex[1].base_color = 0xff00ff;
polygon->vertex[2].x = 32.0f;
polygon->vertex[2].y = 32.0f;
polygon->vertex[2].z = 0.00001f;
polygon->vertex[2].base_color = 0xff00ff;
}
void transfer_ta_triangle()
{
using namespace sh7091;
using sh7091::sh7091;
sh7091.CCN.QACR0 = sh7091::ccn::qacr0::address(ta_fifo_polygon_converter);
sh7091.CCN.QACR1 = sh7091::ccn::qacr1::address(ta_fifo_polygon_converter);
uint32_t store_queue_ix = 0;
using namespace holly::core::parameter;
using namespace holly::ta;
using namespace holly::ta::parameter;
//
// TA polygon global transfer
//
volatile global_parameter::polygon_type_0 * polygon = (volatile global_parameter::polygon_type_0 *)&store_queue[store_queue_ix];
store_queue_ix += (sizeof (global_parameter::polygon_type_0));
polygon->parameter_control_word = parameter_control_word::para_type::polygon_or_modifier_volume
| parameter_control_word::list_type::opaque
| parameter_control_word::col_type::packed_color
| parameter_control_word::gouraud;
polygon->isp_tsp_instruction_word = isp_tsp_instruction_word::depth_compare_mode::always
| isp_tsp_instruction_word::culling_mode::no_culling;
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;
pref(polygon);
//
// TA polygon vertex transfer
//
volatile vertex_parameter::polygon_type_0 * vertex = (volatile vertex_parameter::polygon_type_0 *)&store_queue[store_queue_ix];
store_queue_ix += (sizeof (vertex_parameter::polygon_type_0)) * 3;
// bottom left
vertex[0].parameter_control_word = parameter_control_word::para_type::vertex_parameter;
vertex[0].x = 77.0f;
vertex[0].y = 450.0f;
vertex[0].z = 0.1f;
vertex[0].base_color = 0xff0000; // red
// start store queue transfer of `vertex[0]` to the TA
pref(&vertex[0]);
// top center
vertex[1].parameter_control_word = parameter_control_word::para_type::vertex_parameter;
vertex[1].x = 320.0f;
vertex[1].y = 30.0f;
vertex[1].z = 0.1f;
vertex[1].base_color = 0x00ff00; // green
// start store queue transfer of `vertex[1]` to the TA
pref(&vertex[1]);
// bottom right
vertex[2].parameter_control_word = parameter_control_word::para_type::vertex_parameter
| parameter_control_word::end_of_strip;
vertex[2].x = 562.0f;
vertex[2].y = 450.0f;
vertex[2].z = 0.1f;
vertex[2].base_color = 0x0000ff; // blue
// start store queue transfer of `params[2]` to the TA
pref(&vertex[2]);
//
// TA "end of list" global transfer
//
volatile global_parameter::end_of_list * end_of_list = (volatile global_parameter::end_of_list *)&store_queue[store_queue_ix];
store_queue_ix += (sizeof (global_parameter::end_of_list));
end_of_list->parameter_control_word = parameter_control_word::para_type::end_of_list;
// start store queue transfer of `end_of_list` to the TA
pref(end_of_list);
}
void main()
{
/*
a very simple memory map:
the ordering within texture memory is not significant, and could be
anything
*/
uint32_t framebuffer_start = 0x200000; // intentionally the same address that the boot rom used to draw the SEGA logo
uint32_t isp_tsp_parameter_start = 0x400000;
uint32_t region_array_start = 0x500000;
uint32_t object_list_start = 0x100000;
const int tile_y_num = 480 / 32;
const int tile_x_num = 640 / 32;
using namespace holly::core;
region_array::list_block_size list_block_size = {
.opaque = 8 * 4,
};
region_array::transfer(tile_x_num,
tile_y_num,
list_block_size,
region_array_start,
object_list_start);
transfer_background_polygon(isp_tsp_parameter_start);
//////////////////////////////////////////////////////////////////////////////
// configure the TA
//////////////////////////////////////////////////////////////////////////////
using namespace holly;
using holly::holly;
// TA_GLOB_TILE_CLIP restricts which "object pointer blocks" are written
// to.
//
// This can also be used to implement "windowing", as long as the desired
// window size happens to be a multiple of 32 pixels. The "User Tile Clip" TA
// control parameter can also ~equivalently be used as many times as desired
// within a single TA initialization to produce an identical effect.
//
// See DCDBSysArc990907E.pdf page 183.
holly.TA_GLOB_TILE_CLIP = ta_glob_tile_clip::tile_y_num(tile_y_num - 1)
| ta_glob_tile_clip::tile_x_num(tile_x_num - 1);
// While CORE supports arbitrary-length object lists, the TA uses "object
// pointer blocks" as a memory allocation strategy. These fixed-length blocks
// can still have infinite length via "object pointer block links". This
// mechanism is illustrated in DCDBSysArc990907E.pdf page 188.
holly.TA_ALLOC_CTRL = ta_alloc_ctrl::opb_mode::increasing_addresses
| ta_alloc_ctrl::o_opb::_8x4byte;
// While building object lists, the TA contains an internal index (exposed as
// the read-only TA_ITP_CURRENT) for the next address that new ISP/TSP will be
// stored at. The initial value of this index is TA_ISP_BASE.
// reserve space in ISP/TSP parameters for the background parameter
using polygon = holly::core::parameter::isp_tsp_parameter<3>;
uint32_t ta_isp_base_offset = (sizeof (polygon)) * 1;
holly.TA_ISP_BASE = isp_tsp_parameter_start + ta_isp_base_offset;
holly.TA_ISP_LIMIT = isp_tsp_parameter_start + 0x100000;
// Similarly, the TA also contains, for up to 600 tiles, an internal index for
// the next address that an object list entry will be stored for each
// tile. These internal indicies are partially exposed via the read-only
// TA_OL_POINTERS.
holly.TA_OL_BASE = object_list_start;
// TA_OL_LIMIT, DCDBSysArc990907E.pdf page 385:
//
// > Because the TA may automatically store data in the address that is
// > specified by this register, it must not be used for other data. For
// > example, the address specified here must not be the same as the address
// > in the TA_ISP_BASE register.
holly.TA_OL_LIMIT = object_list_start + 0x100000 - 32;
holly.TA_LIST_INIT = ta_list_init::list_init;
// dummy TA_LIST_INIT read; DCDBSysArc990907E.pdf in multiple places says this
// step is required.
(void)holly.TA_LIST_INIT;
//////////////////////////////////////////////////////////////////////////////
// transfer triangles to texture memory via the TA polygon converter FIFO
//////////////////////////////////////////////////////////////////////////////
transfer_ta_triangle();
//////////////////////////////////////////////////////////////////////////////
// configure CORE
//////////////////////////////////////////////////////////////////////////////
// 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
uint32_t background_offset = 0;
holly.ISP_BACKGND_T = isp_backgnd_t::tag_address(background_offset / 4)
| isp_backgnd_t::tag_offset(0)
| isp_backgnd_t::skip(1);
// 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;
// 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;
// return from main; this will effectively jump back to the serial loader
while (1);
}

18
dreamcast2/holly/core/object_list_bits.hpp
View File

@ -25,27 +25,27 @@ namespace holly::core::object_list {
}
constexpr uint32_t shadow = 1 << 24;
constexpr inline uint32_t skip(uint32_t num) { return (num & 0x7) << 21; }
constexpr inline uint32_t start(uint32_t num) { return (num & 0x1fffff) << 0; }
constexpr uint32_t skip(uint32_t num) { return (num & 0x7) << 21; }
constexpr uint32_t start(uint32_t num) { return (num & 0x1fffff) << 0; }
}
namespace triangle_array {
constexpr inline uint32_t number_of_triangles(uint32_t num) { return (num & 0xf) << 25; }
constexpr uint32_t number_of_triangles(uint32_t num) { return (num & 0xf) << 25; }
constexpr uint32_t shadow = 1 << 24;
constexpr inline uint32_t skip(uint32_t num) { return (num & 0x7) << 21; }
constexpr inline uint32_t start(uint32_t num) { return (num & 0x1fffff) << 0; }
constexpr uint32_t skip(uint32_t num) { return (num & 0x7) << 21; }
constexpr uint32_t start(uint32_t num) { return (num & 0x1fffff) << 0; }
}
namespace quad_array {
constexpr inline uint32_t number_of_quads(uint32_t num) { return (num & 0xf) << 25; }
constexpr uint32_t number_of_quads(uint32_t num) { return (num & 0xf) << 25; }
constexpr uint32_t shadow = 1 << 24;
constexpr inline uint32_t skip(uint32_t num) { return (num & 0x7) << 21; }
constexpr inline uint32_t start(uint32_t num) { return (num & 0x1fffff) << 0; }
constexpr uint32_t skip(uint32_t num) { return (num & 0x7) << 21; }
constexpr uint32_t start(uint32_t num) { return (num & 0x1fffff) << 0; }
}
namespace object_pointer_block_link {
constexpr uint32_t end_of_list = 1 << 28;
constexpr inline uint32_t next_pointer_block(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t next_pointer_block(uint32_t num) { return (num & 0xfffffc) << 0; }
}
}

2
dreamcast2/holly/core/parameter.hpp
View File

@ -1,5 +1,3 @@
#pragma once
#include <cstdint>
namespace holly::core::parameter {

10
dreamcast2/holly/core/parameter_bits.hpp
View File

@ -125,7 +125,7 @@ namespace holly::core::parameter {
}
constexpr uint32_t super_sample_texture = 1 << 12;
constexpr inline uint32_t mip_map_d_adjust(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t mip_map_d_adjust(uint32_t num) { return (num & 0xf) << 8; }
namespace texture_shading_instruction {
constexpr uint32_t decal = 0 << 6;
@ -186,10 +186,10 @@ namespace holly::core::parameter {
constexpr uint32_t bit_mask = 0x1 << 26;
}
constexpr inline uint32_t palette_selector4(uint32_t num) { return (num & 0x3f) << 21; }
constexpr inline uint32_t palette_selector8(uint32_t num) { return (num & 0x3) << 25; }
constexpr inline uint32_t stride_select(uint32_t reg) { return (reg >> 25) & 0x1; }
constexpr inline uint32_t texture_address(uint32_t num) { return (num & 0x1fffff) << 0; }
constexpr uint32_t palette_selector4(uint32_t num) { return (num & 0x3f) << 21; }
constexpr uint32_t palette_selector8(uint32_t num) { return (num & 0x3) << 25; }
constexpr uint32_t stride_select(uint32_t reg) { return (reg >> 25) & 0x1; }
constexpr uint32_t texture_address(uint32_t num) { return (num & 0x1fffff) << 0; }
}
}

6
dreamcast2/holly/core/region_array_bits.hpp
View File

@ -8,13 +8,13 @@ namespace holly::core::region_array {
constexpr uint32_t z_clear = 1 << 30;
constexpr uint32_t pre_sort = 1 << 29;
constexpr uint32_t flush_accumulate = 1 << 28;
constexpr inline uint32_t y_position(uint32_t num) { return (num & 0x3f) << 8; }
constexpr inline uint32_t x_position(uint32_t num) { return (num & 0x3f) << 2; }
constexpr uint32_t y_position(uint32_t num) { return (num & 0x3f) << 8; }
constexpr uint32_t x_position(uint32_t num) { return (num & 0x3f) << 2; }
}
namespace list_pointer {
constexpr uint32_t empty = 1 << 31;
constexpr inline uint32_t object_list(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t object_list(uint32_t num) { return (num & 0xfffffc) << 0; }
}
}

248
dreamcast2/holly/holly_bits.hpp
View File

@ -4,12 +4,12 @@
namespace holly {
namespace id {
constexpr inline uint32_t device_id(uint32_t reg) { return (reg >> 16) & 0xffff; }
constexpr inline uint32_t vendor_id(uint32_t reg) { return (reg >> 0) & 0xffff; }
constexpr uint32_t device_id(uint32_t reg) { return (reg >> 16) & 0xffff; }
constexpr uint32_t vendor_id(uint32_t reg) { return (reg >> 0) & 0xffff; }
}
namespace revision {
constexpr inline uint32_t chip_revision(uint32_t reg) { return (reg >> 0) & 0xffff; }
constexpr uint32_t chip_revision(uint32_t reg) { return (reg >> 0) & 0xffff; }
}
namespace softreset {
@ -23,16 +23,16 @@ namespace holly {
}
namespace test_select {
constexpr inline uint32_t diagdb_data(uint32_t reg) { return (reg >> 5) & 0x1f; }
constexpr inline uint32_t diagda_data(uint32_t reg) { return (reg >> 0) & 0x1f; }
constexpr uint32_t diagdb_data(uint32_t reg) { return (reg >> 5) & 0x1f; }
constexpr uint32_t diagda_data(uint32_t reg) { return (reg >> 0) & 0x1f; }
}
namespace param_base {
constexpr inline uint32_t base_address(uint32_t num) { return (num & 0xf00000) << 0; }
constexpr uint32_t base_address(uint32_t num) { return (num & 0xf00000) << 0; }
}
namespace region_base {
constexpr inline uint32_t base_address(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t base_address(uint32_t num) { return (num & 0xfffffc) << 0; }
}
namespace span_sort_cfg {
@ -42,10 +42,10 @@ namespace holly {
}
namespace vo_border_col {
constexpr inline uint32_t chroma(uint32_t num) { return (num & 0x1) << 24; }
constexpr inline uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr inline uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t chroma(uint32_t num) { return (num & 0x1) << 24; }
constexpr uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fb_r_ctrl {
@ -57,9 +57,9 @@ namespace holly {
}
constexpr uint32_t fb_strip_buf_en = 1 << 22;
constexpr inline uint32_t fb_stripsize(uint32_t num) { return (num & 0x3e) << 16; }
constexpr inline uint32_t fb_chroma_threshold(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t fb_concat(uint32_t num) { return (num & 0x3) << 4; }
constexpr uint32_t fb_stripsize(uint32_t num) { return (num & 0x3e) << 16; }
constexpr uint32_t fb_chroma_threshold(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t fb_concat(uint32_t num) { return (num & 0x3) << 4; }
namespace fb_depth {
constexpr uint32_t xrgb0555 = 0 << 2;
@ -75,8 +75,8 @@ namespace holly {
}
namespace fb_w_ctrl {
constexpr inline uint32_t fb_alpha_threshold(uint32_t num) { return (num & 0xff) << 16; }
constexpr inline uint32_t fb_kval(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t fb_alpha_threshold(uint32_t num) { return (num & 0xff) << 16; }
constexpr uint32_t fb_kval(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t fb_dither = 1 << 3;
namespace fb_packmode {
@ -93,39 +93,39 @@ namespace holly {
}
namespace fb_w_linestride {
constexpr inline uint32_t fb_line_stride(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t fb_line_stride(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fb_r_sof1 {
constexpr inline uint32_t frame_buffer_read_address_frame_1(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t frame_buffer_read_address_frame_1(uint32_t num) { return (num & 0xfffffc) << 0; }
}
namespace fb_r_sof2 {
constexpr inline uint32_t frame_buffer_read_address_frame_2(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t frame_buffer_read_address_frame_2(uint32_t num) { return (num & 0xfffffc) << 0; }
}
namespace fb_r_size {
constexpr inline uint32_t fb_modulus(uint32_t num) { return (num & 0x3ff) << 20; }
constexpr inline uint32_t fb_y_size(uint32_t num) { return (num & 0x3ff) << 10; }
constexpr inline uint32_t fb_x_size(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t fb_modulus(uint32_t num) { return (num & 0x3ff) << 20; }
constexpr uint32_t fb_y_size(uint32_t num) { return (num & 0x3ff) << 10; }
constexpr uint32_t fb_x_size(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace fb_w_sof1 {
constexpr inline uint32_t frame_buffer_write_address_frame_1(uint32_t num) { return (num & 0x1fffffc) << 0; }
constexpr uint32_t frame_buffer_write_address_frame_1(uint32_t num) { return (num & 0x1fffffc) << 0; }
}
namespace fb_w_sof2 {
constexpr inline uint32_t frame_buffer_write_address_frame_2(uint32_t num) { return (num & 0x1fffffc) << 0; }
constexpr uint32_t frame_buffer_write_address_frame_2(uint32_t num) { return (num & 0x1fffffc) << 0; }
}
namespace fb_x_clip {
constexpr inline uint32_t fb_x_clip_max(uint32_t num) { return (num & 0x7ff) << 16; }
constexpr inline uint32_t fb_x_clip_min(uint32_t num) { return (num & 0x7ff) << 0; }
constexpr uint32_t fb_x_clip_max(uint32_t num) { return (num & 0x7ff) << 16; }
constexpr uint32_t fb_x_clip_min(uint32_t num) { return (num & 0x7ff) << 0; }
}
namespace fb_y_clip {
constexpr inline uint32_t fb_y_clip_max(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr inline uint32_t fb_y_clip_min(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t fb_y_clip_max(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr uint32_t fb_y_clip_min(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace fpu_shad_scale {
@ -136,7 +136,7 @@ namespace holly {
constexpr uint32_t bit_mask = 0x1 << 8;
}
constexpr inline uint32_t scale_factor_for_shadows(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t scale_factor_for_shadows(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fpu_cull_val {
@ -151,10 +151,10 @@ namespace holly {
constexpr uint32_t bit_mask = 0x1 << 21;
}
constexpr inline uint32_t tsp_parameter_burst_threshold(uint32_t num) { return (num & 0x3f) << 14; }
constexpr inline uint32_t isp_parameter_burst_threshold(uint32_t num) { return (num & 0x3f) << 8; }
constexpr inline uint32_t pointer_burst_size(uint32_t num) { return (num & 0xf) << 4; }
constexpr inline uint32_t pointer_first_burst_size(uint32_t num) { return (num & 0xf) << 0; }
constexpr uint32_t tsp_parameter_burst_threshold(uint32_t num) { return (num & 0x3f) << 14; }
constexpr uint32_t isp_parameter_burst_threshold(uint32_t num) { return (num & 0x3f) << 8; }
constexpr uint32_t pointer_burst_size(uint32_t num) { return (num & 0xf) << 4; }
constexpr uint32_t pointer_first_burst_size(uint32_t num) { return (num & 0xf) << 0; }
}
namespace half_offset {
@ -191,20 +191,20 @@ namespace holly {
namespace isp_backgnd_t {
constexpr uint32_t cache_bypass = 1 << 28;
constexpr uint32_t shadow = 1 << 27;
constexpr inline uint32_t skip(uint32_t num) { return (num & 0x7) << 24; }
constexpr inline uint32_t tag_address(uint32_t num) { return (num & 0x1fffff) << 3; }
constexpr inline uint32_t tag_offset(uint32_t num) { return (num & 0x7) << 0; }
constexpr uint32_t skip(uint32_t num) { return (num & 0x7) << 24; }
constexpr uint32_t tag_address(uint32_t num) { return (num & 0x1fffff) << 3; }
constexpr uint32_t tag_offset(uint32_t num) { return (num & 0x7) << 0; }
}
namespace isp_feed_cfg {
constexpr inline uint32_t cache_size_for_translucency(uint32_t num) { return (num & 0x3ff) << 14; }
constexpr inline uint32_t punch_through_chunk_size(uint32_t num) { return (num & 0x3ff) << 4; }
constexpr uint32_t cache_size_for_translucency(uint32_t num) { return (num & 0x3ff) << 14; }
constexpr uint32_t punch_through_chunk_size(uint32_t num) { return (num & 0x3ff) << 4; }
constexpr uint32_t discard_mode = 1 << 3;
constexpr uint32_t pre_sort_mode = 1 << 0;
}
namespace sdram_refresh {
constexpr inline uint32_t refresh_counter_value(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t refresh_counter_value(uint32_t num) { return (num & 0xff) << 0; }
}
namespace sdram_arb_cfg {
@ -233,61 +233,61 @@ namespace holly {
constexpr uint32_t bit_mask = 0x3 << 16;
}
constexpr inline uint32_t arbiter_crt_page_break_latency_count_value(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t arbiter_page_break_latency_count_value(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t arbiter_crt_page_break_latency_count_value(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t arbiter_page_break_latency_count_value(uint32_t num) { return (num & 0xff) << 0; }
}
namespace sdram_cfg {
constexpr inline uint32_t read_command_to_returned_data_delay(uint32_t num) { return (num & 0x7) << 26; }
constexpr inline uint32_t cas_latency_value(uint32_t num) { return (num & 0x7) << 23; }
constexpr inline uint32_t activate_to_activate_period(uint32_t num) { return (num & 0x3) << 21; }
constexpr inline uint32_t read_to_write_period(uint32_t num) { return (num & 0x7) << 18; }
constexpr inline uint32_t refresh_to_activate_period(uint32_t num) { return (num & 0xf) << 14; }
constexpr inline uint32_t pre_charge_to_activate_period(uint32_t num) { return (num & 0x3) << 10; }
constexpr inline uint32_t activate_to_pre_charge_period(uint32_t num) { return (num & 0xf) << 6; }
constexpr inline uint32_t activate_to_read_write_command_period(uint32_t num) { return (num & 0x3) << 4; }
constexpr inline uint32_t write_to_pre_charge_period(uint32_t num) { return (num & 0x3) << 2; }
constexpr inline uint32_t read_to_pre_charge_period(uint32_t num) { return (num & 0x3) << 0; }
constexpr uint32_t read_command_to_returned_data_delay(uint32_t num) { return (num & 0x7) << 26; }
constexpr uint32_t cas_latency_value(uint32_t num) { return (num & 0x7) << 23; }
constexpr uint32_t activate_to_activate_period(uint32_t num) { return (num & 0x3) << 21; }
constexpr uint32_t read_to_write_period(uint32_t num) { return (num & 0x7) << 18; }
constexpr uint32_t refresh_to_activate_period(uint32_t num) { return (num & 0xf) << 14; }
constexpr uint32_t pre_charge_to_activate_period(uint32_t num) { return (num & 0x3) << 10; }
constexpr uint32_t activate_to_pre_charge_period(uint32_t num) { return (num & 0xf) << 6; }
constexpr uint32_t activate_to_read_write_command_period(uint32_t num) { return (num & 0x3) << 4; }
constexpr uint32_t write_to_pre_charge_period(uint32_t num) { return (num & 0x3) << 2; }
constexpr uint32_t read_to_pre_charge_period(uint32_t num) { return (num & 0x3) << 0; }
}
namespace fog_col_ram {
constexpr inline uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr inline uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fog_col_vert {
constexpr inline uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr inline uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fog_density {
constexpr inline uint32_t fog_scale_mantissa(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t fog_scale_exponent(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t fog_scale_mantissa(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t fog_scale_exponent(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fog_clamp_max {
constexpr inline uint32_t alpha(uint32_t num) { return (num & 0xff) << 24; }
constexpr inline uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr inline uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t alpha(uint32_t num) { return (num & 0xff) << 24; }
constexpr uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fog_clamp_min {
constexpr inline uint32_t alpha(uint32_t num) { return (num & 0xff) << 24; }
constexpr inline uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr inline uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t alpha(uint32_t num) { return (num & 0xff) << 24; }
constexpr uint32_t red(uint32_t num) { return (num & 0xff) << 16; }
constexpr uint32_t green(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t blue(uint32_t num) { return (num & 0xff) << 0; }
}
namespace spg_trigger_pos {
constexpr inline uint32_t trigger_v_count(uint32_t reg) { return (reg >> 16) & 0x3ff; }
constexpr inline uint32_t trigger_h_count(uint32_t reg) { return (reg >> 0) & 0x3ff; }
constexpr uint32_t trigger_v_count(uint32_t reg) { return (reg >> 16) & 0x3ff; }
constexpr uint32_t trigger_h_count(uint32_t reg) { return (reg >> 0) & 0x3ff; }
}
namespace spg_hblank_int {
constexpr inline uint32_t hblank_in_interrupt(uint32_t reg) { return (reg >> 16) & 0x3ff; }
constexpr uint32_t hblank_in_interrupt(uint32_t reg) { return (reg >> 16) & 0x3ff; }
namespace hblank_int_mode {
constexpr uint32_t output_equal_line_comp_val = 0x0 << 12;
@ -297,12 +297,12 @@ namespace holly {
constexpr uint32_t bit_mask = 0x3 << 12;
}
constexpr inline uint32_t line_comp_val(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t line_comp_val(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace spg_vblank_int {
constexpr inline uint32_t vblank_out_interrupt_line_number(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr inline uint32_t vblank_in_interrupt_line_number(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t vblank_out_interrupt_line_number(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr uint32_t vblank_in_interrupt_line_number(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace spg_control {
@ -349,25 +349,25 @@ namespace holly {
}
namespace spg_hblank {
constexpr inline uint32_t hbend(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr inline uint32_t hbstart(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t hbend(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr uint32_t hbstart(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace spg_load {
constexpr inline uint32_t vcount(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr inline uint32_t hcount(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t vcount(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr uint32_t hcount(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace spg_vblank {
constexpr inline uint32_t vbend(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr inline uint32_t vbstart(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t vbend(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr uint32_t vbstart(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace spg_width {
constexpr inline uint32_t eqwidth(uint32_t num) { return (num & 0x3ff) << 22; }
constexpr inline uint32_t bpwidth(uint32_t num) { return (num & 0x3ff) << 12; }
constexpr inline uint32_t vswidth(uint32_t num) { return (num & 0xf) << 8; }
constexpr inline uint32_t hswidth(uint32_t num) { return (num & 0x7f) << 0; }
constexpr uint32_t eqwidth(uint32_t num) { return (num & 0x3ff) << 22; }
constexpr uint32_t bpwidth(uint32_t num) { return (num & 0x3ff) << 12; }
constexpr uint32_t vswidth(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t hswidth(uint32_t num) { return (num & 0x7f) << 0; }
}
namespace text_control {
@ -385,13 +385,13 @@ namespace holly {
constexpr uint32_t bit_mask = 0x1 << 16;
}
constexpr inline uint32_t bank_bit(uint32_t num) { return (num & 0x1f) << 8; }
constexpr inline uint32_t stride(uint32_t num) { return (num & 0x1f) << 0; }
constexpr uint32_t bank_bit(uint32_t num) { return (num & 0x1f) << 8; }
constexpr uint32_t stride(uint32_t num) { return (num & 0x1f) << 0; }
}
namespace vo_control {
constexpr uint32_t pclk_delay_reset = 1 << 21;
constexpr inline uint32_t pclk_delay(uint32_t num) { return (num & 0x1f) << 16; }
constexpr uint32_t pclk_delay(uint32_t num) { return (num & 0x1f) << 16; }
constexpr uint32_t pixel_double = 1 << 8;
namespace field_mode {
@ -433,12 +433,12 @@ namespace holly {
}
namespace vo_startx {
constexpr inline uint32_t horizontal_start_position(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t horizontal_start_position(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace vo_starty {
constexpr inline uint32_t vertical_start_position_on_field_2(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr inline uint32_t vertical_start_position_on_field_1(uint32_t num) { return (num & 0x3ff) << 0; }
constexpr uint32_t vertical_start_position_on_field_2(uint32_t num) { return (num & 0x3ff) << 16; }
constexpr uint32_t vertical_start_position_on_field_1(uint32_t num) { return (num & 0x3ff) << 0; }
}
namespace scaler_ctl {
@ -451,7 +451,7 @@ namespace holly {
constexpr uint32_t interlace = 1 << 17;
constexpr uint32_t horizontal_scaling_enable = 1 << 16;
constexpr inline uint32_t vertical_scale_factor(uint32_t num) { return (num & 0xffff) << 0; }
constexpr uint32_t vertical_scale_factor(uint32_t num) { return (num & 0xffff) << 0; }
}
namespace pal_ram_ctrl {
@ -466,67 +466,67 @@ namespace holly {
}
namespace spg_status {
constexpr inline uint32_t vsync(uint32_t reg) { return (reg >> 13) & 0x1; }
constexpr inline uint32_t hsync(uint32_t reg) { return (reg >> 12) & 0x1; }
constexpr inline uint32_t blank(uint32_t reg) { return (reg >> 11) & 0x1; }
constexpr inline uint32_t fieldnum(uint32_t reg) { return (reg >> 10) & 0x1; }
constexpr inline uint32_t scanline(uint32_t reg) { return (reg >> 0) & 0x3ff; }
constexpr uint32_t vsync(uint32_t reg) { return (reg >> 13) & 0x1; }
constexpr uint32_t hsync(uint32_t reg) { return (reg >> 12) & 0x1; }
constexpr uint32_t blank(uint32_t reg) { return (reg >> 11) & 0x1; }
constexpr uint32_t fieldnum(uint32_t reg) { return (reg >> 10) & 0x1; }
constexpr uint32_t scanline(uint32_t reg) { return (reg >> 0) & 0x3ff; }
}
namespace fb_burstctrl {
constexpr inline uint32_t wr_burst(uint32_t num) { return (num & 0xf) << 16; }
constexpr inline uint32_t vid_lat(uint32_t num) { return (num & 0x7f) << 8; }
constexpr inline uint32_t vid_burst(uint32_t num) { return (num & 0x3f) << 0; }
constexpr uint32_t wr_burst(uint32_t num) { return (num & 0xf) << 16; }
constexpr uint32_t vid_lat(uint32_t num) { return (num & 0x7f) << 8; }
constexpr uint32_t vid_burst(uint32_t num) { return (num & 0x3f) << 0; }
}
namespace fb_c_sof {
constexpr inline uint32_t frame_buffer_current_read_address(uint32_t reg) { return (reg >> 0) & 0xffffff; }
constexpr uint32_t frame_buffer_current_read_address(uint32_t reg) { return (reg >> 0) & 0xffffff; }
}
namespace y_coeff {
constexpr inline uint32_t coefficient_1(uint32_t num) { return (num & 0xff) << 8; }
constexpr inline uint32_t coefficient_0_2(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t coefficient_1(uint32_t num) { return (num & 0xff) << 8; }
constexpr uint32_t coefficient_0_2(uint32_t num) { return (num & 0xff) << 0; }
}
namespace pt_alpha_ref {
constexpr inline uint32_t alpha_reference_for_punch_through(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t alpha_reference_for_punch_through(uint32_t num) { return (num & 0xff) << 0; }
}
namespace fog_table {
constexpr inline uint32_t fog_table_data(uint32_t num) { return (num & 0xffff) << 0; }
constexpr uint32_t fog_table_data(uint32_t num) { return (num & 0xffff) << 0; }
}
namespace palette_ram {
constexpr inline uint32_t palette_data(uint32_t num) { return (num & 0xffffffff) << 0; }
constexpr uint32_t palette_data(uint32_t num) { return (num & 0xffffffff) << 0; }
}
namespace ta_ol_base {
constexpr inline uint32_t base_address(uint32_t num) { return (num & 0xffffe0) << 0; }
constexpr uint32_t base_address(uint32_t num) { return (num & 0xffffe0) << 0; }
}
namespace ta_isp_base {
constexpr inline uint32_t base_address(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t base_address(uint32_t num) { return (num & 0xfffffc) << 0; }
}
namespace ta_ol_limit {
constexpr inline uint32_t limit_address(uint32_t num) { return (num & 0xffffe0) << 0; }
constexpr uint32_t limit_address(uint32_t num) { return (num & 0xffffe0) << 0; }
}
namespace ta_isp_limit {
constexpr inline uint32_t limit_address(uint32_t num) { return (num & 0xfffffc) << 0; }
constexpr uint32_t limit_address(uint32_t num) { return (num & 0xfffffc) << 0; }
}
namespace ta_next_opb {
constexpr inline uint32_t address(uint32_t num) { return (num & 0xffffe0) << 0; }
constexpr uint32_t address(uint32_t num) { return (num & 0xffffe0) << 0; }
}
namespace ta_itp_current {
constexpr inline uint32_t address(uint32_t reg) { return (reg >> 0) & 0xffffff; }
constexpr uint32_t address(uint32_t reg) { return (reg >> 0) & 0xffffff; }
}
namespace ta_glob_tile_clip {
constexpr inline uint32_t tile_y_num(uint32_t num) { return (num & 0xf) << 16; }
constexpr inline uint32_t tile_x_num(uint32_t num) { return (num & 0x1f) << 0; }
constexpr uint32_t tile_y_num(uint32_t num) { return (num & 0xf) << 16; }
constexpr uint32_t tile_x_num(uint32_t num) { return (num & 0x1f) << 0; }
}
namespace ta_alloc_ctrl {
@ -588,7 +588,7 @@ namespace holly {
}
namespace ta_yuv_tex_base {
constexpr inline uint32_t base_address(uint32_t num) { return (num & 0xfffff8) << 0; }
constexpr uint32_t base_address(uint32_t num) { return (num & 0xfffff8) << 0; }
}
namespace ta_yuv_tex_ctrl {
@ -606,12 +606,12 @@ namespace holly {
constexpr uint32_t bit_mask = 0x1 << 16;
}
constexpr inline uint32_t yuv_v_size(uint32_t num) { return (num & 0x3f) << 8; }
constexpr inline uint32_t yuv_u_size(uint32_t num) { return (num & 0x3f) << 0; }
constexpr uint32_t yuv_v_size(uint32_t num) { return (num & 0x3f) << 8; }
constexpr uint32_t yuv_u_size(uint32_t num) { return (num & 0x3f) << 0; }
}
namespace ta_yuv_tex_cnt {
constexpr inline uint32_t yuv_num(uint32_t reg) { return (reg >> 0) & 0x1fff; }
constexpr uint32_t yuv_num(uint32_t reg) { return (reg >> 0) & 0x1fff; }
}
namespace ta_list_cont {
@ -619,17 +619,17 @@ namespace holly {
}
namespace ta_next_opb_init {
constexpr inline uint32_t address(uint32_t num) { return (num & 0xffffe0) << 0; }
constexpr uint32_t address(uint32_t num) { return (num & 0xffffe0) << 0; }
}
namespace ta_ol_pointers {
constexpr inline uint32_t entry(uint32_t reg) { return (reg >> 31) & 0x1; }
constexpr inline uint32_t sprite(uint32_t reg) { return (reg >> 30) & 0x1; }
constexpr inline uint32_t triangle(uint32_t reg) { return (reg >> 29) & 0x1; }
constexpr inline uint32_t number_of_triangles_quads(uint32_t reg) { return (reg >> 25) & 0xf; }
constexpr inline uint32_t shadow(uint32_t reg) { return (reg >> 24) & 0x1; }
constexpr inline uint32_t pointer_address(uint32_t reg) { return (reg >> 2) & 0x3fffff; }
constexpr inline uint32_t skip(uint32_t reg) { return (reg >> 0) & 0x3; }
constexpr uint32_t entry(uint32_t reg) { return (reg >> 31) & 0x1; }
constexpr uint32_t sprite(uint32_t reg) { return (reg >> 30) & 0x1; }
constexpr uint32_t triangle(uint32_t reg) { return (reg >> 29) & 0x1; }
constexpr uint32_t number_of_triangles_quads(uint32_t reg) { return (reg >> 25) & 0xf; }
constexpr uint32_t shadow(uint32_t reg) { return (reg >> 24) & 0x1; }
constexpr uint32_t pointer_address(uint32_t reg) { return (reg >> 2) & 0x3fffff; }
constexpr uint32_t skip(uint32_t reg) { return (reg >> 0) & 0x3; }
}
}

240
dreamcast2/holly/ta/global_parameter.hpp
View File

@ -1,240 +0,0 @@
#pragma once
#include <cstdint>
#include <cstddef>
namespace holly::ta::global_parameter {
struct end_of_list {
uint32_t parameter_control_word;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t _res3;
uint32_t _res4;
uint32_t _res5;
uint32_t _res6;
};
static_assert((sizeof (end_of_list)) == 32);
static_assert((offsetof (struct end_of_list, parameter_control_word)) == 0x00);
static_assert((offsetof (struct end_of_list, _res0)) == 0x04);
static_assert((offsetof (struct end_of_list, _res1)) == 0x08);
static_assert((offsetof (struct end_of_list, _res2)) == 0x0c);
static_assert((offsetof (struct end_of_list, _res3)) == 0x10);
static_assert((offsetof (struct end_of_list, _res4)) == 0x14);
static_assert((offsetof (struct end_of_list, _res5)) == 0x18);
static_assert((offsetof (struct end_of_list, _res6)) == 0x1c);
struct user_tile_clip {
uint32_t parameter_control_word;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t user_clip_x_min;
uint32_t user_clip_y_min;
uint32_t user_clip_x_max;
uint32_t user_clip_y_max;
};
static_assert((sizeof (user_tile_clip)) == 32);
static_assert((offsetof (struct user_tile_clip, parameter_control_word)) == 0x00);
static_assert((offsetof (struct user_tile_clip, _res0)) == 0x04);
static_assert((offsetof (struct user_tile_clip, _res1)) == 0x08);
static_assert((offsetof (struct user_tile_clip, _res2)) == 0x0c);
static_assert((offsetof (struct user_tile_clip, user_clip_x_min)) == 0x10);
static_assert((offsetof (struct user_tile_clip, user_clip_y_min)) == 0x14);
static_assert((offsetof (struct user_tile_clip, user_clip_x_max)) == 0x18);
static_assert((offsetof (struct user_tile_clip, user_clip_y_max)) == 0x1c);
struct object_list_set {
uint32_t parameter_control_word;
uint32_t object_pointer;
uint32_t _res0;
uint32_t _res1;
uint32_t bounding_box_x_min;
uint32_t bounding_box_y_min;
uint32_t bounding_box_x_max;
uint32_t bounding_box_y_max;
};
static_assert((sizeof (object_list_set)) == 32);
static_assert((offsetof (struct object_list_set, parameter_control_word)) == 0x00);
static_assert((offsetof (struct object_list_set, object_pointer)) == 0x04);
static_assert((offsetof (struct object_list_set, _res0)) == 0x08);
static_assert((offsetof (struct object_list_set, _res1)) == 0x0c);
static_assert((offsetof (struct object_list_set, bounding_box_x_min)) == 0x10);
static_assert((offsetof (struct object_list_set, bounding_box_y_min)) == 0x14);
static_assert((offsetof (struct object_list_set, bounding_box_x_max)) == 0x18);
static_assert((offsetof (struct object_list_set, bounding_box_y_max)) == 0x1c);
struct polygon_type_0 {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t tsp_instruction_word;
uint32_t texture_control_word;
uint32_t _res0;
uint32_t _res1;
uint32_t data_size_for_sort_dma;
uint32_t next_address_for_sort_dma;
};
static_assert((sizeof (polygon_type_0)) == 32);
static_assert((offsetof (struct polygon_type_0, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_0, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct polygon_type_0, tsp_instruction_word)) == 0x08);
static_assert((offsetof (struct polygon_type_0, texture_control_word)) == 0x0c);
static_assert((offsetof (struct polygon_type_0, _res0)) == 0x10);
static_assert((offsetof (struct polygon_type_0, _res1)) == 0x14);
static_assert((offsetof (struct polygon_type_0, data_size_for_sort_dma)) == 0x18);
static_assert((offsetof (struct polygon_type_0, next_address_for_sort_dma)) == 0x1c);
struct polygon_type_1 {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t tsp_instruction_word;
uint32_t texture_control_word;
float face_color_alpha;
float face_color_r;
float face_color_g;
float face_color_b;
};
static_assert((sizeof (polygon_type_1)) == 32);
static_assert((offsetof (struct polygon_type_1, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_1, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct polygon_type_1, tsp_instruction_word)) == 0x08);
static_assert((offsetof (struct polygon_type_1, texture_control_word)) == 0x0c);
static_assert((offsetof (struct polygon_type_1, face_color_alpha)) == 0x10);
static_assert((offsetof (struct polygon_type_1, face_color_r)) == 0x14);
static_assert((offsetof (struct polygon_type_1, face_color_g)) == 0x18);
static_assert((offsetof (struct polygon_type_1, face_color_b)) == 0x1c);
struct polygon_type_2 {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t tsp_instruction_word;
uint32_t texture_control_word;
uint32_t _res0;
uint32_t _res1;
uint32_t data_size_for_sort_dma;
uint32_t next_address_for_sort_dma;
float face_color_alpha;
float face_color_r;
float face_color_g;
float face_color_b;
float face_offset_color_alpha;
float face_offset_color_r;
float face_offset_color_g;
float face_offset_color_b;
};
static_assert((sizeof (polygon_type_2)) == 64);
static_assert((offsetof (struct polygon_type_2, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_2, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct polygon_type_2, tsp_instruction_word)) == 0x08);
static_assert((offsetof (struct polygon_type_2, texture_control_word)) == 0x0c);
static_assert((offsetof (struct polygon_type_2, _res0)) == 0x10);
static_assert((offsetof (struct polygon_type_2, _res1)) == 0x14);
static_assert((offsetof (struct polygon_type_2, data_size_for_sort_dma)) == 0x18);
static_assert((offsetof (struct polygon_type_2, next_address_for_sort_dma)) == 0x1c);
static_assert((offsetof (struct polygon_type_2, face_color_alpha)) == 0x20);
static_assert((offsetof (struct polygon_type_2, face_color_r)) == 0x24);
static_assert((offsetof (struct polygon_type_2, face_color_g)) == 0x28);
static_assert((offsetof (struct polygon_type_2, face_color_b)) == 0x2c);
static_assert((offsetof (struct polygon_type_2, face_offset_color_alpha)) == 0x30);
static_assert((offsetof (struct polygon_type_2, face_offset_color_r)) == 0x34);
static_assert((offsetof (struct polygon_type_2, face_offset_color_g)) == 0x38);
static_assert((offsetof (struct polygon_type_2, face_offset_color_b)) == 0x3c);
struct polygon_type_3 {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t tsp_instruction_word_0;
uint32_t texture_control_word_0;
uint32_t tsp_instruction_word_1;
uint32_t texture_control_word_1;
uint32_t data_size_for_sort_dma;
uint32_t next_address_for_sort_dma;
};
static_assert((sizeof (polygon_type_3)) == 32);
static_assert((offsetof (struct polygon_type_3, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_3, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct polygon_type_3, tsp_instruction_word_0)) == 0x08);
static_assert((offsetof (struct polygon_type_3, texture_control_word_0)) == 0x0c);
static_assert((offsetof (struct polygon_type_3, tsp_instruction_word_1)) == 0x10);
static_assert((offsetof (struct polygon_type_3, texture_control_word_1)) == 0x14);
static_assert((offsetof (struct polygon_type_3, data_size_for_sort_dma)) == 0x18);
static_assert((offsetof (struct polygon_type_3, next_address_for_sort_dma)) == 0x1c);
struct polygon_type_4 {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t tsp_instruction_word_0;
uint32_t texture_control_word_0;
uint32_t tsp_instruction_word_1;
uint32_t texture_control_word_1;
uint32_t data_size_for_sort_dma;
uint32_t next_address_for_sort_dma;
float face_color_alpha_0;
float face_color_r_0;
float face_color_g_0;
float face_color_b_0;
float face_color_alpha_1;
float face_color_r_1;
float face_color_g_1;
float face_color_b_1;
};
static_assert((sizeof (polygon_type_4)) == 64);
static_assert((offsetof (struct polygon_type_4, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_4, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct polygon_type_4, tsp_instruction_word_0)) == 0x08);
static_assert((offsetof (struct polygon_type_4, texture_control_word_0)) == 0x0c);
static_assert((offsetof (struct polygon_type_4, tsp_instruction_word_1)) == 0x10);
static_assert((offsetof (struct polygon_type_4, texture_control_word_1)) == 0x14);
static_assert((offsetof (struct polygon_type_4, data_size_for_sort_dma)) == 0x18);
static_assert((offsetof (struct polygon_type_4, next_address_for_sort_dma)) == 0x1c);
static_assert((offsetof (struct polygon_type_4, face_color_alpha_0)) == 0x20);
static_assert((offsetof (struct polygon_type_4, face_color_r_0)) == 0x24);
static_assert((offsetof (struct polygon_type_4, face_color_g_0)) == 0x28);
static_assert((offsetof (struct polygon_type_4, face_color_b_0)) == 0x2c);
static_assert((offsetof (struct polygon_type_4, face_color_alpha_1)) == 0x30);
static_assert((offsetof (struct polygon_type_4, face_color_r_1)) == 0x34);
static_assert((offsetof (struct polygon_type_4, face_color_g_1)) == 0x38);
static_assert((offsetof (struct polygon_type_4, face_color_b_1)) == 0x3c);
struct sprite {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t tsp_instruction_word;
uint32_t texture_control_word;
uint32_t base_color;
uint32_t offset_color;
uint32_t data_size_for_sort_dma;
uint32_t next_address_for_sort_dma;
};
static_assert((sizeof (sprite)) == 32);
static_assert((offsetof (struct sprite, parameter_control_word)) == 0x00);
static_assert((offsetof (struct sprite, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct sprite, tsp_instruction_word)) == 0x08);
static_assert((offsetof (struct sprite, texture_control_word)) == 0x0c);
static_assert((offsetof (struct sprite, base_color)) == 0x10);
static_assert((offsetof (struct sprite, offset_color)) == 0x14);
static_assert((offsetof (struct sprite, data_size_for_sort_dma)) == 0x18);
static_assert((offsetof (struct sprite, next_address_for_sort_dma)) == 0x1c);
struct modifier_volume {
uint32_t parameter_control_word;
uint32_t isp_tsp_instruction_word;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t _res3;
uint32_t _res4;
uint32_t _res5;
};
static_assert((sizeof (modifier_volume)) == 32);
static_assert((offsetof (struct modifier_volume, parameter_control_word)) == 0x00);
static_assert((offsetof (struct modifier_volume, isp_tsp_instruction_word)) == 0x04);
static_assert((offsetof (struct modifier_volume, _res0)) == 0x08);
static_assert((offsetof (struct modifier_volume, _res1)) == 0x0c);
static_assert((offsetof (struct modifier_volume, _res2)) == 0x10);
static_assert((offsetof (struct modifier_volume, _res3)) == 0x14);
static_assert((offsetof (struct modifier_volume, _res4)) == 0x18);
static_assert((offsetof (struct modifier_volume, _res5)) == 0x1c);
}

78
dreamcast2/holly/ta/parameter_bits.hpp
View File

@ -1,78 +0,0 @@
#pragma once
#include <cstdint>
namespace holly::ta::parameter {
namespace parameter_control_word {
namespace para_type {
constexpr uint32_t end_of_list = 0 << 29;
constexpr uint32_t user_tile_clip = 1 << 29;
constexpr uint32_t object_list_set = 2 << 29;
constexpr uint32_t polygon_or_modifier_volume = 4 << 29;
constexpr uint32_t sprite = 5 << 29;
constexpr uint32_t vertex_parameter = 7 << 29;
constexpr uint32_t bit_mask = 0x7 << 29;
}
constexpr uint32_t end_of_strip = 1 << 28;
namespace list_type {
constexpr uint32_t opaque = 0 << 24;
constexpr uint32_t opaque_modifier_volume = 1 << 24;
constexpr uint32_t translucent = 2 << 24;
constexpr uint32_t translucent_modifier_volume = 3 << 24;
constexpr uint32_t punch_through = 4 << 24;
constexpr uint32_t bit_mask = 0x7 << 24;
}
constexpr uint32_t group_en = 1 << 23;
namespace strip_len {
constexpr uint32_t _1_strip = 0 << 18;
constexpr uint32_t _2_strip = 1 << 18;
constexpr uint32_t _4_strip = 2 << 18;
constexpr uint32_t _6_strip = 3 << 18;
constexpr uint32_t bit_mask = 0x3 << 18;
}
namespace user_clip {
constexpr uint32_t disabled = 0 << 16;
constexpr uint32_t inside_enable = 2 << 16;
constexpr uint32_t outside_enable = 3 << 16;
constexpr uint32_t bit_mask = 0x3 << 16;
}
namespace polygon_volume {
constexpr uint32_t no_volume = 0b00 << 6;
constexpr uint32_t intensity_volume = 0b10 << 6;
constexpr uint32_t two_volumes = 0b11 << 6;
constexpr uint32_t bit_mask = 0x3 << 6;
}
namespace modifier_volume {
constexpr uint32_t last_in_volume = 0b01 << 6;
constexpr uint32_t bit_mask = 0x3 << 6;
}
namespace col_type {
constexpr uint32_t packed_color = 0 << 4;
constexpr uint32_t floating_color = 1 << 4;
constexpr uint32_t intensity_mode_1 = 2 << 4;
constexpr uint32_t intensity_mode_2 = 3 << 4;
constexpr uint32_t bit_mask = 0x3 << 4;
}
constexpr uint32_t texture = 1 << 3;
constexpr uint32_t offset = 1 << 2;
constexpr uint32_t gouraud = 1 << 1;
constexpr uint32_t _16bit_uv = 1 << 0;
}
}

512
dreamcast2/holly/ta/vertex_parameter.hpp
View File

@ -1,512 +0,0 @@
#pragma once
#include <cstdint>
#include <cstddef>
namespace holly::ta::vertex_parameter {
struct polygon_type_0 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t _res0;
uint32_t _res1;
uint32_t base_color;
uint32_t _res2;
};
static_assert((sizeof (polygon_type_0)) == 32);
static_assert((offsetof (struct polygon_type_0, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_0, x)) == 0x04);
static_assert((offsetof (struct polygon_type_0, y)) == 0x08);
static_assert((offsetof (struct polygon_type_0, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_0, _res0)) == 0x10);
static_assert((offsetof (struct polygon_type_0, _res1)) == 0x14);
static_assert((offsetof (struct polygon_type_0, base_color)) == 0x18);
static_assert((offsetof (struct polygon_type_0, _res2)) == 0x1c);
struct polygon_type_1 {
uint32_t parameter_control_word;
float x;
float y;
float z;
float base_color_alpha;
float base_color_r;
float base_color_g;
float base_color_b;
};
static_assert((sizeof (polygon_type_1)) == 32);
static_assert((offsetof (struct polygon_type_1, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_1, x)) == 0x04);
static_assert((offsetof (struct polygon_type_1, y)) == 0x08);
static_assert((offsetof (struct polygon_type_1, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_1, base_color_alpha)) == 0x10);
static_assert((offsetof (struct polygon_type_1, base_color_r)) == 0x14);
static_assert((offsetof (struct polygon_type_1, base_color_g)) == 0x18);
static_assert((offsetof (struct polygon_type_1, base_color_b)) == 0x1c);
struct polygon_type_2 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t _res0;
uint32_t _res1;
float base_intensity;
uint32_t _res2;
};
static_assert((sizeof (polygon_type_2)) == 32);
static_assert((offsetof (struct polygon_type_2, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_2, x)) == 0x04);
static_assert((offsetof (struct polygon_type_2, y)) == 0x08);
static_assert((offsetof (struct polygon_type_2, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_2, _res0)) == 0x10);
static_assert((offsetof (struct polygon_type_2, _res1)) == 0x14);
static_assert((offsetof (struct polygon_type_2, base_intensity)) == 0x18);
static_assert((offsetof (struct polygon_type_2, _res2)) == 0x1c);
struct polygon_type_3 {
uint32_t parameter_control_word;
float x;
float y;
float z;
float u;
float v;
uint32_t base_color;
uint32_t offset_color;
};
static_assert((sizeof (polygon_type_3)) == 32);
static_assert((offsetof (struct polygon_type_3, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_3, x)) == 0x04);
static_assert((offsetof (struct polygon_type_3, y)) == 0x08);
static_assert((offsetof (struct polygon_type_3, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_3, u)) == 0x10);
static_assert((offsetof (struct polygon_type_3, v)) == 0x14);
static_assert((offsetof (struct polygon_type_3, base_color)) == 0x18);
static_assert((offsetof (struct polygon_type_3, offset_color)) == 0x1c);
struct polygon_type_4 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t u_v;
uint32_t _res0;
uint32_t base_color;
uint32_t offset_color;
};
static_assert((sizeof (polygon_type_4)) == 32);
static_assert((offsetof (struct polygon_type_4, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_4, x)) == 0x04);
static_assert((offsetof (struct polygon_type_4, y)) == 0x08);
static_assert((offsetof (struct polygon_type_4, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_4, u_v)) == 0x10);
static_assert((offsetof (struct polygon_type_4, _res0)) == 0x14);
static_assert((offsetof (struct polygon_type_4, base_color)) == 0x18);
static_assert((offsetof (struct polygon_type_4, offset_color)) == 0x1c);
struct polygon_type_5 {
uint32_t parameter_control_word;
float x;
float y;
float z;
float u;
float v;
uint32_t _res0;
uint32_t _res1;
float base_color_alpha;
float base_color_r;
float base_color_g;
float base_color_b;
float offset_color_alpha;
float offset_color_r;
float offset_color_g;
float offset_color_b;
};
static_assert((sizeof (polygon_type_5)) == 64);
static_assert((offsetof (struct polygon_type_5, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_5, x)) == 0x04);
static_assert((offsetof (struct polygon_type_5, y)) == 0x08);
static_assert((offsetof (struct polygon_type_5, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_5, u)) == 0x10);
static_assert((offsetof (struct polygon_type_5, v)) == 0x14);
static_assert((offsetof (struct polygon_type_5, _res0)) == 0x18);
static_assert((offsetof (struct polygon_type_5, _res1)) == 0x1c);
static_assert((offsetof (struct polygon_type_5, base_color_alpha)) == 0x20);
static_assert((offsetof (struct polygon_type_5, base_color_r)) == 0x24);
static_assert((offsetof (struct polygon_type_5, base_color_g)) == 0x28);
static_assert((offsetof (struct polygon_type_5, base_color_b)) == 0x2c);
static_assert((offsetof (struct polygon_type_5, offset_color_alpha)) == 0x30);
static_assert((offsetof (struct polygon_type_5, offset_color_r)) == 0x34);
static_assert((offsetof (struct polygon_type_5, offset_color_g)) == 0x38);
static_assert((offsetof (struct polygon_type_5, offset_color_b)) == 0x3c);
struct polygon_type_6 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t u_v;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
float base_color_alpha;
float base_color_r;
float base_color_g;
float base_color_b;
float offset_color_alpha;
float offset_color_r;
float offset_color_g;
float offset_color_b;
};
static_assert((sizeof (polygon_type_6)) == 64);
static_assert((offsetof (struct polygon_type_6, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_6, x)) == 0x04);
static_assert((offsetof (struct polygon_type_6, y)) == 0x08);
static_assert((offsetof (struct polygon_type_6, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_6, u_v)) == 0x10);
static_assert((offsetof (struct polygon_type_6, _res0)) == 0x14);
static_assert((offsetof (struct polygon_type_6, _res1)) == 0x18);
static_assert((offsetof (struct polygon_type_6, _res2)) == 0x1c);
static_assert((offsetof (struct polygon_type_6, base_color_alpha)) == 0x20);
static_assert((offsetof (struct polygon_type_6, base_color_r)) == 0x24);
static_assert((offsetof (struct polygon_type_6, base_color_g)) == 0x28);
static_assert((offsetof (struct polygon_type_6, base_color_b)) == 0x2c);
static_assert((offsetof (struct polygon_type_6, offset_color_alpha)) == 0x30);
static_assert((offsetof (struct polygon_type_6, offset_color_r)) == 0x34);
static_assert((offsetof (struct polygon_type_6, offset_color_g)) == 0x38);
static_assert((offsetof (struct polygon_type_6, offset_color_b)) == 0x3c);
struct polygon_type_7 {
uint32_t parameter_control_word;
float x;
float y;
float z;
float u;
float v;
float base_intensity;
float offset_intensity;
};
static_assert((sizeof (polygon_type_7)) == 32);
static_assert((offsetof (struct polygon_type_7, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_7, x)) == 0x04);
static_assert((offsetof (struct polygon_type_7, y)) == 0x08);
static_assert((offsetof (struct polygon_type_7, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_7, u)) == 0x10);
static_assert((offsetof (struct polygon_type_7, v)) == 0x14);
static_assert((offsetof (struct polygon_type_7, base_intensity)) == 0x18);
static_assert((offsetof (struct polygon_type_7, offset_intensity)) == 0x1c);
struct polygon_type_8 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t u_v;
uint32_t _res0;
float base_intensity;
float offset_intensity;
};
static_assert((sizeof (polygon_type_8)) == 32);
static_assert((offsetof (struct polygon_type_8, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_8, x)) == 0x04);
static_assert((offsetof (struct polygon_type_8, y)) == 0x08);
static_assert((offsetof (struct polygon_type_8, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_8, u_v)) == 0x10);
static_assert((offsetof (struct polygon_type_8, _res0)) == 0x14);
static_assert((offsetof (struct polygon_type_8, base_intensity)) == 0x18);
static_assert((offsetof (struct polygon_type_8, offset_intensity)) == 0x1c);
struct polygon_type_9 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t base_color_0;
uint32_t base_color_1;
uint32_t _res0;
uint32_t _res1;
};
static_assert((sizeof (polygon_type_9)) == 32);
static_assert((offsetof (struct polygon_type_9, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_9, x)) == 0x04);
static_assert((offsetof (struct polygon_type_9, y)) == 0x08);
static_assert((offsetof (struct polygon_type_9, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_9, base_color_0)) == 0x10);
static_assert((offsetof (struct polygon_type_9, base_color_1)) == 0x14);
static_assert((offsetof (struct polygon_type_9, _res0)) == 0x18);
static_assert((offsetof (struct polygon_type_9, _res1)) == 0x1c);
struct polygon_type_10 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t base_intensity_0;
uint32_t base_intensity_1;
uint32_t _res0;
uint32_t _res1;
};
static_assert((sizeof (polygon_type_10)) == 32);
static_assert((offsetof (struct polygon_type_10, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_10, x)) == 0x04);
static_assert((offsetof (struct polygon_type_10, y)) == 0x08);
static_assert((offsetof (struct polygon_type_10, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_10, base_intensity_0)) == 0x10);
static_assert((offsetof (struct polygon_type_10, base_intensity_1)) == 0x14);
static_assert((offsetof (struct polygon_type_10, _res0)) == 0x18);
static_assert((offsetof (struct polygon_type_10, _res1)) == 0x1c);
struct polygon_type_11 {
uint32_t parameter_control_word;
float x;
float y;
float z;
float u_0;
float v_0;
uint32_t base_color_0;
uint32_t offset_color_0;
float u_1;
float v_1;
uint32_t base_color_1;
uint32_t offset_color_1;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t _res3;
};
static_assert((sizeof (polygon_type_11)) == 64);
static_assert((offsetof (struct polygon_type_11, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_11, x)) == 0x04);
static_assert((offsetof (struct polygon_type_11, y)) == 0x08);
static_assert((offsetof (struct polygon_type_11, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_11, u_0)) == 0x10);
static_assert((offsetof (struct polygon_type_11, v_0)) == 0x14);
static_assert((offsetof (struct polygon_type_11, base_color_0)) == 0x18);
static_assert((offsetof (struct polygon_type_11, offset_color_0)) == 0x1c);
static_assert((offsetof (struct polygon_type_11, u_1)) == 0x20);
static_assert((offsetof (struct polygon_type_11, v_1)) == 0x24);
static_assert((offsetof (struct polygon_type_11, base_color_1)) == 0x28);
static_assert((offsetof (struct polygon_type_11, offset_color_1)) == 0x2c);
static_assert((offsetof (struct polygon_type_11, _res0)) == 0x30);
static_assert((offsetof (struct polygon_type_11, _res1)) == 0x34);
static_assert((offsetof (struct polygon_type_11, _res2)) == 0x38);
static_assert((offsetof (struct polygon_type_11, _res3)) == 0x3c);
struct polygon_type_12 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t u_v_0;
uint32_t _res0;
uint32_t base_color_0;
uint32_t offset_color_0;
uint32_t u_v_1;
uint32_t _res1;
uint32_t base_color_1;
uint32_t offset_color_1;
uint32_t _res2;
uint32_t _res3;
uint32_t _res4;
uint32_t _res5;
};
static_assert((sizeof (polygon_type_12)) == 64);
static_assert((offsetof (struct polygon_type_12, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_12, x)) == 0x04);
static_assert((offsetof (struct polygon_type_12, y)) == 0x08);
static_assert((offsetof (struct polygon_type_12, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_12, u_v_0)) == 0x10);
static_assert((offsetof (struct polygon_type_12, _res0)) == 0x14);
static_assert((offsetof (struct polygon_type_12, base_color_0)) == 0x18);
static_assert((offsetof (struct polygon_type_12, offset_color_0)) == 0x1c);
static_assert((offsetof (struct polygon_type_12, u_v_1)) == 0x20);
static_assert((offsetof (struct polygon_type_12, _res1)) == 0x24);
static_assert((offsetof (struct polygon_type_12, base_color_1)) == 0x28);
static_assert((offsetof (struct polygon_type_12, offset_color_1)) == 0x2c);
static_assert((offsetof (struct polygon_type_12, _res2)) == 0x30);
static_assert((offsetof (struct polygon_type_12, _res3)) == 0x34);
static_assert((offsetof (struct polygon_type_12, _res4)) == 0x38);
static_assert((offsetof (struct polygon_type_12, _res5)) == 0x3c);
struct polygon_type_13 {
uint32_t parameter_control_word;
float x;
float y;
float z;
float u_0;
float v_0;
uint32_t base_intensity_0;
float offset_intensity_0;
float u_1;
float v_1;
uint32_t base_intensity_1;
float offset_intensity_1;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t _res3;
};
static_assert((sizeof (polygon_type_13)) == 64);
static_assert((offsetof (struct polygon_type_13, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_13, x)) == 0x04);
static_assert((offsetof (struct polygon_type_13, y)) == 0x08);
static_assert((offsetof (struct polygon_type_13, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_13, u_0)) == 0x10);
static_assert((offsetof (struct polygon_type_13, v_0)) == 0x14);
static_assert((offsetof (struct polygon_type_13, base_intensity_0)) == 0x18);
static_assert((offsetof (struct polygon_type_13, offset_intensity_0)) == 0x1c);
static_assert((offsetof (struct polygon_type_13, u_1)) == 0x20);
static_assert((offsetof (struct polygon_type_13, v_1)) == 0x24);
static_assert((offsetof (struct polygon_type_13, base_intensity_1)) == 0x28);
static_assert((offsetof (struct polygon_type_13, offset_intensity_1)) == 0x2c);
static_assert((offsetof (struct polygon_type_13, _res0)) == 0x30);
static_assert((offsetof (struct polygon_type_13, _res1)) == 0x34);
static_assert((offsetof (struct polygon_type_13, _res2)) == 0x38);
static_assert((offsetof (struct polygon_type_13, _res3)) == 0x3c);
struct polygon_type_14 {
uint32_t parameter_control_word;
float x;
float y;
float z;
uint32_t u_v_0;
uint32_t _res0;
uint32_t base_intensity_0;
float offset_intensity_0;
uint32_t u_v_1;
uint32_t _res1;
uint32_t base_intensity_1;
float offset_intensity_1;
uint32_t _res2;
uint32_t _res3;
uint32_t _res4;
uint32_t _res5;
};
static_assert((sizeof (polygon_type_14)) == 64);
static_assert((offsetof (struct polygon_type_14, parameter_control_word)) == 0x00);
static_assert((offsetof (struct polygon_type_14, x)) == 0x04);
static_assert((offsetof (struct polygon_type_14, y)) == 0x08);
static_assert((offsetof (struct polygon_type_14, z)) == 0x0c);
static_assert((offsetof (struct polygon_type_14, u_v_0)) == 0x10);
static_assert((offsetof (struct polygon_type_14, _res0)) == 0x14);
static_assert((offsetof (struct polygon_type_14, base_intensity_0)) == 0x18);
static_assert((offsetof (struct polygon_type_14, offset_intensity_0)) == 0x1c);
static_assert((offsetof (struct polygon_type_14, u_v_1)) == 0x20);
static_assert((offsetof (struct polygon_type_14, _res1)) == 0x24);
static_assert((offsetof (struct polygon_type_14, base_intensity_1)) == 0x28);
static_assert((offsetof (struct polygon_type_14, offset_intensity_1)) == 0x2c);
static_assert((offsetof (struct polygon_type_14, _res2)) == 0x30);
static_assert((offsetof (struct polygon_type_14, _res3)) == 0x34);
static_assert((offsetof (struct polygon_type_14, _res4)) == 0x38);
static_assert((offsetof (struct polygon_type_14, _res5)) == 0x3c);
struct sprite_type_0 {
uint32_t parameter_control_word;
float a_x;
float a_y;
float a_z;
float b_x;
float b_y;
float b_z;
float c_x;
float c_y;
float c_z;
float d_x;
float d_y;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t _res3;
};
static_assert((sizeof (sprite_type_0)) == 64);
static_assert((offsetof (struct sprite_type_0, parameter_control_word)) == 0x00);
static_assert((offsetof (struct sprite_type_0, a_x)) == 0x04);
static_assert((offsetof (struct sprite_type_0, a_y)) == 0x08);
static_assert((offsetof (struct sprite_type_0, a_z)) == 0x0c);
static_assert((offsetof (struct sprite_type_0, b_x)) == 0x10);
static_assert((offsetof (struct sprite_type_0, b_y)) == 0x14);
static_assert((offsetof (struct sprite_type_0, b_z)) == 0x18);
static_assert((offsetof (struct sprite_type_0, c_x)) == 0x1c);
static_assert((offsetof (struct sprite_type_0, c_y)) == 0x20);
static_assert((offsetof (struct sprite_type_0, c_z)) == 0x24);
static_assert((offsetof (struct sprite_type_0, d_x)) == 0x28);
static_assert((offsetof (struct sprite_type_0, d_y)) == 0x2c);
static_assert((offsetof (struct sprite_type_0, _res0)) == 0x30);
static_assert((offsetof (struct sprite_type_0, _res1)) == 0x34);
static_assert((offsetof (struct sprite_type_0, _res2)) == 0x38);
static_assert((offsetof (struct sprite_type_0, _res3)) == 0x3c);
struct sprite_type_1 {
uint32_t parameter_control_word;
float a_x;
float a_y;
float a_z;
float b_x;
float b_y;
float b_z;
float c_x;
float c_y;
float c_z;
float d_x;
float d_y;
uint32_t _res0;
uint32_t a_u_a_v;
uint32_t b_u_b_v;
uint32_t c_u_c_v;
};
static_assert((sizeof (sprite_type_1)) == 64);
static_assert((offsetof (struct sprite_type_1, parameter_control_word)) == 0x00);
static_assert((offsetof (struct sprite_type_1, a_x)) == 0x04);
static_assert((offsetof (struct sprite_type_1, a_y)) == 0x08);
static_assert((offsetof (struct sprite_type_1, a_z)) == 0x0c);
static_assert((offsetof (struct sprite_type_1, b_x)) == 0x10);
static_assert((offsetof (struct sprite_type_1, b_y)) == 0x14);
static_assert((offsetof (struct sprite_type_1, b_z)) == 0x18);
static_assert((offsetof (struct sprite_type_1, c_x)) == 0x1c);
static_assert((offsetof (struct sprite_type_1, c_y)) == 0x20);
static_assert((offsetof (struct sprite_type_1, c_z)) == 0x24);
static_assert((offsetof (struct sprite_type_1, d_x)) == 0x28);
static_assert((offsetof (struct sprite_type_1, d_y)) == 0x2c);
static_assert((offsetof (struct sprite_type_1, _res0)) == 0x30);
static_assert((offsetof (struct sprite_type_1, a_u_a_v)) == 0x34);
static_assert((offsetof (struct sprite_type_1, b_u_b_v)) == 0x38);
static_assert((offsetof (struct sprite_type_1, c_u_c_v)) == 0x3c);
struct modifier_volume {
uint32_t parameter_control_word;
float a_x;
float a_y;
float a_z;
float b_x;
float b_y;
float b_z;
float c_x;
float c_y;
float c_z;
uint32_t _res0;
uint32_t _res1;
uint32_t _res2;
uint32_t _res3;
uint32_t _res4;
uint32_t _res5;
};
static_assert((sizeof (modifier_volume)) == 64);
static_assert((offsetof (struct modifier_volume, parameter_control_word)) == 0x00);
static_assert((offsetof (struct modifier_volume, a_x)) == 0x04);
static_assert((offsetof (struct modifier_volume, a_y)) == 0x08);
static_assert((offsetof (struct modifier_volume, a_z)) == 0x0c);
static_assert((offsetof (struct modifier_volume, b_x)) == 0x10);
static_assert((offsetof (struct modifier_volume, b_y)) == 0x14);
static_assert((offsetof (struct modifier_volume, b_z)) == 0x18);
static_assert((offsetof (struct modifier_volume, c_x)) == 0x1c);
static_assert((offsetof (struct modifier_volume, c_y)) == 0x20);
static_assert((offsetof (struct modifier_volume, c_z)) == 0x24);
static_assert((offsetof (struct modifier_volume, _res0)) == 0x28);
static_assert((offsetof (struct modifier_volume, _res1)) == 0x2c);
static_assert((offsetof (struct modifier_volume, _res2)) == 0x30);
static_assert((offsetof (struct modifier_volume, _res3)) == 0x34);
static_assert((offsetof (struct modifier_volume, _res4)) == 0x38);
static_assert((offsetof (struct modifier_volume, _res5)) == 0x3c);
}

2
dreamcast2/memorymap.hpp
View File

@ -1,5 +1,3 @@
#pragma once
#include <cstdint>
extern volatile uint8_t system_boot_rom[0x200000] __asm("system_boot_rom") __attribute__((aligned(32)));

17
dreamcast2/regs.mk
View File

@ -13,25 +13,16 @@ holly/holly_bits.hpp: regs/holly/holly_bits.csv regs/render_bits.py
holly/core/region_array_bits.hpp: regs/holly/core/region_array_bits.csv regs/render_bits.py
python regs/render_bits.py $< holly::core::region_array > $@
holly/core/object_list_bits.hpp: regs/holly/core/object_list_bits.csv regs/render_bits.py
holly/core/object_list_bits.hpp:regs/holly/core/object_list_bits.csv regs/render_bits.py
python regs/render_bits.py $< holly::core::object_list > $@
holly/core/parameter_bits.hpp: regs/holly/core/parameter_bits.csv regs/render_bits.py
holly/core/parameter_bits.hpp:regs/holly/core/parameter_bits.csv regs/render_bits.py
python regs/render_bits.py $< holly::core::parameter > $@
holly/ta/parameter_bits.hpp: regs/holly/ta/parameter_bits.csv regs/render_bits.py
python regs/render_bits.py $< holly::ta::parameter > $@
holly/ta/global_parameter.hpp: regs/holly/ta/global_parameter.csv regs/render_ta_parameter_struct.py
python regs/render_ta_parameter_struct.py $< holly::ta::global_parameter > $@
holly/ta/vertex_parameter.hpp: regs/holly/ta/vertex_parameter.csv regs/render_ta_parameter_struct.py
python regs/render_ta_parameter_struct.py $< holly::ta::vertex_parameter > $@
# SH7091
sh7091/sh7091.hpp: regs/sh7091/sh7091.csv regs/render_sh7091.py
python regs/render_sh7091.py $< sh7091 > $@
sh7091/sh7091.hpp: regs/sh7091/sh7091.csv regs/sh7091.py
python regs/sh7091.py $< sh7091 > $@
sh7091/sh7091_bits.hpp: regs/sh7091/sh7091_bits.csv regs/render_bits.py
python regs/render_bits.py $< sh7091 > $@

126
dreamcast2/regs/generic_sparse_struct.py
View File

@ -1,126 +0,0 @@
from dataclasses import dataclass
class EndOfInput(Exception):
pass
def next_row(ix, rows, advance):
if ix >= len(rows):
raise EndOfInput
if advance:
while rows[ix][0] == "":
ix += 1
if ix >= len(rows):
raise EndOfInput
row = rows[ix]
ix += 1
return ix, row
@dataclass
class FieldDeclaration:
offset: int
name: str
default: int
array_length: str
@dataclass
class StructDeclaration:
name: str
fields: list[FieldDeclaration]
size: int
def parse_type_declaration(ix, rows, expected_offset, expected_sizes):
ix, row = next_row(ix, rows, advance=True)
assert len(row) in {2, 3}, row
struct_name, *empty = row
assert all(e == "" for e in empty)
fields = []
last_offset = 0 - expected_offset
res_ix = 0
def terminate():
size = last_offset + expected_offset
assert size in expected_sizes, size
return ix, StructDeclaration(
struct_name,
fields,
size
)
seen_names = set()
while True:
try:
ix, row = next_row(ix, rows, advance=False)
except EndOfInput:
return terminate()
if row[0] == "":
return terminate()
else:
default = None
if len(row) == 2:
_offset, name = row
elif len(row) == 3:
_offset, name, _default = row
if _default.strip() != "":
default = int(_default, 16)
else:
assert False, row
offset = int(_offset, 16)
assert offset == last_offset + expected_offset, (hex(offset), hex(last_offset))
last_offset = offset
if name == "":
name = f"_res{res_ix}"
res_ix += 1
if fields and fields[-1].name == name:
assert offset == fields[-1].offset + (fields[-1].array_length * expected_offset)
fields[-1].array_length += 1
else:
assert name not in seen_names, row
seen_names.add(name)
fields.append(FieldDeclaration(offset, name, default, 1))
def parse(rows, expected_offset, expected_sizes):
ix = 0
declarations = []
while True:
try:
ix, declaration = parse_type_declaration(ix, rows, expected_offset, expected_sizes)
except EndOfInput:
break
declarations.append(declaration)
return declarations
def render_static_assertions(declaration):
yield f"static_assert((sizeof ({declaration.name})) == {declaration.size});"
for field in declaration.fields:
yield f"static_assert((offsetof (struct {declaration.name}, {field.name})) == 0x{field.offset:02x});"
def render_declaration(declaration, get_type):
yield f"struct {declaration.name} {{"
for field in declaration.fields:
type = get_type(field.name)
if field.array_length == 1:
yield f"{type} {field.name};"
else:
yield f"{type} {field.name}[{field.array_length}];"
yield "};" # struct {declaration.name}
yield from render_static_assertions(declaration)
def render_declarations(namespace, declarations, get_type):
yield f"namespace {namespace} {{"
for declaration in declarations:
yield from render_declaration(declaration, get_type)
yield ""
yield "}"
def headers():
yield "#pragma once"
yield ""
yield "#include <cstdint>"
yield "#include <cstddef>"
yield ""

BIN
dreamcast2/regs/holly/ta/global_parameter.ods
View File

Binary file not shown.

BIN
dreamcast2/regs/holly/ta/parameter_bits.ods
View File

Binary file not shown.

BIN
dreamcast2/regs/holly/ta/vertex_parameter.ods
View File

Binary file not shown.

4
dreamcast2/regs/render_bits.py
View File

@ -152,7 +152,7 @@ def render_read_only(bit_def):
bits = parse_bit_range(bit_def["bits"])
mask_value = mask_from_bits(bits)
yield (
f"constexpr inline uint32_t {escape(bit_def['bit_name'])}(uint32_t reg) {{ "
f"constexpr uint32_t {escape(bit_def['bit_name'])}(uint32_t reg) {{ "
f"return (reg >> {min(bits)}) & {hex(mask_value)};"
" }"
)
@ -173,7 +173,7 @@ def render_mask(bit_def):
assert mask_value & mask_from_bits(bits) == mask_value, (mask_value, mask_from_bits(bits))
yield (
f"constexpr inline uint32_t {escape(bit_def['bit_name'])}(uint32_t num) {{ "
f"constexpr uint32_t {escape(bit_def['bit_name'])}(uint32_t num) {{ "
f"return (num & {hex(mask_value)}) << {min(bits)};"
" }"
)

68
dreamcast2/regs/render_ta_parameter_struct.py
View File

@ -1,68 +0,0 @@
import sys
from generate import renderer
from csv_input import read_input_headerless
from generic_sparse_struct import parse
from generic_sparse_struct import headers
from generic_sparse_struct import render_declarations
_field_types = {
"parameter_control_word": "uint32_t",
"user_clip_": "uint32_t",
"object_pointer": "uint32_t",
"bounding_box_": "uint32_t",
"isp_tsp_instruction_word": "uint32_t",
"tsp_instruction_word": "uint32_t",
"texture_control_word": "uint32_t",
"data_size_for_sort_dma": "uint32_t",
"next_address_for_sort_dma": "uint32_t",
"face_color_": "float",
"face_offset_color_": "float",
"x": "float",
"y": "float",
"z": "float",
"base_color_": "float",
"base_color_0": "uint32_t",
"base_color_1": "uint32_t",
"offset_color_0": "uint32_t",
"offset_color_1": "uint32_t",
"base_intensity_": "uint32_t",
"u": "float",
"v": "float",
"u_v": "uint32_t",
"base_color": "uint32_t",
"offset_color": "uint32_t",
"offset_color_": "float",
"base_intensity": "float",
"offset_intensity": "float",
"a_": "float",
"b_": "float",
"c_": "float",
"d_": "float",
"a_u_a_v": "uint32_t",
"b_u_b_v": "uint32_t",
"c_u_c_v": "uint32_t",
"_res": "uint32_t"
}
def get_type(field_name: str):
match = None
match_len = 0
for name, type in _field_types.items():
if field_name.startswith(name) and len(name) >= match_len:
match = type
assert match_len != len(name), (name, match)
match_len = len(name)
assert match != None, field_name
return match
if __name__ == "__main__":
rows = read_input_headerless(sys.argv[1])
namespace = sys.argv[2]
declarations = parse(rows,
expected_offset=4,
expected_sizes={32, 64})
render, out = renderer()
render(headers())
render(render_declarations(namespace, declarations, get_type))
print(out.getvalue())

BIN
dreamcast2/regs/sh7091/sh7091_bits.ods
View File

Binary file not shown.

14
dreamcast2/sh7091/pref.hpp
View File

@ -1,14 +0,0 @@
#pragma once
#define pref(address) \
{ asm volatile ("pref @%0" : : "r" ((uint32_t)(address)) : "memory"); }
namespace sh7091::ccn::qacr0 {
template <typename T>
constexpr inline uint32_t address(T a) { return (((uint32_t)a) >> 24) & 0b11100; }
}
namespace sh7091::ccn::qacr1 {
template <typename T>
constexpr inline uint32_t address(T a) { return (((uint32_t)a) >> 24) & 0b11100; }
}

62
dreamcast2/sh7091/sh7091_bits.hpp
View File

@ -5,12 +5,12 @@
namespace sh7091 {
namespace ccn {
namespace pteh {
constexpr inline uint32_t VPN(uint32_t reg) { return (reg >> 10) & 0x3fffff; }
constexpr inline uint32_t ASID(uint32_t reg) { return (reg >> 0) & 0xff; }
constexpr uint32_t VPN(uint32_t reg) { return (reg >> 10) & 0x3fffff; }
constexpr uint32_t ASID(uint32_t reg) { return (reg >> 0) & 0xff; }
}
namespace ptel {
constexpr inline uint32_t PPN(uint32_t reg) { return (reg >> 10) & 0x7ffff; }
constexpr uint32_t PPN(uint32_t reg) { return (reg >> 10) & 0x7ffff; }
namespace v {
constexpr uint32_t invalid = 0 << 8;
@ -67,9 +67,9 @@ namespace sh7091 {
}
namespace mmucr {
constexpr inline uint32_t LRUI(uint32_t reg) { return (reg >> 26) & 0x3f; }
constexpr inline uint32_t URB(uint32_t reg) { return (reg >> 18) & 0x3f; }
constexpr inline uint32_t URC(uint32_t reg) { return (reg >> 10) & 0x3f; }
constexpr uint32_t LRUI(uint32_t reg) { return (reg >> 26) & 0x3f; }
constexpr uint32_t URB(uint32_t reg) { return (reg >> 18) & 0x3f; }
constexpr uint32_t URC(uint32_t reg) { return (reg >> 10) & 0x3f; }
namespace sqmd {
constexpr uint32_t user_privileged_access_possible = 0 << 9;
@ -100,11 +100,11 @@ namespace sh7091 {
}
namespace basra {
constexpr inline uint32_t basa(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t basa(uint32_t num) { return (num & 0xff) << 0; }
}
namespace basrb {
constexpr inline uint32_t basa(uint32_t num) { return (num & 0xff) << 0; }
constexpr uint32_t basa(uint32_t num) { return (num & 0xff) << 0; }
}
namespace ccr {
@ -171,15 +171,15 @@ namespace sh7091 {
}
namespace tra {
constexpr inline uint32_t imm(uint32_t reg) { return (reg >> 2) & 0xff; }
constexpr uint32_t imm(uint32_t reg) { return (reg >> 2) & 0xff; }
}
namespace expevt {
constexpr inline uint32_t exception_code(uint32_t reg) { return (reg >> 0) & 0xfff; }
constexpr uint32_t exception_code(uint32_t reg) { return (reg >> 0) & 0xfff; }
}
namespace intevt {
constexpr inline uint32_t exception_code(uint32_t reg) { return (reg >> 0) & 0xfff; }
constexpr uint32_t exception_code(uint32_t reg) { return (reg >> 0) & 0xfff; }
}
namespace ptea {
@ -205,18 +205,18 @@ namespace sh7091 {
}
namespace qacr0 {
constexpr inline uint32_t area(uint32_t num) { return (num & 0x7) << 2; }
constexpr uint32_t area(uint32_t num) { return (num & 0x7) << 2; }
}
namespace qacr1 {
constexpr inline uint32_t area(uint32_t num) { return (num & 0x7) << 2; }
constexpr uint32_t area(uint32_t num) { return (num & 0x7) << 2; }
}
}
namespace dmac {
namespace dmatcr {
constexpr inline uint32_t transfer_count(uint32_t num) { return (num & 0xffffff) << 0; }
constexpr uint32_t transfer_count(uint32_t num) { return (num & 0xffffff) << 0; }
}
namespace chcr {
@ -305,7 +305,7 @@ namespace sh7091 {
}
namespace rs {
constexpr inline uint32_t resource_select(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t resource_select(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t bit_mask = 0xf << 8;
}
@ -429,23 +429,23 @@ namespace sh7091 {
}
namespace ipra {
constexpr inline uint32_t TMU0(uint32_t num) { return (num & 0xf) << 12; }
constexpr inline uint32_t TMU1(uint32_t num) { return (num & 0xf) << 8; }
constexpr inline uint32_t TMU2(uint32_t num) { return (num & 0xf) << 4; }
constexpr inline uint32_t RTC(uint32_t num) { return (num & 0xf) << 0; }
constexpr uint32_t TMU0(uint32_t num) { return (num & 0xf) << 12; }
constexpr uint32_t TMU1(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t TMU2(uint32_t num) { return (num & 0xf) << 4; }
constexpr uint32_t RTC(uint32_t num) { return (num & 0xf) << 0; }
}
namespace iprb {
constexpr inline uint32_t WDT(uint32_t num) { return (num & 0xf) << 12; }
constexpr inline uint32_t REF(uint32_t num) { return (num & 0xf) << 8; }
constexpr inline uint32_t SCI1(uint32_t num) { return (num & 0xf) << 4; }
constexpr uint32_t WDT(uint32_t num) { return (num & 0xf) << 12; }
constexpr uint32_t REF(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t SCI1(uint32_t num) { return (num & 0xf) << 4; }
}
namespace iprc {
constexpr inline uint32_t GPIO(uint32_t num) { return (num & 0xf) << 12; }
constexpr inline uint32_t DMAC(uint32_t num) { return (num & 0xf) << 8; }
constexpr inline uint32_t SCIF(uint32_t num) { return (num & 0xf) << 4; }
constexpr inline uint32_t UDI(uint32_t num) { return (num & 0xf) << 0; }
constexpr uint32_t GPIO(uint32_t num) { return (num & 0xf) << 12; }
constexpr uint32_t DMAC(uint32_t num) { return (num & 0xf) << 8; }
constexpr uint32_t SCIF(uint32_t num) { return (num & 0xf) << 4; }
constexpr uint32_t UDI(uint32_t num) { return (num & 0xf) << 0; }
}
}
@ -653,13 +653,13 @@ namespace sh7091 {
namespace scfsr2 {
namespace per3_0 {
constexpr inline uint32_t number_of_parity_errors(uint32_t reg) { return (reg >> 12) & 0xf; }
constexpr uint32_t number_of_parity_errors(uint32_t reg) { return (reg >> 12) & 0xf; }
constexpr uint32_t bit_mask = 0xf << 12;
}
namespace fer3_0 {
constexpr inline uint32_t number_of_framing_errors(uint32_t reg) { return (reg >> 8) & 0xf; }
constexpr uint32_t number_of_framing_errors(uint32_t reg) { return (reg >> 8) & 0xf; }
constexpr uint32_t bit_mask = 0xf << 8;
}
@ -770,8 +770,8 @@ namespace sh7091 {
}
namespace scfdr2 {
constexpr inline uint32_t transmit_data_bytes(uint32_t reg) { return (reg >> 8) & 0x1f; }
constexpr inline uint32_t receive_data_bytes(uint32_t reg) { return (reg >> 0) & 0x1f; }
constexpr uint32_t transmit_data_bytes(uint32_t reg) { return (reg >> 8) & 0x1f; }
constexpr uint32_t receive_data_bytes(uint32_t reg) { return (reg >> 0) & 0x1f; }
}
namespace scsptr2 {
@ -836,7 +836,7 @@ namespace sh7091 {
constexpr uint32_t fd = 1 << 15;
constexpr uint32_t m = 1 << 9;
constexpr uint32_t q = 1 << 8;
constexpr inline uint32_t imask(uint32_t num) { return (num & 0xf) << 4; }
constexpr uint32_t imask(uint32_t num) { return (num & 0xf) << 4; }
constexpr uint32_t s = 1 << 1;
constexpr uint32_t t = 1 << 0;
}

11
dreamcast2/sh7091/store_queue_transfer.hpp
View File

@ -1,7 +1,6 @@
#pragma once
#include "sh7091/sh7091.hpp"
#include "sh7091/pref.hpp"
#include "memorymap.hpp"
namespace sh7091 {
@ -32,7 +31,10 @@ namespace sh7091 {
base[5] = src32[5];
base[6] = src32[6];
base[7] = src32[7];
pref(&base[0])
asm volatile ("pref @%0"
: // output
: "r" (&base[0]) // input
: "memory");
length -= 32;
base += 8;
src32 += 8;
@ -64,7 +66,10 @@ namespace sh7091 {
base[5] = value;
base[6] = value;
base[7] = value;
pref(&base[0]);
asm volatile ("pref @%0"
: // output
: "r" (&base[0]) // input
: "memory");
length -= 32;
base += 8;
}

10
dreamcast2/systembus/systembus_bits.hpp
View File

@ -4,11 +4,11 @@
namespace systembus {
namespace c2dstat {
constexpr inline uint32_t texture_memory_start_address(uint32_t num) { return (num & 0x13ffffe0) << 0; }
constexpr uint32_t texture_memory_start_address(uint32_t num) { return (num & 0x13ffffe0) << 0; }
}
namespace c2dlen {
constexpr inline uint32_t transfer_length(uint32_t num) { return (num & 0xffffe0) << 0; }
constexpr uint32_t transfer_length(uint32_t num) { return (num & 0xffffe0) << 0; }
}
namespace c2dst {
@ -74,9 +74,9 @@ namespace systembus {
}
namespace ffst {
constexpr inline uint32_t holly_cpu_if_block_internal_write_buffer(uint32_t reg) { return (reg >> 5) & 0x1; }
constexpr inline uint32_t holly_g2_if_block_internal_write_buffer(uint32_t reg) { return (reg >> 4) & 0x1; }
constexpr inline uint32_t aica_internal_write_buffer(uint32_t reg) { return (reg >> 0) & 0x1; }
constexpr uint32_t holly_cpu_if_block_internal_write_buffer(uint32_t reg) { return (reg >> 5) & 0x1; }
constexpr uint32_t holly_g2_if_block_internal_write_buffer(uint32_t reg) { return (reg >> 4) & 0x1; }
constexpr uint32_t aica_internal_write_buffer(uint32_t reg) { return (reg >> 0) & 0x1; }
}
namespace istext {

43
tools/ftdi_transfer.cpp
View File

@ -8,7 +8,6 @@
#include <string.h>
#include <math.h>
#include <errno.h>
#include <unistd.h>
#include <ftdi.h>
#include <libusb.h>
@ -88,48 +87,6 @@ int init_ftdi_context(struct ftdi_context * ftdi, uint32_t scbrr)
}
ftdi_list_free(&devlist);
if (0) {
for (int i = 0; i < 2; i++) {
timespec t = {.tv_sec = 0, .tv_nsec = 33000 * 2 };
// toggle ACBUS5 low (g reset asserted)
uint8_t bitmask1 = (0b0001 << 4) | (0b0001 << 0);
res = ftdi_set_bitmode(ftdi, bitmask1, BITMODE_CBUS);
if (res < 0) {
fprintf(stderr, "ftdi_set_bitmode: %s\n", ftdi_get_error_string(ftdi));
return -1;
}
printf("cbus1\n");
nanosleep(&t, NULL);
// toggle ACBUS5 low (g reset deasserted)
uint8_t bitmask2 = (0b0000 << 4) | (0b0001 << 0);
res = ftdi_set_bitmode(ftdi, bitmask2, BITMODE_CBUS);
if (res < 0) {
fprintf(stderr, "ftdi_set_bitmode: %s\n", ftdi_get_error_string(ftdi));
return -1;
}
printf("cbus2\n");
nanosleep(&t, NULL);
}
uint8_t bitmask2 = (0b0000 << 4) | (0b0000 << 0);
res = ftdi_set_bitmode(ftdi, bitmask2, BITMODE_CBUS);
if (res < 0) {
fprintf(stderr, "ftdi_set_bitmode: %s\n", ftdi_get_error_string(ftdi));
return -1;
}
sleep(2);
printf("cbus3\n");
ftdi_disable_bitbang(ftdi);
//while (1);
//return 0;
}
res = ftdi_set_baudrate(ftdi, round(dreamcast_rate(current_cks, scbrr)));
if (res < 0) {
fprintf(stderr, "ftdi_set_baudrate: %s\n", ftdi_get_error_string(ftdi));