X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=plugins%2Fgpu_unai%2Fgpulib_if.cpp;h=2dedbf83d48aff46cb8b6950fc6420fb40a5ec41;hb=HEAD;hp=191108b83c691948d53ba11c2dd4c99256cc8604;hpb=90ac6fed274c1d573a971c66f8a1338e8918f066;p=pcsx_rearmed.git diff --git a/plugins/gpu_unai/gpulib_if.cpp b/plugins/gpu_unai/gpulib_if.cpp index 191108b8..4d096344 100644 --- a/plugins/gpu_unai/gpulib_if.cpp +++ b/plugins/gpu_unai/gpulib_if.cpp @@ -25,6 +25,7 @@ #include #include #include "../gpulib/gpu.h" +#include "old/if.h" #ifdef THREAD_RENDERING #include "../gpulib/gpulib_thread_if.h" @@ -68,6 +69,12 @@ ///////////////////////////////////////////////////////////////////////////// +#ifndef GPU_UNAI_NO_OLD +#define IS_OLD_RENDERER() gpu_unai.config.old_renderer +#else +#define IS_OLD_RENDERER() false +#endif + #define DOWNSCALE_VRAM_SIZE (1024 * 512 * 2 * 2 + 4096) INLINE void scale_640_to_320(le16_t *dest, const le16_t *src, bool isRGB24) { @@ -154,7 +161,7 @@ static uint16_t *get_downscale_buffer(int *x, int *y, int *w, int *h, int *vram_ lines = *h; // Ensure start at a non-skipped line - while (*y & gpu_unai.ilace_mask) ++*y; + while (*y & gpu_unai.inn.ilace_mask) ++*y; } unsigned int fb_offset_src = (*y * dstride + *x) & fb_mask; @@ -201,8 +208,9 @@ static void map_downscale_buffer(void) gpu_unai.downscale_vram = (le16_t*)gpu.mmap(DOWNSCALE_VRAM_SIZE); - if (gpu_unai.downscale_vram == NULL) { + if (gpu_unai.downscale_vram == NULL || gpu_unai.downscale_vram == (le16_t *)(intptr_t)-1) { fprintf(stderr, "failed to map downscale buffer\n"); + gpu_unai.downscale_vram = NULL; gpu.get_downscale_buffer = NULL; } else { @@ -235,8 +243,8 @@ int renderer_init(void) //senquack - new vars must be updated whenever texture window is changed: // (used for polygon-drawing in gpu_inner.h, gpu_raster_polygon.h) const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4 - gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1); - gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1); + gpu_unai.inn.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1); + gpu_unai.inn.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1); // Configuration options gpu_unai.config = gpu_unai_config_ext; @@ -244,9 +252,9 @@ int renderer_init(void) // sprite-span functions, perhaps unnecessarily. No Abe Oddysey hack was // present in latest PCSX4ALL sources we were using. //gpu_unai.config.enableAbbeyHack = gpu_unai_config_ext.abe_hack; - gpu_unai.ilace_mask = gpu_unai.config.ilace_force; + gpu_unai.inn.ilace_mask = gpu_unai.config.ilace_force; -#ifdef GPU_UNAI_USE_INT_DIV_MULTINV +#if defined(GPU_UNAI_USE_INT_DIV_MULTINV) || (!defined(GPU_UNAI_NO_OLD) && !defined(GPU_UNAI_USE_FLOATMATH)) // s_invTable for(int i=1;i<=(1<>(32-11); - gpu_unai.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11); + gpu_unai.DrawingOffset[0] = GPU_EXPANDSIGN(cmd_word); + gpu_unai.DrawingOffset[1] = GPU_EXPANDSIGN(cmd_word >> 11); } break; case 6: { @@ -391,26 +375,53 @@ static void gpuGP0Cmd_0xEx(gpu_unai_t &gpu_unai, u32 cmd_word) #endif #include "../gpulib/gpu_timing.h" + +// Strip lower 3 bits of each color and determine if lighting should be used: +static inline bool need_lighting(u32 rgb_raw) +{ + return (rgb_raw & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080); +} + +static inline void textured_sprite(int &cpu_cycles_sum, int &cpu_cycles) +{ + u32 PRIM = le32_to_u32(gpu_unai.PacketBuffer.U4[0]) >> 24; + gpuSetCLUT(le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); + u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1); + s32 w = 0, h = 0; + + //senquack - Only color 808080h-878787h allows skipping lighting calculation: + // This fixes Silent Hill running animation on loading screens: + // (On PSX, color values 0x00-0x7F darken the source texture's color, + // 0x81-FF lighten textures (ultimately clamped to 0x1F), + // 0x80 leaves source texture color unchanged, HOWEVER, + // gpu_unai uses a simple lighting LUT whereby only the upper + // 5 bits of an 8-bit color are used, so 0x80-0x87 all behave as + // 0x80. + // + // NOTE: I've changed all textured sprite draw commands here and + // elsewhere to use proper behavior, but left poly commands + // alone, I don't want to slow rendering down too much. (TODO) + if (need_lighting(le32_raw(gpu_unai.PacketBuffer.U4[0]))) + driver_idx |= Lighting; + PS driver = gpuSpriteDrivers[driver_idx]; + PtrUnion packet = { .ptr = (void*)&gpu_unai.PacketBuffer }; + gpuDrawS(packet, driver, &w, &h); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_sprite(w, h)); +} + extern const unsigned char cmd_lengths[256]; -int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) +int do_cmd_list(u32 *list_, int list_len, + int *cycles_sum_out, int *cycles_last, int *last_cmd) { + int cpu_cycles_sum = 0, cpu_cycles = *cycles_last; u32 cmd = 0, len, i; - le32_t *list = (le32_t *)_list; + le32_t *list = (le32_t *)list_; le32_t *list_start = list; le32_t *list_end = list + list_len; - u32 cpu_cycles = 0; - //TODO: set ilace_mask when resolution changes instead of every time, - // eliminate #ifdef below. - gpu_unai.ilace_mask = gpu_unai.config.ilace_force; - -#ifdef HAVE_PRE_ARMV7 /* XXX */ - gpu_unai.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE); -#endif - if (gpu_unai.config.scale_hires) { - gpu_unai.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE); - } + if (IS_OLD_RENDERER()) + return oldunai_do_cmd_list(list_, list_len, cycles_sum_out, cycles_last, last_cmd); for (; list < list_end; list += 1 + len) { @@ -432,8 +443,8 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) { case 0x02: gpuClearImage(packet); - cpu_cycles += gput_fill(le16_to_s16(packet.U2[4]) & 0x3ff, - le16_to_s16(packet.U2[5]) & 0x1ff); + gput_sum(cpu_cycles_sum, cpu_cycles, + gput_fill(le16_to_s16(packet.U2[4]) & 0x3ff, le16_to_s16(packet.U2[5]) & 0x1ff)); break; case 0x20: @@ -441,12 +452,12 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x22: case 0x23: { // Monochrome 3-pt poly PP driver = gpuPolySpanDrivers[ - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Blending_Mode | gpu_unai.Masking | Blending | gpu_unai.PixelMSB ]; gpuDrawPolyF(packet, driver, false); - cpu_cycles += gput_poly_base(); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_poly_base()); } break; case 0x24: @@ -457,7 +468,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) gpuSetTexture(le32_to_u32(gpu_unai.PacketBuffer.U4[4]) >> 16); u32 driver_idx = - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Dithering | Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | gpu_unai.PixelMSB; @@ -471,7 +482,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) PP driver = gpuPolySpanDrivers[driver_idx]; gpuDrawPolyFT(packet, driver, false); - cpu_cycles += gput_poly_base_t(); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_poly_base_t()); } break; case 0x28: @@ -479,23 +490,35 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x2A: case 0x2B: { // Monochrome 4-pt poly PP driver = gpuPolySpanDrivers[ - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Blending_Mode | gpu_unai.Masking | Blending | gpu_unai.PixelMSB ]; gpuDrawPolyF(packet, driver, true); // is_quad = true - cpu_cycles += gput_quad_base(); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_quad_base()); } break; case 0x2C: case 0x2D: case 0x2E: case 0x2F: { // Textured 4-pt poly - gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); + u32 simplified_count; gpuSetTexture(le32_to_u32(gpu_unai.PacketBuffer.U4[4]) >> 16); + if ((simplified_count = prim_try_simplify_quad_t(gpu_unai.PacketBuffer.U4, + gpu_unai.PacketBuffer.U4))) + { + for (i = 0;; ) { + textured_sprite(cpu_cycles_sum, cpu_cycles); + if (++i >= simplified_count) + break; + memcpy(&gpu_unai.PacketBuffer.U4[0], &gpu_unai.PacketBuffer.U4[i * 4], 16); + } + break; + } + gpuSetCLUT(le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); u32 driver_idx = - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Dithering | Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | gpu_unai.PixelMSB; @@ -509,7 +532,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) PP driver = gpuPolySpanDrivers[driver_idx]; gpuDrawPolyFT(packet, driver, true); // is_quad = true - cpu_cycles += gput_quad_base_t(); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_quad_base_t()); } break; case 0x30: @@ -520,14 +543,23 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) // this is an untextured poly, so CF_LIGHT (texture blend) // shouldn't apply. Until the original array of template // instantiation ptrs is fixed, we're stuck with this. (TODO) + u8 gouraud = 129; + u32 xor_ = 0, rgb0 = le32_raw(gpu_unai.PacketBuffer.U4[0]); + for (i = 1; i < 3; i++) + xor_ |= rgb0 ^ le32_raw(gpu_unai.PacketBuffer.U4[i * 2]); + if ((xor_ & HTOLE32(0xf8f8f8)) == 0) + gouraud = 0; PP driver = gpuPolySpanDrivers[ - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Dithering | Blending_Mode | - gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB + gpu_unai.Masking | Blending | gouraud | gpu_unai.PixelMSB ]; - gpuDrawPolyG(packet, driver, false); - cpu_cycles += gput_poly_base_g(); + if (gouraud) + gpuDrawPolyG(packet, driver, false); + else + gpuDrawPolyF(packet, driver, false, POLYTYPE_G); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_poly_base_g()); } break; case 0x34: @@ -536,14 +568,29 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x37: { // Gouraud-shaded, textured 3-pt poly gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16); + u8 lighting = Lighting; + u8 gouraud = lighting ? (1<<7) : 0; + if (lighting) { + u32 xor_ = 0, rgb0 = le32_raw(gpu_unai.PacketBuffer.U4[0]); + for (i = 1; i < 3; i++) + xor_ |= rgb0 ^ le32_raw(gpu_unai.PacketBuffer.U4[i * 3]); + if ((xor_ & HTOLE32(0xf8f8f8)) == 0) { + gouraud = 0; + if (!need_lighting(rgb0)) + lighting = 0; + } + } PP driver = gpuPolySpanDrivers[ - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Dithering | Blending_Mode | gpu_unai.TEXT_MODE | - gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB + gpu_unai.Masking | Blending | gouraud | lighting | gpu_unai.PixelMSB ]; - gpuDrawPolyGT(packet, driver, false); - cpu_cycles += gput_poly_base_gt(); + if (gouraud) + gpuDrawPolyGT(packet, driver, false); // is_quad = true + else + gpuDrawPolyFT(packet, driver, false, POLYTYPE_GT); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_poly_base_gt()); } break; case 0x38: @@ -551,30 +598,66 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x3A: case 0x3B: { // Gouraud-shaded 4-pt poly // See notes regarding '129' for 0x30..0x33 further above -senquack + u8 gouraud = 129; + u32 xor_ = 0, rgb0 = le32_raw(gpu_unai.PacketBuffer.U4[0]); + for (i = 1; i < 4; i++) + xor_ |= rgb0 ^ le32_raw(gpu_unai.PacketBuffer.U4[i * 2]); + if ((xor_ & HTOLE32(0xf8f8f8)) == 0) + gouraud = 0; PP driver = gpuPolySpanDrivers[ - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Dithering | Blending_Mode | - gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB + gpu_unai.Masking | Blending | gouraud | gpu_unai.PixelMSB ]; - gpuDrawPolyG(packet, driver, true); // is_quad = true - cpu_cycles += gput_quad_base_g(); + if (gouraud) + gpuDrawPolyG(packet, driver, true); // is_quad = true + else + gpuDrawPolyF(packet, driver, true, POLYTYPE_G); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_quad_base_g()); } break; case 0x3C: case 0x3D: case 0x3E: case 0x3F: { // Gouraud-shaded, textured 4-pt poly - gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); - gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16); + u32 simplified_count; + gpuSetTexture(le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16); + if ((simplified_count = prim_try_simplify_quad_gt(gpu_unai.PacketBuffer.U4, + gpu_unai.PacketBuffer.U4))) + { + for (i = 0;; ) { + textured_sprite(cpu_cycles_sum, cpu_cycles); + if (++i >= simplified_count) + break; + memcpy(&gpu_unai.PacketBuffer.U4[0], &gpu_unai.PacketBuffer.U4[i * 4], 16); + } + break; + } + gpuSetCLUT(le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); + u8 lighting = Lighting; + u8 gouraud = lighting ? (1<<7) : 0; + if (lighting) { + u32 xor_ = 0, rgb0 = le32_raw(gpu_unai.PacketBuffer.U4[0]); + for (i = 1; i < 4; i++) + xor_ |= rgb0 ^ le32_raw(gpu_unai.PacketBuffer.U4[i * 3]); + if ((xor_ & HTOLE32(0xf8f8f8)) == 0) { + gouraud = 0; + if (!need_lighting(rgb0)) + lighting = 0; + } + } PP driver = gpuPolySpanDrivers[ - (gpu_unai.blit_mask?1024:0) | + //(gpu_unai.blit_mask?1024:0) | Dithering | Blending_Mode | gpu_unai.TEXT_MODE | - gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB + gpu_unai.Masking | Blending | gouraud | lighting | gpu_unai.PixelMSB ]; - gpuDrawPolyGT(packet, driver, true); // is_quad = true - cpu_cycles += gput_quad_base_gt(); + if (gouraud) + gpuDrawPolyGT(packet, driver, true); // is_quad = true + else + gpuDrawPolyFT(packet, driver, true, POLYTYPE_GT); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_quad_base_gt()); } break; case 0x40: @@ -585,7 +668,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1; PSD driver = gpuPixelSpanDrivers[driver_idx]; gpuDrawLineF(packet, driver); - cpu_cycles += gput_line(0); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_line(0)); } break; case 0x48 ... 0x4F: { // Monochrome line strip @@ -602,7 +685,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[2]; gpu_unai.PacketBuffer.U4[2] = *list_position++; gpuDrawLineF(packet, driver); - cpu_cycles += gput_line(0); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_line(0)); num_vertexes++; if(list_position >= list_end) { @@ -626,7 +709,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) driver_idx |= (1 << 5); PSD driver = gpuPixelSpanDrivers[driver_idx]; gpuDrawLineG(packet, driver); - cpu_cycles += gput_line(0); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_line(0)); } break; case 0x58 ... 0x5F: { // Gouraud-shaded line strip @@ -647,7 +730,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) gpu_unai.PacketBuffer.U4[2] = *list_position++; gpu_unai.PacketBuffer.U4[3] = *list_position++; gpuDrawLineG(packet, driver); - cpu_cycles += gput_line(0); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_line(0)); num_vertexes++; if(list_position >= list_end) { @@ -665,49 +748,28 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x61: case 0x62: case 0x63: { // Monochrome rectangle (variable size) - PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; - gpuDrawT(packet, driver); - cpu_cycles += gput_sprite(le16_to_u16(packet.U2[4]) & 0x3ff, - le16_to_u16(packet.U2[5]) & 0x1ff); + PT driver = gpuTileDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; + s32 w = 0, h = 0; + gpuDrawT(packet, driver, &w, &h); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_sprite(w, h)); } break; case 0x64: case 0x65: case 0x66: - case 0x67: { // Textured rectangle (variable size) - gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); - u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1); - - //senquack - Only color 808080h-878787h allows skipping lighting calculation: - // This fixes Silent Hill running animation on loading screens: - // (On PSX, color values 0x00-0x7F darken the source texture's color, - // 0x81-FF lighten textures (ultimately clamped to 0x1F), - // 0x80 leaves source texture color unchanged, HOWEVER, - // gpu_unai uses a simple lighting LUT whereby only the upper - // 5 bits of an 8-bit color are used, so 0x80-0x87 all behave as - // 0x80. - // - // NOTE: I've changed all textured sprite draw commands here and - // elsewhere to use proper behavior, but left poly commands - // alone, I don't want to slow rendering down too much. (TODO) - //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)) - // Strip lower 3 bits of each color and determine if lighting should be used: - if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080)) - driver_idx |= Lighting; - PS driver = gpuSpriteSpanDrivers[driver_idx]; - gpuDrawS(packet, driver); - cpu_cycles += gput_sprite(le16_to_u16(packet.U2[6]) & 0x3ff, - le16_to_u16(packet.U2[7]) & 0x1ff); - } break; + case 0x67: // Textured rectangle (variable size) + textured_sprite(cpu_cycles_sum, cpu_cycles); + break; case 0x68: case 0x69: case 0x6A: case 0x6B: { // Monochrome rectangle (1x1 dot) gpu_unai.PacketBuffer.U4[2] = u32_to_le32(0x00010001); - PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; - gpuDrawT(packet, driver); - cpu_cycles += gput_sprite(1, 1); + PT driver = gpuTileDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; + s32 w = 0, h = 0; + gpuDrawT(packet, driver, &w, &h); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_sprite(1, 1)); } break; case 0x70: @@ -715,9 +777,10 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x72: case 0x73: { // Monochrome rectangle (8x8) gpu_unai.PacketBuffer.U4[2] = u32_to_le32(0x00080008); - PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; - gpuDrawT(packet, driver); - cpu_cycles += gput_sprite(8, 8); + PT driver = gpuTileDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; + s32 w = 0, h = 0; + gpuDrawT(packet, driver, &w, &h); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_sprite(w, h)); } break; case 0x74: @@ -725,17 +788,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x76: case 0x77: { // Textured rectangle (8x8) gpu_unai.PacketBuffer.U4[3] = u32_to_le32(0x00080008); - gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); - u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1); - - //senquack - Only color 808080h-878787h allows skipping lighting calculation: - //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)) - // Strip lower 3 bits of each color and determine if lighting should be used: - if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080)) - driver_idx |= Lighting; - PS driver = gpuSpriteSpanDrivers[driver_idx]; - gpuDrawS(packet, driver); - cpu_cycles += gput_sprite(8, 8); + textured_sprite(cpu_cycles_sum, cpu_cycles); } break; case 0x78: @@ -743,36 +796,18 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0x7A: case 0x7B: { // Monochrome rectangle (16x16) gpu_unai.PacketBuffer.U4[2] = u32_to_le32(0x00100010); - PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; - gpuDrawT(packet, driver); - cpu_cycles += gput_sprite(16, 16); + PT driver = gpuTileDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1]; + s32 w = 0, h = 0; + gpuDrawT(packet, driver, &w, &h); + gput_sum(cpu_cycles_sum, cpu_cycles, gput_sprite(w, h)); } break; case 0x7C: case 0x7D: -#ifdef __arm__ - if ((gpu_unai.GPU_GP1 & 0x180) == 0 && (gpu_unai.Masking | gpu_unai.PixelMSB) == 0) - { - gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); - gpuDrawS16(packet); - cpu_cycles += gput_sprite(16, 16); - break; - } - // fallthrough -#endif case 0x7E: case 0x7F: { // Textured rectangle (16x16) gpu_unai.PacketBuffer.U4[3] = u32_to_le32(0x00100010); - gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16); - u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1); - //senquack - Only color 808080h-878787h allows skipping lighting calculation: - //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)) - // Strip lower 3 bits of each color and determine if lighting should be used: - if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080)) - driver_idx |= Lighting; - PS driver = gpuSpriteSpanDrivers[driver_idx]; - gpuDrawS(packet, driver); - cpu_cycles += gput_sprite(16, 16); + textured_sprite(cpu_cycles_sum, cpu_cycles); } break; #ifdef TEST @@ -792,6 +827,7 @@ int do_cmd_list(u32 *_list, int list_len, int *cpu_cycles_out, int *last_cmd) case 0xC0: break; #else + case 0x1F: // irq? case 0x80 ... 0x9F: // vid -> vid case 0xA0 ... 0xBF: // sys -> vid case 0xC0 ... 0xDF: // vid -> sys @@ -808,15 +844,20 @@ breakloop: gpu.ex_regs[1] &= ~0x1ff; gpu.ex_regs[1] |= gpu_unai.GPU_GP1 & 0x1ff; - *cpu_cycles_out += cpu_cycles; + *cycles_sum_out += cpu_cycles_sum; + *cycles_last = cpu_cycles; *last_cmd = cmd; return list - list_start; } void renderer_sync_ecmds(u32 *ecmds) { - int dummy; - do_cmd_list(&ecmds[1], 6, &dummy, &dummy); + if (!IS_OLD_RENDERER()) { + int dummy; + do_cmd_list(&ecmds[1], 6, &dummy, &dummy, &dummy); + } + else + oldunai_renderer_sync_ecmds(ecmds); } void renderer_update_caches(int x, int y, int w, int h, int state_changed) @@ -829,6 +870,7 @@ void renderer_flush_queues(void) void renderer_set_interlace(int enable, int is_odd) { + renderer_notify_res_change(); } #include "../../frontend/plugin_lib.h" @@ -836,13 +878,14 @@ void renderer_set_interlace(int enable, int is_odd) void renderer_set_config(const struct rearmed_cbs *cbs) { gpu_unai.vram = (le16_t *)gpu.vram; + gpu_unai.config.old_renderer = cbs->gpu_unai.old_renderer; gpu_unai.config.ilace_force = cbs->gpu_unai.ilace_force; - gpu_unai.config.pixel_skip = cbs->gpu_unai.pixel_skip; gpu_unai.config.lighting = cbs->gpu_unai.lighting; gpu_unai.config.fast_lighting = cbs->gpu_unai.fast_lighting; gpu_unai.config.blending = cbs->gpu_unai.blending; - gpu_unai.config.dithering = cbs->gpu_unai.dithering; gpu_unai.config.scale_hires = cbs->gpu_unai.scale_hires; + gpu_unai.config.dithering = cbs->dithering != 0; + gpu_unai.config.force_dithering = cbs->dithering >> 1; gpu.state.downscale_enable = gpu_unai.config.scale_hires; if (gpu_unai.config.scale_hires) { @@ -850,6 +893,7 @@ void renderer_set_config(const struct rearmed_cbs *cbs) } else { unmap_downscale_buffer(); } + oldunai_renderer_set_config(cbs); } void renderer_sync(void)