Disabble PVR_CULLING_SMALL

src/liberty/fakerw/fake.cpp

@@ -449,8 +449,8 @@ RwBool RwIm3DRenderPrimitive(RwPrimitiveType primType);
 
 RwBool RwRenderStateGet(RwRenderState state, void *value)
 {
-	uint32_t *uival = (uint32_t*)value;
-	uint32_t fog;
+	uint32 *uival = (uint32*)value;
+	uint32 fog;
 	switch(state){
 	case rwRENDERSTATETEXTURERASTER: *(void**)value = GetRenderStatePtr(TEXTURERASTER); return true;
 	case rwRENDERSTATETEXTUREADDRESS: *uival = GetRenderState(TEXTUREADDRESS); return true;
@@ -496,8 +496,8 @@ RwBool RwRenderStateGet(RwRenderState state, void *value)
 }
 RwBool RwRenderStateSet(RwRenderState state, void *value)
 {
-	uint32_t uival = (uintptr_t)value;
-	uint32_t fog;
+	uint32 uival = (uintptr)value;
+	uint32 fog;
 	switch(state){
 	case rwRENDERSTATETEXTURERASTER: SetRenderStatePtr(TEXTURERASTER, value); return true;
 	case rwRENDERSTATETEXTUREADDRESS: SetRenderState(TEXTUREADDRESS, uival); return true;
@@ -544,8 +544,8 @@ RwBool RwRenderStateSet(RwRenderState state, void *value)
 static rw::MemoryFunctions gMemfuncs;
 static void *(*real_malloc)(size_t size);
 static void *(*real_realloc)(void *mem, size_t newSize);
-static void *mallocWrap(size_t sz, uint32_t hint) { if(sz == 0) return nil; return real_malloc(sz); }
-static void *reallocWrap(void *p, size_t sz, uint32_t hint) { return real_realloc(p, sz); }
+static void *mallocWrap(size_t sz, uint32 hint) { if(sz == 0) return nil; return real_malloc(sz); }
+static void *reallocWrap(void *p, size_t sz, uint32 hint) { return real_realloc(p, sz); }
 
 
 // WARNING: unused parameters
@@ -830,7 +830,7 @@ RwCamera *RwCameraForAllClumpsNotInFrustum(RwCamera *camera, RwInt32 numClumps,
 RwBool RpMatFXPluginAttach( void ) { registerMatFXPlugin(); return true; }
 RpAtomic *RpMatFXAtomicEnableEffects( RpAtomic *atomic ) { MatFX::enableEffects(atomic); return atomic; }
 RpMatFXMaterialFlags RpMatFXMaterialGetEffects( const RpMaterial *material ){ return (RpMatFXMaterialFlags)MatFX::getEffects(material); }
-RpMaterial *RpMatFXMaterialSetEffects( RpMaterial *material, RpMatFXMaterialFlags flags ) { MatFX::setEffects(material, (uint32_t)flags); return material; }
+RpMaterial *RpMatFXMaterialSetEffects( RpMaterial *material, RpMatFXMaterialFlags flags ) { MatFX::setEffects(material, (uint32)flags); return material; }
 RpMaterial *RpMatFXMaterialSetupEnvMap( RpMaterial *material, RwTexture *texture, RwFrame *frame, RwBool useFrameBufferAlpha, RwReal coef ) {
 	MatFX *mfx = MatFX::get(material);
 	mfx->setEnvTexture(texture);

src/liberty/skel/crossplatform.h

@@ -13,9 +13,7 @@ enum eWinVersion
     OS_WINXP,
 };
 
-#ifdef _WIN64
-#include <windows.h>
-#elif defined(_WIN32)
+#ifdef _WIN32
 
 // As long as WITHWINDOWS isn't defined / <Windows.h> isn't included, we only need type definitions so let's include <IntSafe.h>.
 // NOTE: It's perfectly fine to include <Windows.h> here, but it can increase build size and time in *some* conditions, and maybe substantially in future if we'll use crossplatform.h more.

src/miami/fakerw/fake.cpp

@@ -450,8 +450,8 @@ RwBool RwIm3DRenderPrimitive(RwPrimitiveType primType);
 
 RwBool RwRenderStateGet(RwRenderState state, void *value)
 {
-	uint32_t *uival = (uint32_t*)value;
-	uint32_t fog;
+	uint32 *uival = (uint32*)value;
+	uint32 fog;
 	switch(state){
 	case rwRENDERSTATETEXTURERASTER: *(void**)value = GetRenderStatePtr(TEXTURERASTER); return true;
 	case rwRENDERSTATETEXTUREADDRESS: *uival = GetRenderState(TEXTUREADDRESS); return true;
@@ -497,8 +497,8 @@ RwBool RwRenderStateGet(RwRenderState state, void *value)
 }
 RwBool RwRenderStateSet(RwRenderState state, void *value)
 {
-	uint32_t uival = (uintptr_t)value;
-	uint32_t fog;
+	uint32 uival = (uintptr)value;
+	uint32 fog;
 	switch(state){
 	case rwRENDERSTATETEXTURERASTER: SetRenderStatePtr(TEXTURERASTER, value); return true;
 	case rwRENDERSTATETEXTUREADDRESS: SetRenderState(TEXTUREADDRESS, uival); return true;
@@ -545,8 +545,8 @@ RwBool RwRenderStateSet(RwRenderState state, void *value)
 static rw::MemoryFunctions gMemfuncs;
 static void *(*real_malloc)(size_t size);
 static void *(*real_realloc)(void *mem, size_t newSize);
-static void *mallocWrap(size_t sz, uint32_t hint) { if(sz == 0) return nil; return real_malloc(sz); }
-static void *reallocWrap(void *p, size_t sz, uint32_t hint) { return real_realloc(p, sz); }
+static void *mallocWrap(size_t sz, uint32 hint) { if(sz == 0) return nil; return real_malloc(sz); }
+static void *reallocWrap(void *p, size_t sz, uint32 hint) { return real_realloc(p, sz); }
 
 
 // WARNING: unused parameters
@@ -832,7 +832,7 @@ RwCamera *RwCameraForAllClumpsNotInFrustum(RwCamera *camera, RwInt32 numClumps,
 RwBool RpMatFXPluginAttach( void ) { registerMatFXPlugin(); return true; }
 RpAtomic *RpMatFXAtomicEnableEffects( RpAtomic *atomic ) { MatFX::enableEffects(atomic); return atomic; }
 RpMatFXMaterialFlags RpMatFXMaterialGetEffects( const RpMaterial *material ){ return (RpMatFXMaterialFlags)MatFX::getEffects(material); }
-RpMaterial *RpMatFXMaterialSetEffects( RpMaterial *material, RpMatFXMaterialFlags flags ) { MatFX::setEffects(material, (uint32_t)flags); return material; }
+RpMaterial *RpMatFXMaterialSetEffects( RpMaterial *material, RpMatFXMaterialFlags flags ) { MatFX::setEffects(material, (uint32)flags); return material; }
 RpMaterial *RpMatFXMaterialSetupEnvMap( RpMaterial *material, RwTexture *texture, RwFrame *frame, RwBool useFrameBufferAlpha, RwReal coef ) {
 	MatFX *mfx = MatFX::get(material);
 	mfx->setEnvTexture(texture);

src/miami/skel/crossplatform.h

@@ -17,7 +17,7 @@ enum eWinVersion
 char *_strdate(char *buf);
 #endif
 
-#if defined(_WIN32) || defined(_WIN64)
+#ifdef _WIN32
 
 // As long as WITHWINDOWS isn't defined / <Windows.h> isn't included, we only need type definitions so let's include <IntSafe.h>.
 // NOTE: It's perfectly fine to include <Windows.h> here, but it can increase build size and time in *some* conditions, and maybe substantially in future if we'll use crossplatform.h more.

vendor/emu/lxdream/tacore.cpp

@@ -182,8 +182,7 @@ struct pvr2_ta_status {
     int32_t state;
     int32_t width, height; /* Tile resolution, ie 20x15 */
     int32_t tilelist_dir; /* Growth direction of the tilelist, 0 = up, 1 = down */
-    // uint32_t tilelist_size; /* Size of the tilelist segments */
-    // this needs to be current_tile_size
+    uint32_t tilelist_size; /* Size of the tilelist segments */
     uint32_t tilelist_start; /* Initial address of the tilelist */
     uint32_t polybuf_start; /* Initial bank address of the polygon buffer (ie &0x00F00000) */
     int32_t current_vertex_type;
@@ -209,9 +208,6 @@ struct pvr2_ta_status {
     struct tile_bounds last_triangle_bounds;
     struct pvr2_ta_vertex poly_vertex[8];
     uint32_t debug_output;
-
-    bool modifier_last_volume;
-    struct tile_bounds modifier_bounds;
 };
 
 static struct pvr2_ta_status ta_status;
@@ -257,9 +253,13 @@ void lxd_ta_init(u8* vram) {
     ta_status.clip.y2 = ta_status.height-1;
     uint32_t control = TA_ALLOC_CTRL; //MMIO_READ( PVR2, TA_TILECFG );
     ta_status.tilelist_dir = (control >> 20) & 0x01;
+    ta_status.tilelist_size = tilematrix_sizes[ (control & 0x03) ];
     TA_ISP_CURRENT = TA_ISP_BASE;
     //MMIO_WRITE( PVR2, TA_POLYPOS, MMIO_READ( PVR2, TA_POLYBASE ) );
     uint32_t plistpos = TA_NEXT_OPB_INIT >> 2; //MMIO_READ( PVR2, TA_LISTBASE )
+    if( ta_status.tilelist_dir == TA_GROW_DOWN ) {
+        plistpos -= ta_status.tilelist_size;
+    }
     TA_NEXT_OPB = plistpos;
     //MMIO_WRITE( PVR2, TA_LISTPOS, plistpos );
     ta_status.tilelist_start = plistpos;
@@ -433,9 +433,7 @@ static uint32_t ta_alloc_tilelist( uint32_t reference ) {
     uint32_t limit = TA_OL_LIMIT >> 2;//MMIO_READ( PVR2, TA_LISTEND ) >> 2;
     uint32_t newposn;
     if( ta_status.tilelist_dir == TA_GROW_DOWN ) {
-        // printf("**TA WARNING**: Allocating tilelist in GROW_DOWN mode\n");
-        posn -= ta_status.current_tile_size;
-        newposn = posn;
+        newposn = posn - ta_status.tilelist_size;
         if( posn == limit ) {
             PVRRAM(posn<<2) = 0xF0000000;
             PVRRAM(reference) = 0xE0000000 | (posn<<2);
@@ -444,7 +442,7 @@ static uint32_t ta_alloc_tilelist( uint32_t reference ) {
             PVRRAM(reference) = 0xE0000000 | (posn<<2);
             return TA_NO_ALLOC;
         } else if( newposn <= limit ) {
-        } else if( newposn <= (limit + ta_status.current_tile_size) ) {
+        } else if( newposn <= (limit + ta_status.tilelist_size) ) {
             // asic_RaiseInterrupt(holly_MATR_NOMEM);
             pvr_queue_interrupt(ASIC_EVT_PVR_OPB_OUTOFMEM);
             printf("TA error: holly_MATR_NOMEM. Interrupt raised\n");
@@ -458,7 +456,7 @@ static uint32_t ta_alloc_tilelist( uint32_t reference ) {
         PVRRAM(reference) = 0xE0000000 | (posn<<2);
         return posn << 2;
     } else {
-        newposn = posn + ta_status.current_tile_size;
+        newposn = posn + ta_status.tilelist_size;
         if( posn == limit ) {
             PVRRAM(posn<<2) = 0xF0000000;
             PVRRAM(reference) = 0xE0000000 | (posn<<2);
@@ -467,7 +465,7 @@ static uint32_t ta_alloc_tilelist( uint32_t reference ) {
             PVRRAM(reference) = 0xE0000000 | (posn<<2);
             return TA_NO_ALLOC;
         } else if( newposn >= limit ) {
-        } else if( newposn >= (limit - ta_status.current_tile_size) ) {
+        } else if( newposn >= (limit - ta_status.tilelist_size) ) {
             // asic_RaiseInterrupt(holly_MATR_NOMEM);
             pvr_queue_interrupt(ASIC_EVT_PVR_OPB_OUTOFMEM);
             printf("TA error: holly_MATR_NOMEM. Interrupt raised\n");
@@ -623,17 +621,6 @@ static void ta_commit_polygon( ) {
     if( polygon_bound.y1 < 0 ) polygon_bound.y1 = 0;
     if( polygon_bound.y2 >= ta_status.height ) polygon_bound.y2 = ta_status.height-1;
 
-    if (ta_status.current_vertex_type == TA_VERTEX_MOD_VOLUME) {
-        ta_status.modifier_bounds.x1 = MIN(ta_status.modifier_bounds.x1, polygon_bound.x1);
-        ta_status.modifier_bounds.x2 = MAX(ta_status.modifier_bounds.x2, polygon_bound.x2);
-        ta_status.modifier_bounds.y1 = MIN(ta_status.modifier_bounds.y1, polygon_bound.y1);
-        ta_status.modifier_bounds.y2 = MAX(ta_status.modifier_bounds.y2, polygon_bound.y2);
-    
-        if (ta_status.modifier_last_volume) {
-            polygon_bound = ta_status.modifier_bounds;
-        }
-    }
-
     /* Set the "single tile" flag if it's entirely contained in 1 tile */
     if( polygon_bound.x1 == polygon_bound.x2 &&
             polygon_bound.y1 == polygon_bound.y2 ) {
@@ -856,14 +843,6 @@ static void ta_parse_modifier_context( union ta_data *data ) {
     ta_status.vertex_count = 0;
     ta_status.max_vertex = 3;
     ta_status.poly_pointer = 0;
-
-    if (ta_status.modifier_last_volume) {
-        ta_status.modifier_bounds.x1 = INT_MAX/32;
-        ta_status.modifier_bounds.y1 = INT_MAX/32;
-        ta_status.modifier_bounds.x2 = -1;
-        ta_status.modifier_bounds.y2 = -1;
-    }
-    ta_status.modifier_last_volume = data[0].i & TA_POLYCMD_FULLMOD;
 }
 
 /**
@@ -1027,11 +1006,7 @@ static void ta_parse_vertex( union ta_data *data ) {
         vertex++;
         vertex->x = data[7].f;
         ta_status.vertex_count += 2;
-        if (ta_status.current_vertex_type  == TA_VERTEX_SPRITE || ta_status.current_vertex_type == TA_VERTEX_TEX_SPRITE) {
-            ta_status.state = STATE_EXPECT_END_VERTEX_BLOCK2;
-        } else {
-            ta_status.state = STATE_EXPECT_VERTEX_BLOCK2;
-        }
+        ta_status.state = STATE_EXPECT_VERTEX_BLOCK2;
         break;
     }
     ta_status.vertex_count++;

vendor/emu/refsw/TexUtils.cpp

@@ -14,9 +14,9 @@
 #endif
 
 u32 detwiddle[2][11][1024];
-s8 BM_SIN90[256];
-s8 BM_COS90[256];
-s8 BM_COS360[256];
+u8 BM_SIN90[256];
+u8 BM_COS90[256];
+u8 BM_COS360[256];
 
 //input : address in the yyyyyxxxxx format
 //output : address in the xyxyxyxy format
@@ -70,9 +70,9 @@ void BuildTables()
 	}
 
 	for (int i = 0; i < 256; i++) {
-		BM_SIN90[i]  = 127 * sinf((i / 256.0f) * (M_PI / 2));
-		BM_COS90[i]  = 127 * cosf((i / 256.0f) * (M_PI / 2));
-		BM_COS360[i] = 127 * cosf((i / 256.0f) * (2 * M_PI));
+		BM_SIN90[i]  = 255 * sinf((i / 256.0f) * (M_PI / 2));
+		BM_COS90[i]  = 255 * cosf((i / 256.0f) * (M_PI / 2));
+		BM_COS360[i] = 255 * cosf((i / 256.0f) * (2 * M_PI));
 	}
 	
 }

vendor/emu/refsw/TexUtils.h

@@ -8,9 +8,9 @@
 #include <algorithm>
 
 extern u32 detwiddle[2][11][1024];
-extern s8 BM_SIN90[256];
-extern s8 BM_COS90[256];
-extern s8 BM_COS360[256];
+extern u8 BM_SIN90[256];
+extern u8 BM_COS90[256];
+extern u8 BM_COS360[256];
 
 void BuildTables();
 

vendor/emu/refsw/gentable.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-import itertools
-
-def generate_table(name, parameters):
-    """
-    Generates C++ code for PixelFlush_tsp_table given parameter ranges.
-    :param parameters: tuple of ints, the range for each template parameter
-    :return: string containing the C++ table declaration and initializer
-    """
-    num_params = len(parameters)
-    # Construct the table dimensions
-    dims = ''.join(f'[{p}]' for p in parameters)
-    # Start building the initializer as a list of strings
-    lines = []
-
-    def recurse(level, indices, indent):
-        if level == num_params:
-            # Leaf: generate function pointer
-            params_list = ', '.join(str(i) for i in indices)
-            lines.append(f"{indent}&{name}<{params_list}>,")
-        else:
-            # Open brace for this dimension
-            lines.append(f"{indent}{{")
-            for i in range(parameters[level]):
-                recurse(level + 1, indices + [i], indent + '    ')
-            # Close brace
-            if level != 0:
-                lines.append(f"{indent}}},")
-            else:
-                lines.append(f"{indent}}}")
-
-    # Table declaration
-    decl = f"{name}_fp {name}_table{dims} ="
-    lines.append(decl)
-    recurse(0, [], '    ')
-    lines.append(';')
-
-    return '\n'.join(lines)
-
-if __name__ == '__main__':
-    # Example usage: each bool has 2 possibilities, some enums have more
-    bitwidths = (
-        1, # [pp_AlphaTest]
-        1, # [entry->params.tsp[two_voume_index].UseAlpha]
-        1, # [entry->params.isp.Texture]
-        1, # [entry->params.isp.Offset]
-        1, # [entry->params.tsp[two_voume_index].ColorClamp]
-        2, # [entry->params.tsp[two_voume_index].FogCtrl]
-        1, # [FPU_SHAD_SCALE.intensity_shadow]
-    )
-    code = generate_table("PixelFlush_tsp", tuple(1 << bw for bw in bitwidths))
-    print(code)
-
-    bitwidths = (
-        1, # [entry->params.tsp[two_voume_index].IgnoreTexA]
-        1, # [entry->params.tsp[two_voume_index].ClampU]
-        1, # [entry->params.tsp[two_voume_index].ClampV]
-        1, # [entry->params.tsp[two_voume_index].FlipU]
-        1, # [entry->params.tsp[two_voume_index].FlipV]
-        2, # [entry->params.tsp[two_voume_index].FilterMode]
-    )
-    code = generate_table("TextureFilter", tuple(1 << bw for bw in bitwidths))
-    print(code)
-
-    bitwidths = (
-        1, # [entry->params.isp.Texture]
-        1, # [entry->params.isp.Offset]
-        2, # [entry->params.tsp[two_voume_index].ShadInstr ]
-    )
-    code = generate_table("ColorCombiner", tuple(1 << bw for bw in bitwidths))
-    print(code)
-
-    bitwidths = (
-        1, # [entry->params.tsp[two_voume_index].SrcSelect]
-        1, # [entry->params.tsp[two_voume_index].DstSelect]
-        3, # [entry->params.tsp[two_voume_index].SrcInstr]
-        3, # [entry->params.tsp[two_voume_index].DstInstr]
-    )
-    code = generate_table("BlendingUnit", tuple(1 << bw for bw in bitwidths))
-    print(code)
-
-    bitwidths = (
-        1, # [entry->params.tcw[two_voume_index].VQ_Comp]
-        1, # [entry->params.tcw[two_voume_index].MipMapped]
-        1, # [entry->params.tcw[two_voume_index].ScanOrder]
-        1, # [entry->params.tcw[two_voume_index].StrideSel]
-        3, # [entry->params.tcw[two_voume_index].PixelFmt]
-    )
-    code = generate_table("TextureFetch", tuple(1 << bw for bw in bitwidths))
-    print(code)

vendor/emu/refsw/refsw_lists.cpp

@@ -81,16 +81,34 @@
 
 #include "refsw_tile.h"
 
+#define JLOG(...)
+#define JLOG2(...)
+#define V(x) x
+
+void log_vertex(const Vertex& v) {
+    JLOG(ll, 
+        V(v.x), V(v.y), V(v.z),
+        V(v.col[0]), V(v.col[1]), V(v.col[2]), V(v.col[3]), V(v.spc[0]), V(v.spc[1]), V(v.spc[2]), V(v.spc[3]), V(v.u), V(v.v),
+        V(v.col1[0]), V(v.col1[1]), V(v.col1[2]), V(v.col1[3]), V(v.spc1[0]), V(v.spc1[1]), V(v.spc1[2]), V(v.spc1[3]), V(v.u1), V(v.v1)
+    );
+}
+
 /*
     Main renderer class
 */
-void RenderTriangle(RenderMode render_mode, DrawParameters* params, parameter_tag_t tag, const Vertex& v1, const Vertex& v2, const Vertex& v3, const Vertex* v4, taRECT* area)
-{   
-    RasterizeTriangle_table[render_mode](params, tag, v1, v2, v3, v4, area);
 
-    if (render_mode == RM_TRANSLUCENT_PRESORT) {
-        RenderParamTags<RM_TRANSLUCENT_PRESORT>(area->left, area->top);
+void RenderTriangle(RenderMode render_mode, DrawParameters* params, parameter_tag_t tag, const Vertex& v1, const Vertex& v2, const Vertex& v3, const Vertex* v4, taRECT* area)
+{
+    JLOG(ll, V(render_mode), V(tag), "tsp0", params->tsp[0].full, "tcw0", params->tcw[0].full, "tsp1", params->tsp[1].full, "tcw1", params->tcw[1].full);
+
+    log_vertex(v1);
+    log_vertex(v2);
+    log_vertex(v3);
+    if (v4) { 
+        log_vertex(*v4);
     }
+    
+    RasterizeTriangle(render_mode, params, tag, v1, v2, v3, v4, area);
 
     if (render_mode == RM_MODIFIER)
     {
@@ -120,7 +138,6 @@ u32 ReadRegionArrayEntry(u32 base, RegionArrayEntry* entry)
     u32 rv;
     if (fmt_v1)
     {
-        entry->control.pre_sort = ISP_FEED_CFG.pre_sort;
         entry->puncht.full = 0x80000000;
         rv = 5 * 4;
     }
@@ -143,13 +160,13 @@ u32 ReadRegionArrayEntry(u32 base, RegionArrayEntry* entry)
 	}
 
 ISP_BACKGND_T_type CoreTagFromDesc(u32 cache_bypass, u32 shadow, u32 skip, u32 param_offs_in_words, u32 tag_offset) {
-    ISP_BACKGND_T_type rv;
-    rv.full = 0;
-    rv.tag_offset = tag_offset;
-    rv.param_offs_in_words = param_offs_in_words;
-    rv.skip = skip;
-    rv.shadow = shadow;
-    rv.cache_bypass = cache_bypass;
+    ISP_BACKGND_T_type rv {
+        .tag_offset = tag_offset,
+        .param_offs_in_words = param_offs_in_words,
+        .skip = skip,
+        .shadow = shadow,
+        .cache_bypass = cache_bypass 
+    };
 
     return rv;
 }
@@ -157,6 +174,8 @@ ISP_BACKGND_T_type CoreTagFromDesc(u32 cache_bypass, u32 shadow, u32 skip, u32 p
 // render a triangle strip object list entry
 void RenderTriangleStrip(RenderMode render_mode, ObjectListEntry obj, taRECT* rect)
 {
+    JLOG(ll, V(render_mode), "obj", obj.full);
+
     Vertex vtx[8];
     DrawParameters params;
 
@@ -185,6 +204,7 @@ void RenderTriangleStrip(RenderMode render_mode, ObjectListEntry obj, taRECT* re
 // render a triangle array object list entry
 void RenderTriangleArray(RenderMode render_mode, ObjectListEntry obj, taRECT* rect)
 {
+    JLOG(ll, V(render_mode), "obj", obj.full);
     auto triangles = obj.tarray.prims + 1;
     u32 param_base = PARAM_BASE & 0xF00000;
 
@@ -202,6 +222,8 @@ void RenderTriangleArray(RenderMode render_mode, ObjectListEntry obj, taRECT* re
             
         parameter_tag_t tag  = CoreTagFromDesc(params.isp.CacheBypass, obj.tstrip.shadow, obj.tstrip.skip, (tag_address - param_base)/4, 0).full;
 
+        assert(!(tag & TAG_INVALID));
+
         RenderTriangle(render_mode, &params, tag, vtx[0], vtx[1], vtx[2], nullptr, rect);
     }
 }
@@ -209,6 +231,8 @@ void RenderTriangleArray(RenderMode render_mode, ObjectListEntry obj, taRECT* re
 // render a quad array object list entry
 void RenderQuadArray(RenderMode render_mode, ObjectListEntry obj, taRECT* rect)
 {
+    JLOG(ll, V(render_mode), "obj", obj.full);
+
     auto quads = obj.qarray.prims + 1;
     u32 param_base = PARAM_BASE & 0xF00000;
 
@@ -277,12 +301,22 @@ void RenderCORE() {
     }
     u32 base = REGION_BASE;
 
+    JLOG(ll, V(REGION_BASE));
+
     RegionArrayEntry entry;
         
     // Parse region array
     do {
         auto step = ReadRegionArrayEntry(base, &entry);
         
+        JLOG2(llrrae, "ReadRegionArrayEntry", V(base), 
+            "control", entry.control.full,
+            "opaque", entry.opaque.full,
+            "opaque_mod", entry.opaque_mod.full,
+            "trans", entry.trans.full,
+            "trans_mod", entry.trans_mod.full,
+            "puncht", entry.puncht.full);
+
         base += step;
 
         taRECT rect;
@@ -294,7 +328,6 @@ void RenderCORE() {
 
         parameter_tag_t bgTag;
 
-        ClearFpuCache();
         // register BGPOLY to fpu
         {
             bgTag = ISP_BACKGND_T.full;
@@ -305,102 +338,85 @@ void RenderCORE() {
         {
             // Clear Param + Z + stencil buffers
             ClearBuffers(bgTag, ISP_BACKGND_D.f, 0);
-        } else {
-            ClearParamStatusBuffer();
         }
 
         // Render OPAQ to TAGS
         if (!entry.opaque.empty)
         {
+            JLOG2(llo, "opaque", V(entry.opaque.ptr_in_words));
             RenderObjectList(RM_OPAQUE, entry.opaque.ptr_in_words * 4, &rect);
-        
-            if (!entry.opaque_mod.empty)
-            {
-                RenderObjectList(RM_MODIFIER, entry.opaque_mod.ptr_in_words * 4, &rect);
-            }
         }
+
         // Render TAGS to ACCUM
-        RenderParamTags<RM_OPAQUE>(rect.left, rect.top);
+        RenderParamTags(RM_OPAQUE, rect.left, rect.top);
 
         // render PT to TAGS
         if (!entry.puncht.empty)
         {
             PeelBuffersPTInitial(FLT_MAX);
-            
-            ClearMoreToDraw();
 
-            // Render to TAGS
-            RenderObjectList(RM_PUNCHTHROUGH_PASS0, entry.puncht.ptr_in_words * 4, &rect);
-
-            // keep reference Z buffer
-            PeelBuffersPT();
-
-            // Render TAGS to ACCUM, making Z holes as-needed
-            RenderParamTags<RM_PUNCHTHROUGH_PASS0>(rect.left, rect.top);
-
-            while (GetMoreToDraw()) {
+            do {
                 ClearMoreToDraw();
 
                 // Render to TAGS
-                RenderObjectList(RM_PUNCHTHROUGH_PASSN, entry.puncht.ptr_in_words * 4, &rect);
+                {
+                    JLOG2(llo, "puncht", V(entry.puncht.ptr_in_words));
+                    RenderObjectList(RM_PUNCHTHROUGH, entry.puncht.ptr_in_words * 4, &rect);
+                }
 
-                if (!GetMoreToDraw())
-                    break;
-                
-                ClearMoreToDraw();
                 // keep reference Z buffer
                 PeelBuffersPT();
 
                 // Render TAGS to ACCUM, making Z holes as-needed
-                RenderParamTags<RM_PUNCHTHROUGH_PASS0>(rect.left, rect.top);
-            }
-            if (!entry.opaque_mod.empty)
-            {
-                RenderObjectList(RM_MODIFIER, entry.opaque_mod.ptr_in_words * 4, &rect);
-                RenderParamTags<RM_PUNCHTHROUGH_MV>(rect.left, rect.top);
-            }
+                RenderParamTags(RM_PUNCHTHROUGH, rect.left, rect.top);
+                
+                // Copy TAGB=TAGA buffers, clear TAGA
+                PeelBuffersPTAfterHoles();
+
+            } while (GetMoreToDraw() != 0);
+        }
+        
+
+        //TODO: Actually render OPAQ modvol affected pixels
+        if (!entry.opaque_mod.empty)
+        {
+            JLOG2(llo, "opaque_mod", V(entry.opaque_mod.ptr_in_words));
+            RenderObjectList(RM_MODIFIER, entry.opaque_mod.ptr_in_words * 4, &rect);
+            RenderParamTags(RM_OP_PT_MV, rect.left, rect.top);
         }
 
         // layer peeling rendering
         if (!entry.trans.empty)
         {
-            if (entry.control.pre_sort) {
-                 // clear the param buffer
-                 ClearParamStatusBuffer();
+            // clear the param buffer
+            ClearParamBuffer(TAG_INVALID);
 
-                 // render to TAGS
-                 {
-                     RenderObjectList(RM_TRANSLUCENT_PRESORT, entry.trans.ptr_in_words * 4, &rect);
-                 }
-
-                // what happens with modvols here?
-                //  if (!entry.trans_mod.empty)
-                //  {
-                //      RenderObjectList(RM_MODIFIER, entry.trans_mod.ptr_in_words * 4, &rect);
-                //  }
-            } else {
-                do
-                {
-                    // prepare for a new pass
-                    ClearMoreToDraw();
+            do
+            {
+                // prepare for a new pass
+                ClearMoreToDraw();
 
+                if (!ISP_FEED_CFG.pre_sort) {
                     // copy depth test to depth reference buffer, clear depth test buffer, clear stencil
                     PeelBuffers(FLT_MAX, 0);
+                }
 
-                    // render to TAGS
-                    {
-                        RenderObjectList(RM_TRANSLUCENT_AUTOSORT, entry.trans.ptr_in_words * 4, &rect);
-                    }
+                // render to TAGS
+                {
+                    JLOG2(llo, "trans", V(entry.trans.ptr_in_words));
+                    RenderObjectList(RM_TRANSLUCENT, entry.trans.ptr_in_words * 4, &rect);
+                }
 
-                    if (!entry.trans_mod.empty)
-                    {
-                        RenderObjectList(RM_MODIFIER, entry.trans_mod.ptr_in_words * 4, &rect);
-                    }
+                if (!entry.trans_mod.empty)
+                {
+                    JLOG2(llo, "trans_mod", V(entry.trans_mod.ptr_in_words));
+                    RenderObjectList(RM_MODIFIER, entry.trans_mod.ptr_in_words * 4, &rect);
+                }
 
-                    // render TAGS to ACCUM
-                    RenderParamTags<RM_TRANSLUCENT_AUTOSORT>(rect.left, rect.top);
-                } while (GetMoreToDraw() != 0);
-            }
+                // render TAGS to ACCUM
+                // also marks TAGS as invalid, but keeps the index for coplanar sorting
+                RenderParamTags(RM_TRANSLUCENT, rect.left, rect.top);
+            } while (GetMoreToDraw() != 0);
         }
 
         // Copy to vram
@@ -453,6 +469,9 @@ void RenderCORE() {
                 }
             }
         }
+
+        // clear the tsp cache
+        ClearFpuEntries();
     } while (!entry.control.last_region);
 }
 

vendor/emu/refsw/refsw_lists.h

@@ -26,23 +26,13 @@ struct DrawParameters
 
 enum RenderMode {
     RM_OPAQUE,
-    RM_PUNCHTHROUGH_PASS0,
-    RM_PUNCHTHROUGH_PASSN,
-    RM_PUNCHTHROUGH_MV, // PT MODVOL 2nd pass
-    RM_TRANSLUCENT_AUTOSORT,
-    RM_TRANSLUCENT_PRESORT,
+    RM_PUNCHTHROUGH,
+    RM_OP_PT_MV, // OP and PT with modvol
+    RM_TRANSLUCENT,
     RM_MODIFIER,
 };
 
-struct TagState {
-    union {
-        struct {
-            bool valid: 1;
-            bool rendered: 1;
-        };
-        uint8_t raw;
-    };
-};
+#define TAG_INVALID (1 << 31)
 
 typedef u32 parameter_tag_t;
 

vendor/emu/refsw/refsw_tile.h

@@ -39,10 +39,6 @@ struct PlaneStepper3
 
         float C = ((v2.x - v1.x) * (v3.y - v1.y) - (v3.x - v1.x) * (v2.y - v1.y));
         
-        if (C == 0) {
-            C = 1; // avoid divide by zero
-        }
-
         ddx = -Aa / C;
         ddy = -Ba / C;
 
@@ -58,16 +54,6 @@ struct PlaneStepper3
     {
         return Ip(x, y) * W;
     }
-
-    float IpU8(float x, float y, float W) const
-    {
-        float rv = Ip(x, y, W);
-
-        if (rv < 0) rv = 0;
-        if (rv > 255) rv = 255;
-
-        return rv;
-    }
 };
 
 /*
@@ -101,8 +87,8 @@ struct IPs3
         }
 
         if (TwoVolumes) {
-            U[1].Setup(rect, v1, v2, v3, v1.u1 * v1.z, v2.u1 * v2.z, v3.u1 * v3.z);
-            V[1].Setup(rect, v1, v2, v3, v1.v1 * v1.z, v2.v1 * v2.z, v3.v1 * v3.z);
+            U[1].Setup(rect, v1, v2, v3, v1.u * v1.z, v2.u1 * v2.z, v3.u1 * v3.z);
+            V[1].Setup(rect, v1, v2, v3, v1.v * v1.z, v2.v1 * v2.z, v3.v1 * v3.z);
             if (params->isp.Gouraud) {
                 for (int i = 0; i < 4; i++)
                     Col[1][i].Setup(rect, v1, v2, v3, v1.col1[i] * v1.z, v2.col1[i] * v2.z, v3.col1[i] * v3.z);
@@ -142,9 +128,10 @@ extern u32  colorBuffer1 [MAX_RENDER_PIXELS];
 extern const char* dump_textures;
 
 void ClearBuffers(u32 paramValue, float depthValue, u32 stencilValue);
-void ClearParamStatusBuffer();
+void ClearParamBuffer(parameter_tag_t paramValue);
 void PeelBuffers(float depthValue, u32 stencilValue);
 void PeelBuffersPT();
+void PeelBuffersPTAfterHoles();
 void PeelBuffersPTInitial(float depthValue);
 void SummarizeStencilOr();
 void SummarizeStencilAnd();
@@ -153,29 +140,31 @@ bool GetMoreToDraw();
 
 // Render to ACCUM from TAG buffer
 // TAG holds references to triangles, ACCUM is the tile framebuffer
-template<RenderMode rm>
-void RenderParamTags(int tileX, int tileY);
+void RenderParamTags(RenderMode rm, int tileX, int tileY);
+void ClearFpuEntries();
 
-inline __attribute__((always_inline)) f32 f16(u16 v)
-{
-    u32 z=v<<16;
-    return *(f32*)&z;
-}
+f32 f16(u16 v);
 
 //decode a vertex in the native pvr format
 void decode_pvr_vertex(DrawParameters* params, pvr32addr_t ptr,Vertex* cv, u32 shadow);
 // decode an object (params + vertexes)
 u32 decode_pvr_vertices(DrawParameters* params, pvr32addr_t base, u32 skip, u32 two_volumes, Vertex* vtx, int count, int offset);
 
-const FpuEntry& GetFpuEntry(taRECT *rect, RenderMode render_mode, ISP_BACKGND_T_type core_tag);
+FpuEntry GetFpuEntry(taRECT *rect, RenderMode render_mode, ISP_BACKGND_T_type core_tag);
 // Lookup/create cached TSP parameters, and call PixelFlush_tsp
-bool PixelFlush_tsp(bool pp_AlphaTest, const FpuEntry* entry, float x, float y, u32 index, float invW, bool InVolume);
+bool PixelFlush_tsp(bool pp_AlphaTest, FpuEntry* entry, float x, float y, u32 index, float invW, bool InVolume);
 // Rasterize a single triangle to ISP (or ISP+TSP for PT)
-
-extern void (*RasterizeTriangle_table[])(DrawParameters* params, parameter_tag_t tag, const Vertex& v1, const Vertex& v2, const Vertex& v3, const Vertex* v4, taRECT* area);
-
+void RasterizeTriangle(RenderMode render_mode, DrawParameters* params, parameter_tag_t tag, const Vertex& v1, const Vertex& v2, const Vertex& v3, const Vertex* v4, taRECT* area);
 u8* GetColorOutputBuffer();
 
+// Implement the full texture/shade pipeline for a pixel
+bool PixelFlush_tsp(
+    bool pp_UseAlpha, bool pp_Texture, bool pp_Offset, bool pp_ColorClamp, u32 pp_FogCtrl, bool pp_IgnoreAlpha, bool pp_ClampU, bool pp_ClampV, bool pp_FlipU, bool pp_FlipV, u32 pp_FilterMode, u32 pp_ShadInstr, bool pp_AlphaTest, u32 pp_SrcSel, u32 pp_DstSel, u32 pp_SrcInst, u32 pp_DstInst,
+    const FpuEntry *entry, float x, float y, float W, bool InVolume, u32 index);
+
+// Depth processing for a pixel -- render_mode 0: OPAQ, 1: PT, 2: TRANS
+void PixelFlush_isp(RenderMode render_mode, u32 depth_mode, u32 ZWriteDis, float x, float y, float invW, u32 index, parameter_tag_t tag);
+
 
 /*
     Main renderer class
@@ -191,5 +180,4 @@ void RenderTriangleArray(RenderMode render_mode, ObjectListEntry obj, taRECT* re
 void RenderQuadArray(RenderMode render_mode, ObjectListEntry obj, taRECT* rect);
 void RenderObjectList(RenderMode render_mode, pvr32addr_t base, taRECT* rect);
 void RenderCORE();
-void Hackpresent();
-void ClearFpuCache();
+void Hackpresent();

vendor/koshle/dc_hle_types.h

@@ -1,27 +1,6 @@
 #pragma once
 
-#if defined(_WIN64) && _WIN64 == 1
-    typedef unsigned long long uint64;  /**< \brief 64-bit unsigned integer */
-    typedef unsigned int uint32;       /**< \brief 32-bit unsigned integer */
-    typedef unsigned short uint16;      /**< \brief 16-bit unsigned integer */
-    typedef unsigned char uint8;        /**< \brief 8-bit unsigned integer */
-    typedef long long int64;            /**< \brief 64-bit signed integer */
-    typedef int int32;                 /**< \brief 32-bit signed integer */
-    typedef short int16;                /**< \brief 16-bit signed integer */
-    typedef char int8;                  /**< \brief 8-bit signed integer */ 
-
-    typedef volatile unsigned long long vuint64;  /**< \brief 64-bit unsigned integer */
-    typedef volatile unsigned int vuint32;       /**< \brief 32-bit unsigned integer */
-    typedef volatile unsigned short vuint16;      /**< \brief 16-bit unsigned integer */
-    typedef volatile unsigned char vuint8;        /**< \brief 8-bit unsigned integer */
-    typedef volatile long long vint64;            /**< \brief 64-bit signed integer */
-    typedef volatile int vint32;                 /**< \brief 32-bit signed integer */
-    typedef volatile short vint16;                /**< \brief 16-bit signed integer */
-    typedef volatile char vint8;                  /**< \brief 8-bit signed integer */ 
-
-typedef uint64 ptr_t;
-#define INT32_IS_INT
-#elif (( (__LONG_MAX__ *2UL+1UL) == 18446744073709551615ULL) && ((__INT_MAX__  *2U +1U) == 4294967295ULL))
+#if ( (__LONG_MAX__ *2UL+1UL) == 18446744073709551615ULL) && ((__INT_MAX__  *2U +1U) == 4294967295ULL)
 typedef unsigned long uint64;  /**< \brief 64-bit unsigned integer */
 typedef unsigned int uint32;       /**< \brief 32-bit unsigned integer */
 typedef unsigned short uint16;      /**< \brief 16-bit unsigned integer */

vendor/koshle/hlekos.cpp

@@ -24,7 +24,7 @@ void * maple_dev_status(maple_device*) {
 maple_device_t * maple_enum_type(int n, uint32 func) {
     return &dev;
 }
-namespace kos {
+
 int sem_wait_timed(semaphore_t *sem, int timeout) {
     auto count = sem->count.load();
 
@@ -54,7 +54,6 @@ int sem_signal(semaphore_t *sem) {
     sem->count++;
     return 0;
 }
-}
 
 void sq_lock(void *dest) {
 

vendor/koshle/kos/sem.h

@@ -32,7 +32,6 @@
 
     \headerfile kos/sem.h
 */
-namespace kos {
 typedef struct semaphore {
     std::atomic<int> initialized;    /**< \brief Are we initialized? */
     std::atomic<int> count;          /**< \brief The semaphore count */
@@ -178,7 +177,5 @@ int sem_signal(semaphore_t *sem);
 */
 int sem_count(semaphore_t *sem);
 
-}
-using namespace kos;
 
 #endif  /* __KOS_SEM_H */

vendor/koshle/pvr_internal.h

@@ -233,7 +233,7 @@ typedef struct {
 
     /* Wait-ready semaphore: this will be signaled whenever the pvr_wait_ready()
        call should be ready to return. */
-    kos::semaphore_t ready_sem;
+    semaphore_t ready_sem;
 
     // Handle for the vblank interrupt
     int     vbl_handle;

vendor/librw/src/dc/rwdc.cpp

@@ -1327,9 +1327,9 @@ static uint32 cullModePvr;
 
 static inline unsigned pvrCullMode(uint32_t cullMode) {
 	switch(cullMode) {
-		case CULLNONE: return PVR_CULLING_SMALL;
-		case CULLBACK: return PVR_CULLING_CW;
-		default:       return PVR_CULLING_CCW;
+		case CULLNONE: return PVR_CULLING_NONE;  // No descartar nada
+		case CULLBACK: return PVR_CULLING_NONE;  // No descartar nada
+		default:       return PVR_CULLING_NONE;  // No descartar nada
 	}
 }
 
@@ -4527,10 +4527,6 @@ imageFindRasterFormat(Image *img, int32 type,
 
 #if defined(_WIN32) || defined(_WIN64)
 #include <windows.h> // For QueryPerformanceCounter and GetCurrentThreadId
-#ifdef _WIN64
-#include <profileapi.h>
-#include <processthreadsapi.h>
-#endif
 #elif defined(__APPLE__)
 #include <mach/mach_time.h> // For mach_absolute_time
 #include <pthread.h>
@@ -4961,17 +4957,17 @@ driverOpen(void *o, int32, int32)
 	#endif
 
 	if (pvr_params.fsaa_enabled) {
-		pvr_params.vertex_buf_size = (1024 + 768) * 1024;
-		pvr_params.opb_overflow_count = 4; // 307200 bytes
-	} else {
-		pvr_params.vertex_buf_size = (1024 + 1024) * 1024;
-		pvr_params.opb_overflow_count = 7; // 268800 bytes
-	}
+	pvr_params.vertex_buf_size = (1024 + 768) * 1024;  // ≈ 1.75 MB
+	pvr_params.opb_overflow_count = 4; // 307200 bytes
+} else {
+	pvr_params.vertex_buf_size = (int)(2.5f * 1024 * 1024);  // 2.5 MB
+	pvr_params.opb_overflow_count = 7; // 268800 bytes
+}
 
-	if (videoModes[VIDEO_MODE].depth == 24) {
-		pvr_params.vertex_buf_size -= 128 * 1024;
-		pvr_params.opb_overflow_count -= pvr_params.fsaa_enabled ? 1 : 2;
-	}
+if (videoModes[VIDEO_MODE].depth == 24) {
+	pvr_params.vertex_buf_size -= 128 * 1024;
+	pvr_params.opb_overflow_count -= pvr_params.fsaa_enabled ? 1 : 2;
+}
 
 	#if !defined(DC_SIM)
 	vid_set_mode(DM_640x480, videoModes[VIDEO_MODE].depth == 24 ? PM_RGB888P : PM_RGB565);