ifeq "$(ARCH)" "arm"
OBJS += plugins/gpu_unai/gpu_arm.o
endif
-plugins/gpu_unai/gpulib_if.o: CFLAGS += -DREARMED -O3
+plugins/gpu_unai/gpulib_if.o: CFLAGS += -DREARMED -DUSE_GPULIB=1 -O3
CC_LINK = $(CXX)
endif
CFLAGS += -I../../include
#CFLAGS += -DINLINE="static __inline__"
#CFLAGS += -Dasm="__asm__ __volatile__"
-#CFLAGS += -DUSE_GPULIB=1
+CFLAGS += -DUSE_GPULIB=1
include ../../config.mak
#include "plugins.h"
#include "psxcommon.h"
//#include "port.h"
-#include "gpu_senquack.h"
+#include "gpu_unai.h"
#define VIDEO_WIDTH 320
#define TPS 1000000
#endif
-#define IS_PAL (gpu_senquack.GPU_GP1&(0x08<<17))
+#define IS_PAL (gpu_unai.GPU_GP1&(0x08<<17))
//senquack - Original 512KB of guard space seems not to be enough, as Xenogears
// accesses outside this range and crashes in town intro fight sequence.
///////////////////////////////////////////////////////////////////////////////
static void gpuReset(void)
{
- memset((void*)&gpu_senquack, 0, sizeof(gpu_senquack));
- gpu_senquack.vram = (u16*)GPU_FrameBuffer + (4096/2); //4kb guard room in front
- gpu_senquack.GPU_GP1 = 0x14802000;
- gpu_senquack.DrawingArea[2] = 256;
- gpu_senquack.DrawingArea[3] = 240;
- gpu_senquack.DisplayArea[2] = 256;
- gpu_senquack.DisplayArea[3] = 240;
- gpu_senquack.DisplayArea[5] = 240;
- gpu_senquack.TextureWindow[0] = 0;
- gpu_senquack.TextureWindow[1] = 0;
- gpu_senquack.TextureWindow[2] = 255;
- gpu_senquack.TextureWindow[3] = 255;
+ memset((void*)&gpu_unai, 0, sizeof(gpu_unai));
+ gpu_unai.vram = (u16*)GPU_FrameBuffer + (4096/2); //4kb guard room in front
+ gpu_unai.GPU_GP1 = 0x14802000;
+ gpu_unai.DrawingArea[2] = 256;
+ gpu_unai.DrawingArea[3] = 240;
+ gpu_unai.DisplayArea[2] = 256;
+ gpu_unai.DisplayArea[3] = 240;
+ gpu_unai.DisplayArea[5] = 240;
+ gpu_unai.TextureWindow[0] = 0;
+ gpu_unai.TextureWindow[1] = 0;
+ gpu_unai.TextureWindow[2] = 255;
+ gpu_unai.TextureWindow[3] = 255;
//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_senquack.u_msk = (((u32)gpu_senquack.TextureWindow[2]) << fb) | ((1 << fb) - 1);
- gpu_senquack.v_msk = (((u32)gpu_senquack.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+ 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);
// Configuration options
- gpu_senquack.config = gpu_senquack_config_ext;
- gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
- gpu_senquack.frameskip.skipCount = gpu_senquack.config.frameskip_count;
+ gpu_unai.config = gpu_unai_config_ext;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
+ gpu_unai.frameskip.skipCount = gpu_unai.config.frameskip_count;
SetupLightLUT();
SetupDitheringConstants();
}
#endif
- gpu_senquack.fb_dirty = true;
- gpu_senquack.dma.last_dma = NULL;
+ gpu_unai.fb_dirty = true;
+ gpu_unai.dma.last_dma = NULL;
return (0);
}
if (bWrite)
{
- p2->ulStatus = gpu_senquack.GPU_GP1;
+ p2->ulStatus = gpu_unai.GPU_GP1;
memset(p2->ulControl, 0, sizeof(p2->ulControl));
// save resolution and registers for P.E.Op.S. compatibility
- p2->ulControl[3] = (3 << 24) | ((gpu_senquack.GPU_GP1 >> 23) & 1);
- p2->ulControl[4] = (4 << 24) | ((gpu_senquack.GPU_GP1 >> 29) & 3);
- p2->ulControl[5] = (5 << 24) | (gpu_senquack.DisplayArea[0] | (gpu_senquack.DisplayArea[1] << 10));
+ p2->ulControl[3] = (3 << 24) | ((gpu_unai.GPU_GP1 >> 23) & 1);
+ p2->ulControl[4] = (4 << 24) | ((gpu_unai.GPU_GP1 >> 29) & 3);
+ p2->ulControl[5] = (5 << 24) | (gpu_unai.DisplayArea[0] | (gpu_unai.DisplayArea[1] << 10));
p2->ulControl[6] = (6 << 24) | (2560 << 12);
- p2->ulControl[7] = (7 << 24) | (gpu_senquack.DisplayArea[4] | (gpu_senquack.DisplayArea[5] << 10));
- p2->ulControl[8] = (8 << 24) | ((gpu_senquack.GPU_GP1 >> 17) & 0x3f) | ((gpu_senquack.GPU_GP1 >> 10) & 0x40);
- memcpy((void*)p2->psxVRam, (void*)gpu_senquack.vram, FRAME_BUFFER_SIZE);
+ p2->ulControl[7] = (7 << 24) | (gpu_unai.DisplayArea[4] | (gpu_unai.DisplayArea[5] << 10));
+ p2->ulControl[8] = (8 << 24) | ((gpu_unai.GPU_GP1 >> 17) & 0x3f) | ((gpu_unai.GPU_GP1 >> 10) & 0x40);
+ memcpy((void*)p2->psxVRam, (void*)gpu_unai.vram, FRAME_BUFFER_SIZE);
return (1);
}
else
{
extern void GPU_writeStatus(u32 data);
- gpu_senquack.GPU_GP1 = p2->ulStatus;
- memcpy((void*)gpu_senquack.vram, (void*)p2->psxVRam, FRAME_BUFFER_SIZE);
+ gpu_unai.GPU_GP1 = p2->ulStatus;
+ memcpy((void*)gpu_unai.vram, (void*)p2->psxVRam, FRAME_BUFFER_SIZE);
GPU_writeStatus((5 << 24) | p2->ulControl[5]);
GPU_writeStatus((7 << 24) | p2->ulControl[7]);
GPU_writeStatus((8 << 24) | p2->ulControl[8]);
- gpuSetTexture(gpu_senquack.GPU_GP1);
+ gpuSetTexture(gpu_unai.GPU_GP1);
return (1);
}
return (0);
///////////////////////////////////////////////////////////////////////////////
INLINE void gpuSendPacket()
{
- gpuSendPacketFunction(gpu_senquack.PacketBuffer.U4[0]>>24);
+ gpuSendPacketFunction(gpu_unai.PacketBuffer.U4[0]>>24);
}
///////////////////////////////////////////////////////////////////////////////
INLINE void gpuCheckPacket(u32 uData)
{
- if (gpu_senquack.PacketCount)
+ if (gpu_unai.PacketCount)
{
- gpu_senquack.PacketBuffer.U4[gpu_senquack.PacketIndex++] = uData;
- --gpu_senquack.PacketCount;
+ gpu_unai.PacketBuffer.U4[gpu_unai.PacketIndex++] = uData;
+ --gpu_unai.PacketCount;
}
else
{
- gpu_senquack.PacketBuffer.U4[0] = uData;
- gpu_senquack.PacketCount = PacketSize[uData >> 24];
- gpu_senquack.PacketIndex = 1;
+ gpu_unai.PacketBuffer.U4[0] = uData;
+ gpu_unai.PacketCount = PacketSize[uData >> 24];
+ gpu_unai.PacketIndex = 1;
}
- if (!gpu_senquack.PacketCount) gpuSendPacket();
+ if (!gpu_unai.PacketCount) gpuSendPacket();
}
///////////////////////////////////////////////////////////////////////////////
fprintf(stdout,"GPU_writeDataMem(%d)\n",dmaCount);
#endif
u32 data;
- const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
- gpu_senquack.GPU_GP1 &= ~0x14000000;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
+ gpu_unai.GPU_GP1 &= ~0x14000000;
while (dmaCount)
{
- if (gpu_senquack.dma.FrameToWrite)
+ if (gpu_unai.dma.FrameToWrite)
{
while (dmaCount)
{
dmaCount--;
data = *dmaAddress++;
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
- gpu_senquack.dma.pvram[gpu_senquack.dma.px] = data;
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px] = data;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToWrite = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
- gpu_senquack.fb_dirty = true;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
break;
}
}
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
- gpu_senquack.dma.pvram[gpu_senquack.dma.px] = data>>16;
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px] = data>>16;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToWrite = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
- gpu_senquack.fb_dirty = true;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
break;
}
}
}
}
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 | 0x14000000) & ~0x60000000;
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 | 0x14000000) & ~0x60000000;
}
long GPU_dmaChain(u32 *rambase, u32 start_addr)
u32 len, count;
long dma_words = 0;
- if (gpu_senquack.dma.last_dma) *gpu_senquack.dma.last_dma |= 0x800000;
+ if (gpu_unai.dma.last_dma) *gpu_unai.dma.last_dma |= 0x800000;
- gpu_senquack.GPU_GP1 &= ~0x14000000;
+ gpu_unai.GPU_GP1 &= ~0x14000000;
addr = start_addr & 0xffffff;
for (count = 0; addr != 0xffffff; count++)
list[0] &= ~0x800000;
}
- if (gpu_senquack.dma.last_dma) *gpu_senquack.dma.last_dma &= ~0x800000;
- gpu_senquack.dma.last_dma = rambase + (start_addr & 0x1fffff) / 4;
+ if (gpu_unai.dma.last_dma) *gpu_unai.dma.last_dma &= ~0x800000;
+ gpu_unai.dma.last_dma = rambase + (start_addr & 0x1fffff) / 4;
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 | 0x14000000) & ~0x60000000;
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 | 0x14000000) & ~0x60000000;
return dma_words;
}
///////////////////////////////////////////////////////////////////////////////
void GPU_writeData(u32 data)
{
- const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"GPU_writeData()\n");
#endif
- gpu_senquack.GPU_GP1 &= ~0x14000000;
+ gpu_unai.GPU_GP1 &= ~0x14000000;
- if (gpu_senquack.dma.FrameToWrite)
+ if (gpu_unai.dma.FrameToWrite)
{
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
- gpu_senquack.dma.pvram[gpu_senquack.dma.px]=(u16)data;
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px]=(u16)data;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToWrite = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
- gpu_senquack.fb_dirty = true;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
}
}
- if (gpu_senquack.dma.FrameToWrite)
+ if (gpu_unai.dma.FrameToWrite)
{
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
- gpu_senquack.dma.pvram[gpu_senquack.dma.px]=data>>16;
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px]=data>>16;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToWrite = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
- gpu_senquack.fb_dirty = true;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
}
}
}
{
gpuCheckPacket(data);
}
- gpu_senquack.GPU_GP1 |= 0x14000000;
+ gpu_unai.GPU_GP1 |= 0x14000000;
}
///////////////////////////////////////////////////////////////////////////////
void GPU_readDataMem(u32* dmaAddress, int dmaCount)
{
- const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"GPU_readDataMem(%d)\n",dmaCount);
#endif
- if(!gpu_senquack.dma.FrameToRead) return;
+ if(!gpu_unai.dma.FrameToRead) return;
- gpu_senquack.GPU_GP1 &= ~0x14000000;
+ gpu_unai.GPU_GP1 &= ~0x14000000;
do
{
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
// lower 16 bit
//senquack - 64-bit fix (from notaz)
- //u32 data = (unsigned long)gpu_senquack.dma.pvram[gpu_senquack.dma.px];
- u32 data = (u32)gpu_senquack.dma.pvram[gpu_senquack.dma.px];
+ //u32 data = (unsigned long)gpu_unai.dma.pvram[gpu_unai.dma.px];
+ u32 data = (u32)gpu_unai.dma.pvram[gpu_unai.dma.px];
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
}
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
// higher 16 bit (always, even if it's an odd width)
//senquack - 64-bit fix (from notaz)
- //data |= (unsigned long)(gpu_senquack.dma.pvram[gpu_senquack.dma.px])<<16;
- data |= (u32)(gpu_senquack.dma.pvram[gpu_senquack.dma.px])<<16;
+ //data |= (unsigned long)(gpu_unai.dma.pvram[gpu_unai.dma.px])<<16;
+ data |= (u32)(gpu_unai.dma.pvram[gpu_unai.dma.px])<<16;
*dmaAddress++ = data;
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToRead = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToRead = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
break;
}
}
} while (--dmaCount);
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 | 0x14000000) & ~0x60000000;
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 | 0x14000000) & ~0x60000000;
}
///////////////////////////////////////////////////////////////////////////////
u32 GPU_readData(void)
{
- const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"GPU_readData()\n");
#endif
- gpu_senquack.GPU_GP1 &= ~0x14000000;
- if (gpu_senquack.dma.FrameToRead)
+ gpu_unai.GPU_GP1 &= ~0x14000000;
+ if (gpu_unai.dma.FrameToRead)
{
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
- gpu_senquack.GPU_GP0 = gpu_senquack.dma.pvram[gpu_senquack.dma.px];
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.GPU_GP0 = gpu_unai.dma.pvram[gpu_unai.dma.px];
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToRead = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToRead = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
}
}
- if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
- gpu_senquack.GPU_GP0 |= gpu_senquack.dma.pvram[gpu_senquack.dma.px]<<16;
- if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.GPU_GP0 |= gpu_unai.dma.pvram[gpu_unai.dma.px]<<16;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.pvram += 1024;
- if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- gpu_senquack.dma.FrameToRead = false;
- gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToRead = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
}
}
}
- gpu_senquack.GPU_GP1 |= 0x14000000;
+ gpu_unai.GPU_GP1 |= 0x14000000;
- return (gpu_senquack.GPU_GP0);
+ return (gpu_unai.GPU_GP0);
}
///////////////////////////////////////////////////////////////////////////////
u32 GPU_readStatus(void)
{
- return gpu_senquack.GPU_GP1;
+ return gpu_unai.GPU_GP1;
}
INLINE void GPU_NoSkip(void)
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"GPU_NoSkip()\n");
#endif
- gpu_senquack.frameskip.wasSkip = gpu_senquack.frameskip.isSkip;
- if (gpu_senquack.frameskip.isSkip)
+ gpu_unai.frameskip.wasSkip = gpu_unai.frameskip.isSkip;
+ if (gpu_unai.frameskip.isSkip)
{
- gpu_senquack.frameskip.isSkip = false;
- gpu_senquack.frameskip.skipGPU = false;
+ gpu_unai.frameskip.isSkip = false;
+ gpu_unai.frameskip.skipGPU = false;
}
else
{
- gpu_senquack.frameskip.isSkip = gpu_senquack.frameskip.skipFrame;
- gpu_senquack.frameskip.skipGPU = gpu_senquack.frameskip.skipFrame;
+ gpu_unai.frameskip.isSkip = gpu_unai.frameskip.skipFrame;
+ gpu_unai.frameskip.skipGPU = gpu_unai.frameskip.skipFrame;
}
}
gpuReset();
break;
case 0x01:
- gpu_senquack.GPU_GP1 &= ~0x08000000;
- gpu_senquack.PacketCount = 0;
- gpu_senquack.dma.FrameToRead = gpu_senquack.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.PacketCount = 0;
+ gpu_unai.dma.FrameToRead = gpu_unai.dma.FrameToWrite = false;
break;
case 0x02:
- gpu_senquack.GPU_GP1 &= ~0x08000000;
- gpu_senquack.PacketCount = 0;
- gpu_senquack.dma.FrameToRead = gpu_senquack.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.PacketCount = 0;
+ gpu_unai.dma.FrameToRead = gpu_unai.dma.FrameToWrite = false;
break;
case 0x03:
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
break;
case 0x04:
- if (data == 0x04000000) gpu_senquack.PacketCount = 0;
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x60000000) | ((data & 3) << 29);
+ if (data == 0x04000000) gpu_unai.PacketCount = 0;
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x60000000) | ((data & 3) << 29);
break;
case 0x05:
// Start of Display Area in VRAM
- gpu_senquack.DisplayArea[0] = data & 0x3ff; // X (0..1023)
- gpu_senquack.DisplayArea[1] = (data >> 10) & 0x1ff; // Y (0..511)
+ gpu_unai.DisplayArea[0] = data & 0x3ff; // X (0..1023)
+ gpu_unai.DisplayArea[1] = (data >> 10) & 0x1ff; // Y (0..511)
GPU_NoSkip();
break;
case 0x06:
// 0-11 X1 (260h+0) ;12bit ;\counted in 53.222400MHz units,
// 12-23 X2 (260h+320*8) ;12bit ;/relative to HSYNC
- // senquack - gpu_senquack completely ignores GP1(0x06) command and
+ // senquack - gpu_unai completely ignores GP1(0x06) command and
// lacks even a place in DisplayArea[] array to store the values.
// It seems to have been concerned only with vertical display range
// and centering top/bottom. I will not add support here, and
{
u32 v1=data & 0x000003FF; //(short)(data & 0x3ff);
u32 v2=(data & 0x000FFC00) >> 10; //(short)((data>>10) & 0x3ff);
- if ((gpu_senquack.DisplayArea[4]!=v1)||(gpu_senquack.DisplayArea[5]!=v2))
+ if ((gpu_unai.DisplayArea[4]!=v1)||(gpu_unai.DisplayArea[5]!=v2))
{
- gpu_senquack.DisplayArea[4] = v1;
- gpu_senquack.DisplayArea[5] = v2;
+ gpu_unai.DisplayArea[4] = v1;
+ gpu_unai.DisplayArea[5] = v2;
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"video_clear(CHANGE_Y)\n");
#endif
{
static const u32 HorizontalResolution[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
static const u32 VerticalResolution[4] = { 240, 480, 256, 480 };
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x007F0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x007F0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
#ifdef ENABLE_GPU_LOG_SUPPORT
- fprintf(stdout,"GPU_writeStatus(RES=%dx%d,BITS=%d,PAL=%d)\n",HorizontalResolution[(gpu_senquack.GPU_GP1 >> 16) & 7],
- VerticalResolution[(gpu_senquack.GPU_GP1 >> 19) & 3],(gpu_senquack.GPU_GP1&0x00200000?24:15),(IS_PAL?1:0));
+ fprintf(stdout,"GPU_writeStatus(RES=%dx%d,BITS=%d,PAL=%d)\n",HorizontalResolution[(gpu_unai.GPU_GP1 >> 16) & 7],
+ VerticalResolution[(gpu_unai.GPU_GP1 >> 19) & 3],(gpu_unai.GPU_GP1&0x00200000?24:15),(IS_PAL?1:0));
#endif
// Video mode change
- u32 new_width = HorizontalResolution[(gpu_senquack.GPU_GP1 >> 16) & 7];
- u32 new_height = VerticalResolution[(gpu_senquack.GPU_GP1 >> 19) & 3];
+ u32 new_width = HorizontalResolution[(gpu_unai.GPU_GP1 >> 16) & 7];
+ u32 new_height = VerticalResolution[(gpu_unai.GPU_GP1 >> 19) & 3];
- if (gpu_senquack.DisplayArea[2] != new_width || gpu_senquack.DisplayArea[3] != new_height)
+ if (gpu_unai.DisplayArea[2] != new_width || gpu_unai.DisplayArea[3] != new_height)
{
// Update width
- gpu_senquack.DisplayArea[2] = new_width;
+ gpu_unai.DisplayArea[2] = new_width;
if (PixelSkipEnabled()) {
// Set blit_mask for high horizontal resolutions. This allows skipping
// rendering pixels that would never get displayed on low-resolution
// platforms that use simple pixel-dropping scaler.
- switch (gpu_senquack.DisplayArea[2])
+ switch (gpu_unai.DisplayArea[2])
{
- case 512: gpu_senquack.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
- case 640: gpu_senquack.blit_mask = 0xaa; break; // GPU_BlitWS
- default: gpu_senquack.blit_mask = 0; break;
+ case 512: gpu_unai.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
+ case 640: gpu_unai.blit_mask = 0xaa; break; // GPU_BlitWS
+ default: gpu_unai.blit_mask = 0; break;
}
} else {
- gpu_senquack.blit_mask = 0;
+ gpu_unai.blit_mask = 0;
}
// Update height
- gpu_senquack.DisplayArea[3] = new_height;
+ gpu_unai.DisplayArea[3] = new_height;
if (LineSkipEnabled()) {
// Set rendering line-skip (only render every other line in high-res
// 480 vertical mode, or, optionally, force it for all video modes)
- if (gpu_senquack.DisplayArea[3] == 480) {
- if (gpu_senquack.config.ilace_force) {
- gpu_senquack.ilace_mask = 3; // Only need 1/4 of lines
+ if (gpu_unai.DisplayArea[3] == 480) {
+ if (gpu_unai.config.ilace_force) {
+ gpu_unai.ilace_mask = 3; // Only need 1/4 of lines
} else {
- gpu_senquack.ilace_mask = 1; // Only need 1/2 of lines
+ gpu_unai.ilace_mask = 1; // Only need 1/2 of lines
}
} else {
// Vert resolution changed from 480 to lower one
- gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
}
} else {
- gpu_senquack.ilace_mask = 0;
+ gpu_unai.ilace_mask = 0;
}
#ifdef ENABLE_GPU_LOG_SUPPORT
break;
case 0x10:
switch (data & 0xff) {
- case 2: gpu_senquack.GPU_GP0 = gpu_senquack.tex_window; break;
- case 3: gpu_senquack.GPU_GP0 = (gpu_senquack.DrawingArea[1] << 10) | gpu_senquack.DrawingArea[0]; break;
- case 4: gpu_senquack.GPU_GP0 = ((gpu_senquack.DrawingArea[3]-1) << 10) | (gpu_senquack.DrawingArea[2]-1); break;
- case 5: case 6: gpu_senquack.GPU_GP0 = (((u32)gpu_senquack.DrawingOffset[1] & 0x7ff) << 11) | ((u32)gpu_senquack.DrawingOffset[0] & 0x7ff); break;
- case 7: gpu_senquack.GPU_GP0 = 2; break;
- case 8: case 15: gpu_senquack.GPU_GP0 = 0xBFC03720; break;
+ case 2: gpu_unai.GPU_GP0 = gpu_unai.tex_window; break;
+ case 3: gpu_unai.GPU_GP0 = (gpu_unai.DrawingArea[1] << 10) | gpu_unai.DrawingArea[0]; break;
+ case 4: gpu_unai.GPU_GP0 = ((gpu_unai.DrawingArea[3]-1) << 10) | (gpu_unai.DrawingArea[2]-1); break;
+ case 5: case 6: gpu_unai.GPU_GP0 = (((u32)gpu_unai.DrawingOffset[1] & 0x7ff) << 11) | ((u32)gpu_unai.DrawingOffset[0] & 0x7ff); break;
+ case 7: gpu_unai.GPU_GP0 = 2; break;
+ case 8: case 15: gpu_unai.GPU_GP0 = 0xBFC03720; break;
}
break;
}
{
int h0, x0, y0, w0, h1;
- x0 = gpu_senquack.DisplayArea[0];
- y0 = gpu_senquack.DisplayArea[1];
+ x0 = gpu_unai.DisplayArea[0];
+ y0 = gpu_unai.DisplayArea[1];
- w0 = gpu_senquack.DisplayArea[2];
- h0 = gpu_senquack.DisplayArea[3]; // video mode
+ w0 = gpu_unai.DisplayArea[2];
+ h0 = gpu_unai.DisplayArea[3]; // video mode
- h1 = gpu_senquack.DisplayArea[5] - gpu_senquack.DisplayArea[4]; // display needed
+ h1 = gpu_unai.DisplayArea[5] - gpu_unai.DisplayArea[4]; // display needed
if (h0 == 480) h1 = Min2(h1*2,480);
- bool isRGB24 = (gpu_senquack.GPU_GP1 & 0x00200000 ? true : false);
+ bool isRGB24 = (gpu_unai.GPU_GP1 & 0x00200000 ? true : false);
u16* dst16 = SCREEN;
- u16* src16 = (u16*)gpu_senquack.vram;
+ u16* src16 = (u16*)gpu_unai.vram;
// PS1 fb read wraps around (fixes black screen in 'Tobal no. 1')
unsigned int src16_offs_msk = 1024*512-1;
h0=(h0==480 ? 2048 : 1024);
{
- const int li=gpu_senquack.ilace_mask;
+ const int li=gpu_unai.ilace_mask;
bool pi = ProgressiveInterlaceEnabled();
- bool pif = gpu_senquack.prog_ilace_flag;
+ bool pif = gpu_unai.prog_ilace_flag;
switch ( w0 )
{
case 256:
}
break;
}
- gpu_senquack.prog_ilace_flag = !gpu_senquack.prog_ilace_flag;
+ gpu_unai.prog_ilace_flag = !gpu_unai.prog_ilace_flag;
}
video_flip();
}
u32 now=get_ticks(); // current frame
// Update frameskip
- if (gpu_senquack.frameskip.skipCount==0) gpu_senquack.frameskip.skipFrame=false; // frameskip off
- else if (gpu_senquack.frameskip.skipCount==7) { if (show) gpu_senquack.frameskip.skipFrame=!gpu_senquack.frameskip.skipFrame; } // frameskip medium
- else if (gpu_senquack.frameskip.skipCount==8) gpu_senquack.frameskip.skipFrame=true; // frameskip maximum
+ if (gpu_unai.frameskip.skipCount==0) gpu_unai.frameskip.skipFrame=false; // frameskip off
+ else if (gpu_unai.frameskip.skipCount==7) { if (show) gpu_unai.frameskip.skipFrame=!gpu_unai.frameskip.skipFrame; } // frameskip medium
+ else if (gpu_unai.frameskip.skipCount==8) gpu_unai.frameskip.skipFrame=true; // frameskip maximum
else
{
static u32 spd=100; // speed %
frames=0;
prev=now;
}
- switch(gpu_senquack.frameskip.skipCount)
+ switch(gpu_unai.frameskip.skipCount)
{
- case 1: if (spd<50) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<50%)
- case 2: if (spd<60) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<60%)
- case 3: if (spd<70) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<70%)
- case 4: if (spd<80) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<80%)
- case 5: if (spd<90) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<90%)
+ case 1: if (spd<50) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<50%)
+ case 2: if (spd<60) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<60%)
+ case 3: if (spd<70) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<70%)
+ case 4: if (spd<80) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<80%)
+ case 5: if (spd<90) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<90%)
}
}
}
void GPU_updateLace(void)
{
// Interlace bit toggle
- gpu_senquack.GPU_GP1 ^= 0x80000000;
+ gpu_unai.GPU_GP1 ^= 0x80000000;
// Update display?
- if ((gpu_senquack.fb_dirty) && (!gpu_senquack.frameskip.wasSkip) && (!(gpu_senquack.GPU_GP1&0x00800000)))
+ if ((gpu_unai.fb_dirty) && (!gpu_unai.frameskip.wasSkip) && (!(gpu_unai.GPU_GP1&0x00800000)))
{
// Display updated
gpuVideoOutput();
#endif
}
- if ((!gpu_senquack.frameskip.skipCount) && (gpu_senquack.DisplayArea[3] == 480)) gpu_senquack.frameskip.skipGPU=true; // Tekken 3 hack
+ if ((!gpu_unai.frameskip.skipCount) && (gpu_unai.DisplayArea[3] == 480)) gpu_unai.frameskip.skipGPU=true; // Tekken 3 hack
- gpu_senquack.fb_dirty=false;
- gpu_senquack.dma.last_dma = NULL;
+ gpu_unai.fb_dirty=false;
+ gpu_unai.dma.last_dma = NULL;
}
// Allows frontend to signal plugin to redraw screen after returning to emu
void GPU_requestScreenRedraw()
{
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
}
void GPU_getScreenInfo(GPUScreenInfo_t *sinfo)
{
- bool depth24 = (gpu_senquack.GPU_GP1 & 0x00200000 ? true : false);
- int16_t hres = (uint16_t)gpu_senquack.DisplayArea[2];
- int16_t vres = (uint16_t)gpu_senquack.DisplayArea[3];
- int16_t w = hres; // Original gpu_senquack doesn't support width < 100%
- int16_t h = gpu_senquack.DisplayArea[5] - gpu_senquack.DisplayArea[4];
+ bool depth24 = (gpu_unai.GPU_GP1 & 0x00200000 ? true : false);
+ int16_t hres = (uint16_t)gpu_unai.DisplayArea[2];
+ int16_t vres = (uint16_t)gpu_unai.DisplayArea[3];
+ int16_t w = hres; // Original gpu_unai doesn't support width < 100%
+ int16_t h = gpu_unai.DisplayArea[5] - gpu_unai.DisplayArea[4];
if (vres == 480)
h *= 2;
if (h <= 0 || h > vres)
h = vres;
- sinfo->vram = (uint8_t*)gpu_senquack.vram;
- sinfo->x = (uint16_t)gpu_senquack.DisplayArea[0];
- sinfo->y = (uint16_t)gpu_senquack.DisplayArea[1];
+ sinfo->vram = (uint8_t*)gpu_unai.vram;
+ sinfo->x = (uint16_t)gpu_unai.DisplayArea[0];
+ sinfo->y = (uint16_t)gpu_unai.DisplayArea[1];
sinfo->w = w;
sinfo->h = h;
sinfo->hres = hres;
#ifndef GPU_UNAI_GPU_H
#define GPU_UNAI_GPU_H
-struct gpu_senquack_config_t {
+struct gpu_unai_config_t {
uint8_t pixel_skip:1; // If 1, allows skipping rendering pixels that
// would not be visible when a high horizontal
// resolution PS1 video mode is set.
uint8_t ilace_force:3; // Option to force skipping rendering of lines,
// for very slow platforms. Value will be
- // assigned to 'ilace_mask' in gpu_senquack struct.
+ // assigned to 'ilace_mask' in gpu_unai struct.
// Normally 0. Value '1' will skip rendering
// odd lines.
uint8_t blending:1;
uint8_t dithering:1;
- //senquack Only PCSX Rearmed's version of gpu_senquack had this, and I
+ //senquack Only PCSX Rearmed's version of gpu_unai had this, and I
// don't think it's necessary. It would require adding 'AH' flag to
// gpuSpriteSpanFn() increasing size of sprite span function array.
//uint8_t enableAbbeyHack:1; // Abe's Odyssey hack
////////////////////////////////////////////////////////////////////////////
- // Variables used only by older standalone version of gpu_senquack (gpu.cpp)
+ // Variables used only by older standalone version of gpu_unai (gpu.cpp)
#ifndef USE_GPULIB
uint8_t prog_ilace:1; // Progressive interlace option (old option)
// This option was somewhat oddly named:
#endif
};
-extern gpu_senquack_config_t gpu_senquack_config_ext;
+extern gpu_unai_config_t gpu_unai_config_ext;
// TODO: clean up show_fps frontend option
extern bool show_fps;
extern "C" {
#endif
-void draw_spr16_full(u16 *d, void *s, u16 *pal, int lines);
+void draw_spr16_full(void *d, void *s, void *pal, int lines);
#ifdef __cplusplus
}
void gpuSetTexture(u16 tpage)
{
u32 tmode, tx, ty;
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x1FF) | (tpage & 0x1FF);
- gpu_senquack.TextureWindow[0]&= ~gpu_senquack.TextureWindow[2];
- gpu_senquack.TextureWindow[1]&= ~gpu_senquack.TextureWindow[3];
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x1FF) | (tpage & 0x1FF);
+ gpu_unai.TextureWindow[0]&= ~gpu_unai.TextureWindow[2];
+ gpu_unai.TextureWindow[1]&= ~gpu_unai.TextureWindow[3];
tmode = (tpage >> 7) & 3; // 16bpp, 8bpp, or 4bpp texture colors?
// 0: 4bpp 1: 8bpp 2/3: 16bpp
tx = (tpage & 0x0F) << 6;
ty = (tpage & 0x10) << 4;
- tx += (gpu_senquack.TextureWindow[0] >> (2 - tmode));
- ty += gpu_senquack.TextureWindow[1];
+ tx += (gpu_unai.TextureWindow[0] >> (2 - tmode));
+ ty += gpu_unai.TextureWindow[1];
- gpu_senquack.BLEND_MODE = ((tpage>>5) & 3) << 3;
- gpu_senquack.TEXT_MODE = (tmode + 1) << 5; // gpu_senquack.TEXT_MODE should be values 1..3, so add one
- gpu_senquack.TBA = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(tx, ty)];
+ gpu_unai.BLEND_MODE = ((tpage>>5) & 3) << 3;
+ gpu_unai.TEXT_MODE = (tmode + 1) << 5; // gpu_unai.TEXT_MODE should be values 1..3, so add one
+ gpu_unai.TBA = &gpu_unai.vram[FRAME_OFFSET(tx, ty)];
}
///////////////////////////////////////////////////////////////////////////////
INLINE void gpuSetCLUT(u16 clut)
{
- gpu_senquack.CBA = &((u16*)gpu_senquack.vram)[(clut & 0x7FFF) << 4];
+ gpu_unai.CBA = &gpu_unai.vram[(clut & 0x7FFF) << 4];
}
#ifdef ENABLE_GPU_NULL_SUPPORT
#endif
#define Blending (((PRIM&0x2) && BlendingEnabled()) ? (PRIM&0x2) : 0)
-#define Blending_Mode (((PRIM&0x2) && BlendingEnabled()) ? gpu_senquack.BLEND_MODE : 0)
+#define Blending_Mode (((PRIM&0x2) && BlendingEnabled()) ? gpu_unai.BLEND_MODE : 0)
#define Lighting (((~PRIM)&0x1) && LightingEnabled())
// Dithering applies only to Gouraud-shaded polys or texture-blended polys:
#define Dithering (((((~PRIM)&0x1) || (PRIM&0x10)) && DitheringEnabled()) ? \
- (ForcedDitheringEnabled() ? (1<<9) : (gpu_senquack.GPU_GP1 & (1 << 9))) \
+ (ForcedDitheringEnabled() ? (1<<9) : (gpu_unai.GPU_GP1 & (1 << 9))) \
: 0)
///////////////////////////////////////////////////////////////////////////////
-//Now handled by Rearmed's gpulib and gpu_senquack/gpulib_if.cpp:
+//Now handled by Rearmed's gpulib and gpu_unai/gpulib_if.cpp:
///////////////////////////////////////////////////////////////////////////////
#ifndef USE_GPULIB
// Handles GP0 draw settings commands 0xE1...0xE6
-static void gpuGP0Cmd_0xEx(gpu_senquack_t &gpu_senquack, u32 cmd_word)
+static void gpuGP0Cmd_0xEx(gpu_unai_t &gpu_unai, u32 cmd_word)
{
// Assume incoming GP0 command is 0xE1..0xE6, convert to 1..6
u8 num = (cmd_word >> 24) & 7;
case 1: {
// GP0(E1h) - Draw Mode setting (aka "Texpage")
DO_LOG(("GP0(0xE1) DrawMode TexPage(0x%x)\n", cmd_word));
- u32 cur_texpage = gpu_senquack.GPU_GP1 & 0x7FF;
+ u32 cur_texpage = gpu_unai.GPU_GP1 & 0x7FF;
u32 new_texpage = cmd_word & 0x7FF;
if (cur_texpage != new_texpage) {
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x7FF) | new_texpage;
- gpuSetTexture(gpu_senquack.GPU_GP1);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x7FF) | new_texpage;
+ gpuSetTexture(gpu_unai.GPU_GP1);
}
} break;
case 2: {
// GP0(E2h) - Texture Window setting
DO_LOG(("GP0(0xE2) TextureWindow(0x%x)\n", cmd_word));
- if (cmd_word != gpu_senquack.TextureWindowCur) {
+ if (cmd_word != gpu_unai.TextureWindowCur) {
static const u8 TextureMask[32] = {
255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7,
127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7
};
- gpu_senquack.TextureWindowCur = cmd_word;
- gpu_senquack.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
- gpu_senquack.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
- gpu_senquack.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
- gpu_senquack.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
- gpu_senquack.TextureWindow[0] &= ~gpu_senquack.TextureWindow[2];
- gpu_senquack.TextureWindow[1] &= ~gpu_senquack.TextureWindow[3];
+ gpu_unai.TextureWindowCur = cmd_word;
+ gpu_unai.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
+ gpu_unai.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
+ gpu_unai.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
+ gpu_unai.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
+ gpu_unai.TextureWindow[0] &= ~gpu_unai.TextureWindow[2];
+ gpu_unai.TextureWindow[1] &= ~gpu_unai.TextureWindow[3];
// Inner loop vars must be updated whenever texture window is changed:
const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
- gpu_senquack.u_msk = (((u32)gpu_senquack.TextureWindow[2]) << fb) | ((1 << fb) - 1);
- gpu_senquack.v_msk = (((u32)gpu_senquack.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+ 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);
- gpuSetTexture(gpu_senquack.GPU_GP1);
+ gpuSetTexture(gpu_unai.GPU_GP1);
}
} break;
case 3: {
// GP0(E3h) - Set Drawing Area top left (X1,Y1)
DO_LOG(("GP0(0xE3) DrawingArea Pos(0x%x)\n", cmd_word));
- gpu_senquack.DrawingArea[0] = cmd_word & 0x3FF;
- gpu_senquack.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
+ gpu_unai.DrawingArea[0] = cmd_word & 0x3FF;
+ gpu_unai.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
} break;
case 4: {
// GP0(E4h) - Set Drawing Area bottom right (X2,Y2)
DO_LOG(("GP0(0xE4) DrawingArea Size(0x%x)\n", cmd_word));
- gpu_senquack.DrawingArea[2] = (cmd_word & 0x3FF) + 1;
- gpu_senquack.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
+ gpu_unai.DrawingArea[2] = (cmd_word & 0x3FF) + 1;
+ gpu_unai.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
} break;
case 5: {
// GP0(E5h) - Set Drawing Offset (X,Y)
DO_LOG(("GP0(0xE5) DrawingOffset(0x%x)\n", cmd_word));
- gpu_senquack.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
- gpu_senquack.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
+ gpu_unai.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
+ gpu_unai.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
} break;
case 6: {
// GP0(E6h) - Mask Bit Setting
DO_LOG(("GP0(0xE6) SetMask(0x%x)\n", cmd_word));
- gpu_senquack.Masking = (cmd_word & 0x2) << 1;
- gpu_senquack.PixelMSB = (cmd_word & 0x1) << 8;
+ gpu_unai.Masking = (cmd_word & 0x2) << 1;
+ gpu_unai.PixelMSB = (cmd_word & 0x1) << 8;
} break;
}
}
//senquack - TODO: optimize this (packet pointer union as prim draw parameter
// introduced as optimization for gpulib command-list processing)
- PtrUnion packet = { .ptr = (void*)&gpu_senquack.PacketBuffer };
+ PtrUnion packet = { .ptr = (void*)&gpu_unai.PacketBuffer };
switch (PRIM)
{
case 0x02: {
NULL_GPU();
gpuClearImage(packet); // prim handles updateLace && skip
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuClearImage(0x%x)\n",PRIM));
} break;
case 0x21:
case 0x22:
case 0x23: { // Monochrome 3-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Blending_Mode |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
];
gpuDrawPolyF(packet, driver, false);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyF(0x%x)\n",PRIM));
}
} break;
case 0x25:
case 0x26:
case 0x27: { // Textured 3-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture (gpu_senquack.PacketBuffer.U4[4] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[4]) >> 16);
u32 driver_idx =
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB;
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
if (!FastLightingEnabled()) {
driver_idx |= Lighting;
} else {
- if (!((gpu_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F)))
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
driver_idx |= Lighting;
}
PP driver = gpuPolySpanDrivers[driver_idx];
gpuDrawPolyFT(packet, driver, false);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyFT(0x%x)\n",PRIM));
}
} break;
case 0x29:
case 0x2A:
case 0x2B: { // Monochrome 4-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Blending_Mode |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
];
gpuDrawPolyF(packet, driver, true); // is_quad = true
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyF(0x%x) (4-pt QUAD)\n",PRIM));
}
} break;
case 0x2D:
case 0x2E:
case 0x2F: { // Textured 4-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture (gpu_senquack.PacketBuffer.U4[4] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[4]) >> 16);
u32 driver_idx =
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB;
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
if (!FastLightingEnabled()) {
driver_idx |= Lighting;
} else {
- if (!((gpu_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F)))
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
driver_idx |= Lighting;
}
PP driver = gpuPolySpanDrivers[driver_idx];
gpuDrawPolyFT(packet, driver, true); // is_quad = true
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyFT(0x%x) (4-pt QUAD)\n",PRIM));
}
} break;
case 0x31:
case 0x32:
case 0x33: { // Gouraud-shaded 3-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
//NOTE: The '129' here is CF_GOURAUD | CF_LIGHT, however
// shouldn't apply. Until the original array of template
// instantiation ptrs is fixed, we're stuck with this. (TODO)
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
Blending_Mode |
- gpu_senquack.Masking | Blending | 129 | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
];
gpuDrawPolyG(packet, driver, false);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyG(0x%x)\n",PRIM));
}
} break;
case 0x35:
case 0x36:
case 0x37: { // Gouraud-shaded, textured 3-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture (gpu_senquack.PacketBuffer.U4[5] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16);
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | ((Lighting)?129:0) | gpu_senquack.PixelMSB
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
];
gpuDrawPolyGT(packet, driver, false);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyGT(0x%x)\n",PRIM));
}
} break;
case 0x39:
case 0x3A:
case 0x3B: { // Gouraud-shaded 4-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
// See notes regarding '129' for 0x30..0x33 further above -senquack
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
Blending_Mode |
- gpu_senquack.Masking | Blending | 129 | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
];
gpuDrawPolyG(packet, driver, true); // is_quad = true
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyG(0x%x) (4-pt QUAD)\n",PRIM));
}
} break;
case 0x3D:
case 0x3E:
case 0x3F: { // Gouraud-shaded, textured 4-pt poly
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture (gpu_senquack.PacketBuffer.U4[5] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16);
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | ((Lighting)?129:0) | gpu_senquack.PixelMSB
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
];
gpuDrawPolyGT(packet, driver, true); // is_quad = true
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawPolyGT(0x%x) (4-pt QUAD)\n",PRIM));
}
} break;
case 0x41:
case 0x42:
case 0x43: { // Monochrome line
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
PSD driver = gpuPixelSpanDrivers[driver_idx];
gpuDrawLineF(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawLineF(0x%x)\n",PRIM));
}
} break;
case 0x4D:
case 0x4E:
case 0x4F: { // Monochrome line strip
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
PSD driver = gpuPixelSpanDrivers[driver_idx];
gpuDrawLineF(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawLineF(0x%x)\n",PRIM));
}
- if ((gpu_senquack.PacketBuffer.U4[3] & 0xF000F000) != 0x50005000)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[3]) & HTOLE32(0xF000F000)) != HTOLE32(0x50005000))
{
- gpu_senquack.PacketBuffer.U4[1] = gpu_senquack.PacketBuffer.U4[2];
- gpu_senquack.PacketBuffer.U4[2] = gpu_senquack.PacketBuffer.U4[3];
- gpu_senquack.PacketCount = 1;
- gpu_senquack.PacketIndex = 3;
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[2] = gpu_unai.PacketBuffer.U4[3];
+ gpu_unai.PacketCount = 1;
+ gpu_unai.PacketIndex = 3;
}
} break;
case 0x51:
case 0x52:
case 0x53: { // Gouraud-shaded line
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
// Index MSB selects Gouraud-shaded PixelSpanDriver:
driver_idx |= (1 << 5);
PSD driver = gpuPixelSpanDrivers[driver_idx];
gpuDrawLineG(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawLineG(0x%x)\n",PRIM));
}
} break;
case 0x5D:
case 0x5E:
case 0x5F: { // Gouraud-shaded line strip
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
// Index MSB selects Gouraud-shaded PixelSpanDriver:
driver_idx |= (1 << 5);
PSD driver = gpuPixelSpanDrivers[driver_idx];
gpuDrawLineG(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawLineG(0x%x)\n",PRIM));
}
- if ((gpu_senquack.PacketBuffer.U4[4] & 0xF000F000) != 0x50005000)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[4]) & HTOLE32(0xF000F000)) != HTOLE32(0x50005000))
{
- gpu_senquack.PacketBuffer.U1[3 + (2 * 4)] = gpu_senquack.PacketBuffer.U1[3 + (0 * 4)];
- gpu_senquack.PacketBuffer.U4[0] = gpu_senquack.PacketBuffer.U4[2];
- gpu_senquack.PacketBuffer.U4[1] = gpu_senquack.PacketBuffer.U4[3];
- gpu_senquack.PacketBuffer.U4[2] = gpu_senquack.PacketBuffer.U4[4];
- gpu_senquack.PacketCount = 2;
- gpu_senquack.PacketIndex = 3;
+ gpu_unai.PacketBuffer.U1[3 + (2 * 4)] = gpu_unai.PacketBuffer.U1[3 + (0 * 4)];
+ gpu_unai.PacketBuffer.U4[0] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[3];
+ gpu_unai.PacketBuffer.U4[2] = gpu_unai.PacketBuffer.U4[4];
+ gpu_unai.PacketCount = 2;
+ gpu_unai.PacketIndex = 3;
}
} break;
case 0x61:
case 0x62:
case 0x63: { // Monochrome rectangle (variable size)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
gpuDrawT(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
} break;
case 0x65:
case 0x66:
case 0x67: { // Textured rectangle (variable size)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- u32 driver_idx = Blending_Mode | gpu_senquack.TEXT_MODE | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>1);
+ 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);
// 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_senquack uses a simple lighting LUT whereby only the upper
+ // 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_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F))
+ //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 ((gpu_senquack.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080))
driver_idx |= Lighting;
PS driver = gpuSpriteSpanDrivers[driver_idx];
gpuDrawS(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
}
} break;
case 0x69:
case 0x6A:
case 0x6B: { // Monochrome rectangle (1x1 dot)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpu_senquack.PacketBuffer.U4[2] = 0x00010001;
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ 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);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
} break;
case 0x71:
case 0x72:
case 0x73: { // Monochrome rectangle (8x8)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpu_senquack.PacketBuffer.U4[2] = 0x00080008;
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ 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);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
} break;
case 0x75:
case 0x76:
case 0x77: { // Textured rectangle (8x8)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpu_senquack.PacketBuffer.U4[3] = 0x00080008;
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- u32 driver_idx = Blending_Mode | gpu_senquack.TEXT_MODE | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>1);
+ 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_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F))
+ //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 ((gpu_senquack.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080))
driver_idx |= Lighting;
PS driver = gpuSpriteSpanDrivers[driver_idx];
gpuDrawS(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
}
} break;
case 0x79:
case 0x7A:
case 0x7B: { // Monochrome rectangle (16x16)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpu_senquack.PacketBuffer.U4[2] = 0x00100010;
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ 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);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
} break;
case 0x7D:
#ifdef __arm__
/* Notaz 4bit sprites optimization */
- if ((!gpu_senquack.frameskip.skipGPU) && (!(gpu_senquack.GPU_GP1&0x180)) && (!(gpu_senquack.Masking|gpu_senquack.PixelMSB)))
+ if ((!gpu_unai.frameskip.skipGPU) && (!(gpu_unai.GPU_GP1&0x180)) && (!(gpu_unai.Masking|gpu_unai.PixelMSB)))
{
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
gpuDrawS16(packet);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
break;
}
#endif
case 0x7E:
case 0x7F: { // Textured rectangle (16x16)
- if (!gpu_senquack.frameskip.skipGPU)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpu_senquack.PacketBuffer.U4[3] = 0x00100010;
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- u32 driver_idx = Blending_Mode | gpu_senquack.TEXT_MODE | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>1);
+ 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_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F))
+ //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 ((gpu_senquack.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080))
driver_idx |= Lighting;
PS driver = gpuSpriteSpanDrivers[driver_idx];
gpuDrawS(packet, driver);
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
}
} break;
case 0x80: // vid -> vid
gpuMoveImage(packet); // prim handles updateLace && skip
- if ((!gpu_senquack.frameskip.skipCount) && (gpu_senquack.DisplayArea[3] == 480)) // Tekken 3 hack
+ if ((!gpu_unai.frameskip.skipCount) && (gpu_unai.DisplayArea[3] == 480)) // Tekken 3 hack
{
- if (!gpu_senquack.frameskip.skipGPU) gpu_senquack.fb_dirty = true;
+ if (!gpu_unai.frameskip.skipGPU) gpu_unai.fb_dirty = true;
}
else
{
- gpu_senquack.fb_dirty = true;
+ gpu_unai.fb_dirty = true;
}
DO_LOG(("gpuMoveImage(0x%x)\n",PRIM));
break;
DO_LOG(("gpuStoreImage(0x%x)\n",PRIM));
break;
case 0xE1 ... 0xE6: { // Draw settings
- gpuGP0Cmd_0xEx(gpu_senquack, gpu_senquack.PacketBuffer.U4[0]);
+ gpuGP0Cmd_0xEx(gpu_unai, le32_to_u32(gpu_unai.PacketBuffer.U4[0]));
} break;
}
}
#endif //!USE_GPULIB
///////////////////////////////////////////////////////////////////////////////
-// End of code specific to non-gpulib standalone version of gpu_senquack
+// End of code specific to non-gpulib standalone version of gpu_unai
///////////////////////////////////////////////////////////////////////////////
#endif /* __GPU_UNAI_GPU_COMMAND_H__ */
// rectangles) to use the same set of functions. Since tiles are always
// monochrome, they simply wouldn't use the extra set of 32 gouraud-shaded
// gpuPixelSpanFn functions (TODO?).
-//
-// NOTE: While the PS1 framebuffer is 16 bit, we use 8-bit pointers here,
-// so that pDst can be incremented directly by 'incr' parameter
-// without having to shift it before use.
template<int CF>
-static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len)
+static le16_t* gpuPixelSpanFn(le16_t* pDst, uintptr_t data, ptrdiff_t incr, size_t len)
{
// Blend func can save an operation if it knows uSrc MSB is
// unset. For untextured prims, this is always true.
u32 r, g, b;
s32 r_incr, g_incr, b_incr;
+ // Caller counts in bytes, we count in pixels
+ incr /= 2;
+
if (CF_GOURAUD) {
gcPtr = (GouraudColor*)data;
r = gcPtr->r; r_incr = gcPtr->r_incr;
if (!CF_GOURAUD)
{ // NO GOURAUD
if (!CF_MASKCHECK && !CF_BLEND) {
- if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
- else { *(u16*)pDst = col; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); }
+ else { *pDst = u16_to_le16(col); }
} else if (CF_MASKCHECK && !CF_BLEND) {
- if (!(*(u16*)pDst & 0x8000)) {
- if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
- else { *(u16*)pDst = col; }
+ if (!(le16_raw(*pDst) & HTOLE16(0x8000))) {
+ if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); }
+ else { *pDst = u16_to_le16(col); }
}
} else {
- uint_fast16_t uDst = *(u16*)pDst;
+ uint_fast16_t uDst = le16_to_u16(*pDst);
if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; }
uint_fast16_t uSrc = col;
if (CF_BLEND)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; }
- else { *(u16*)pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else { *pDst = u16_to_le16(uSrc); }
}
} else
if (!CF_MASKCHECK && !CF_BLEND) {
col = gpuGouraudColor15bpp(r, g, b);
- if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
- else { *(u16*)pDst = col; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); }
+ else { *pDst = u16_to_le16(col); }
} else if (CF_MASKCHECK && !CF_BLEND) {
col = gpuGouraudColor15bpp(r, g, b);
- if (!(*(u16*)pDst & 0x8000)) {
- if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
- else { *(u16*)pDst = col; }
+ if (!(le16_raw(*pDst) & HTOLE16(0x8000))) {
+ if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); }
+ else { *pDst = u16_to_le16(col); }
}
} else {
- uint_fast16_t uDst = *(u16*)pDst;
+ uint_fast16_t uDst = le16_to_u16(*pDst);
if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; }
col = gpuGouraudColor15bpp(r, g, b);
if (CF_BLEND)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; }
- else { *(u16*)pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else { *pDst = u16_to_le16(uSrc); }
}
}
return pDst;
}
-static u8* PixelSpanNULL(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len)
+static le16_t* PixelSpanNULL(le16_t* pDst, uintptr_t data, ptrdiff_t incr, size_t len)
{
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"PixelSpanNULL()\n");
///////////////////////////////////////////////////////////////////////////////
// PixelSpan (lines) innerloops driver
-typedef u8* (*PSD)(u8* dst, uintptr_t data, ptrdiff_t incr, size_t len);
+typedef le16_t* (*PSD)(le16_t* dst, uintptr_t data, ptrdiff_t incr, size_t len);
const PSD gpuPixelSpanDrivers[64] =
{
// GPU Tiles innerloops generator
template<int CF>
-static void gpuTileSpanFn(u16 *pDst, u32 count, u16 data)
+static void gpuTileSpanFn(le16_t *pDst, u32 count, u16 data)
{
+ le16_t ldata;
+
if (!CF_MASKCHECK && !CF_BLEND) {
- if (CF_MASKSET) { data = data | 0x8000; }
- do { *pDst++ = data; } while (--count);
+ if (CF_MASKSET)
+ ldata = u16_to_le16(data | 0x8000);
+ else
+ ldata = u16_to_le16(data);
+ do { *pDst++ = ldata; } while (--count);
} else if (CF_MASKCHECK && !CF_BLEND) {
- if (CF_MASKSET) { data = data | 0x8000; }
- do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count);
+ if (CF_MASKSET)
+ ldata = u16_to_le16(data | 0x8000);
+ else
+ ldata = u16_to_le16(data);
+ do {
+ if (!(le16_raw(*pDst) & HTOLE16(0x8000)))
+ *pDst = ldata;
+ pDst++;
+ } while (--count);
} else
{
// Blend func can save an operation if it knows uSrc MSB is
uint_fast16_t uSrc, uDst;
do
{
- if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
- if (CF_MASKCHECK) { if (uDst&0x8000) goto endtile; }
+ if (CF_MASKCHECK || CF_BLEND) { uDst = le16_to_u16(*pDst); }
+ if (CF_MASKCHECK) if (uDst&0x8000) { goto endtile; }
uSrc = data;
if (CF_BLEND)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else { *pDst = u16_to_le16(uSrc); }
//senquack - Did not apply "Silent Hill" mask-bit fix to here.
// It is hard to tell from scarce documentation available and
}
}
-static void TileNULL(u16 *pDst, u32 count, u16 data)
+static void TileNULL(le16_t *pDst, u32 count, u16 data)
{
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"TileNULL()\n");
///////////////////////////////////////////////////////////////////////////////
// Tiles innerloops driver
-typedef void (*PT)(u16 *pDst, u32 count, u16 data);
+typedef void (*PT)(le16_t *pDst, u32 count, u16 data);
// Template instantiation helper macros
#define TI(cf) gpuTileSpanFn<(cf)>
// GPU Sprites innerloops generator
template<int CF>
-static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0)
+static void gpuSpriteSpanFn(le16_t *pDst, u32 count, u8* pTxt, u32 u0)
{
// Blend func can save an operation if it knows uSrc MSB is unset.
// Untextured prims can always skip (source color always comes with MSB=0).
uint_fast16_t uSrc, uDst, srcMSB;
bool should_blend;
- u32 u0_mask = gpu_senquack.TextureWindow[2];
+ u32 u0_mask = gpu_unai.TextureWindow[2];
u8 r5, g5, b5;
if (CF_LIGHT) {
- r5 = gpu_senquack.r5;
- g5 = gpu_senquack.g5;
- b5 = gpu_senquack.b5;
+ r5 = gpu_unai.r5;
+ g5 = gpu_unai.g5;
+ b5 = gpu_unai.b5;
}
if (CF_TEXTMODE==3) {
u0_mask <<= 1;
}
- const u16 *CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_senquack.CBA;
+ const le16_t *CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.CBA;
do
{
- if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
+ if (CF_MASKCHECK || CF_BLEND) { uDst = le16_to_u16(*pDst); }
if (CF_MASKCHECK) if (uDst&0x8000) { goto endsprite; }
if (CF_TEXTMODE==1) { // 4bpp (CLUT)
u8 rgb = pTxt[(u0 & u0_mask)>>1];
- uSrc = CBA_[(rgb>>((u0&1)<<2))&0xf];
+ uSrc = le16_to_u16(CBA_[(rgb>>((u0&1)<<2))&0xf]);
}
if (CF_TEXTMODE==2) { // 8bpp (CLUT)
- uSrc = CBA_[pTxt[u0 & u0_mask]];
+ uSrc = le16_to_u16(CBA_[pTxt[u0 & u0_mask]]);
}
if (CF_TEXTMODE==3) { // 16bpp
- uSrc = *(u16*)(&pTxt[u0 & u0_mask]);
+ uSrc = le16_to_u16(*(le16_t*)(&pTxt[u0 & u0_mask]));
}
if (!uSrc) goto endsprite;
if (CF_BLEND && should_blend)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = u16_to_le16(uSrc | srcMSB); }
+ else { *pDst = u16_to_le16(uSrc); }
endsprite:
u0 += (CF_TEXTMODE==3) ? 2 : 1;
while (--count);
}
-static void SpriteNULL(u16 *pDst, u32 count, u8* pTxt, u32 u0)
+static void SpriteNULL(le16_t *pDst, u32 count, u8* pTxt, u32 u0)
{
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"SpriteNULL()\n");
///////////////////////////////////////////////////////////////////////////////
// Sprite innerloops driver
-typedef void (*PS)(u16 *pDst, u32 count, u8* pTxt, u32 u0);
+typedef void (*PS)(le16_t *pDst, u32 count, u8* pTxt, u32 u0);
// Template instantiation helper macros
#define TI(cf) gpuSpriteSpanFn<(cf)>
// relevant blend/light headers.
// (see README_senquack.txt)
template<int CF>
-static void gpuPolySpanFn(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count)
+static void gpuPolySpanFn(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count)
{
// Blend func can save an operation if it knows uSrc MSB is unset.
// Untextured prims can always skip this (src color MSB is always 0).
const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT;
bool should_blend;
- u32 bMsk; if (CF_BLITMASK) bMsk = gpu_senquack.blit_mask;
+ u32 bMsk; if (CF_BLITMASK) bMsk = gpu_unai.blit_mask;
if (!CF_TEXTMODE)
{
if (!CF_GOURAUD)
{
// UNTEXTURED, NO GOURAUD
- const u16 pix15 = gpu_senquack.PixelData;
+ const u16 pix15 = gpu_unai.PixelData;
do {
uint_fast16_t uSrc, uDst;
// gravestone text at end of Medieval intro sequence. -senquack
//if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) { goto endpolynotextnogou; } }
- if (CF_BLEND || CF_MASKCHECK) uDst = *pDst;
+ if (CF_BLEND || CF_MASKCHECK) uDst = le16_to_u16(*pDst);
if (CF_MASKCHECK) { if (uDst&0x8000) { goto endpolynotextnogou; } }
uSrc = pix15;
if (CF_BLEND)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else { *pDst = u16_to_le16(uSrc); }
endpolynotextnogou:
pDst++;
else
{
// UNTEXTURED, GOURAUD
- u32 l_gCol = gpu_senquack.gCol;
- u32 l_gInc = gpu_senquack.gInc;
+ u32 l_gCol = gpu_unai.gCol;
+ u32 l_gInc = gpu_unai.gInc;
do {
uint_fast16_t uDst, uSrc;
// See note in above loop regarding CF_BLITMASK
//if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolynotextgou; }
- if (CF_BLEND || CF_MASKCHECK) uDst = *pDst;
+ if (CF_BLEND || CF_MASKCHECK) uDst = le16_to_u16(*pDst);
if (CF_MASKCHECK) { if (uDst&0x8000) goto endpolynotextgou; }
if (CF_DITHER) {
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
}
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else { *pDst = u16_to_le16(uSrc); }
endpolynotextgou:
pDst++;
uint_fast16_t uDst, uSrc, srcMSB;
- //senquack - note: original UNAI code had gpu_senquack.{u4/v4} packed into
+ //senquack - note: original UNAI code had gpu_unai.{u4/v4} packed into
// one 32-bit unsigned int, but this proved to lose too much accuracy
// (pixel drouputs noticeable in NFS3 sky), so now are separate vars.
- u32 l_u_msk = gpu_senquack.u_msk; u32 l_v_msk = gpu_senquack.v_msk;
- u32 l_u = gpu_senquack.u & l_u_msk; u32 l_v = gpu_senquack.v & l_v_msk;
- s32 l_u_inc = gpu_senquack.u_inc; s32 l_v_inc = gpu_senquack.v_inc;
+ u32 l_u_msk = gpu_unai.u_msk; u32 l_v_msk = gpu_unai.v_msk;
+ u32 l_u = gpu_unai.u & l_u_msk; u32 l_v = gpu_unai.v & l_v_msk;
+ s32 l_u_inc = gpu_unai.u_inc; s32 l_v_inc = gpu_unai.v_inc;
- const u16* TBA_ = gpu_senquack.TBA;
- const u16* CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_senquack.CBA;
+ const le16_t* TBA_ = gpu_unai.TBA;
+ const le16_t* CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.CBA;
u8 r5, g5, b5;
u8 r8, g8, b8;
if (CF_LIGHT) {
if (CF_GOURAUD) {
- l_gInc = gpu_senquack.gInc;
- l_gCol = gpu_senquack.gCol;
+ l_gInc = gpu_unai.gInc;
+ l_gCol = gpu_unai.gCol;
} else {
if (CF_DITHER) {
- r8 = gpu_senquack.r8;
- g8 = gpu_senquack.g8;
- b8 = gpu_senquack.b8;
+ r8 = gpu_unai.r8;
+ g8 = gpu_unai.g8;
+ b8 = gpu_unai.b8;
} else {
- r5 = gpu_senquack.r5;
- g5 = gpu_senquack.g5;
- b5 = gpu_senquack.b5;
+ r5 = gpu_unai.r5;
+ g5 = gpu_unai.g5;
+ b5 = gpu_unai.b5;
}
}
}
do
{
if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolytext; }
- if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
+ if (CF_MASKCHECK || CF_BLEND) { uDst = le16_to_u16(*pDst); }
if (CF_MASKCHECK) if (uDst&0x8000) { goto endpolytext; }
//senquack - adapted to work with new 22.10 fixed point routines:
u32 tu=(l_u>>10);
u32 tv=(l_v<<1)&(0xff<<11);
u8 rgb=((u8*)TBA_)[tv+(tu>>1)];
- uSrc=CBA_[(rgb>>((tu&1)<<2))&0xf];
+ uSrc=le16_to_u16(CBA_[(rgb>>((tu&1)<<2))&0xf]);
if (!uSrc) goto endpolytext;
}
if (CF_TEXTMODE==2) { // 8bpp (CLUT)
- uSrc = CBA_[(((u8*)TBA_)[(l_u>>10)+((l_v<<1)&(0xff<<11))])];
+ uSrc = le16_to_u16(CBA_[(((u8*)TBA_)[(l_u>>10)+((l_v<<1)&(0xff<<11))])]);
if (!uSrc) goto endpolytext;
}
if (CF_TEXTMODE==3) { // 16bpp
- uSrc = TBA_[(l_u>>10)+((l_v)&(0xff<<10))];
+ uSrc = le16_to_u16(TBA_[(l_u>>10)+((l_v)&(0xff<<10))]);
if (!uSrc) goto endpolytext;
}
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
}
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); }
+ else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = u16_to_le16(uSrc | srcMSB); }
+ else { *pDst = u16_to_le16(uSrc); }
endpolytext:
pDst++;
l_u = (l_u + l_u_inc) & l_u_msk;
}
}
-static void PolyNULL(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count)
+static void PolyNULL(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count)
{
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"PolyNULL()\n");
///////////////////////////////////////////////////////////////////////////////
// Polygon innerloops driver
-typedef void (*PP)(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count);
+typedef void (*PP)(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count);
// Template instantiation helper macros
#define TI(cf) gpuPolySpanFn<(cf)>
for (int i=0; i < 32; ++i) {
int val = i * j / 16;
if (val > 31) val = 31;
- gpu_senquack.LightLUT[(j*32) + i] = val;
+ gpu_unai.LightLUT[(j*32) + i] = val;
}
}
}
////////////////////////////////////////////////////////////////////////////////
GPU_INLINE uint_fast16_t gpuLightingTXTGeneric(uint_fast16_t uSrc, u8 r5, u8 g5, u8 b5)
{
- return (gpu_senquack.LightLUT[((uSrc&0x7C00)>>5) | b5] << 10) |
- (gpu_senquack.LightLUT[ (uSrc&0x03E0) | g5] << 5) |
- (gpu_senquack.LightLUT[((uSrc&0x001F)<<5) | r5] );
+ return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | b5] << 10) |
+ (gpu_unai.LightLUT[ (uSrc&0x03E0) | g5] << 5) |
+ (gpu_unai.LightLUT[((uSrc&0x001F)<<5) | r5] );
}
////////////////////////////////////////////////////////////////////////////////
GPU_INLINE uint_fast16_t gpuLightingTXTGouraudGeneric(uint_fast16_t uSrc, u32 gCol)
{
- return (gpu_senquack.LightLUT[((uSrc&0x7C00)>>5) | ((gCol>> 5)&0x1F)]<<10) |
- (gpu_senquack.LightLUT[ (uSrc&0x03E0) | ((gCol>>16)&0x1F)]<< 5) |
- (gpu_senquack.LightLUT[((uSrc&0x001F)<<5) | (gCol>>27) ] );
+ return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | ((gCol>> 5)&0x1F)]<<10) |
+ (gpu_unai.LightLUT[ (uSrc&0x03E0) | ((gCol>>16)&0x1F)]<< 5) |
+ (gpu_unai.LightLUT[((uSrc&0x001F)<<5) | (gCol>>27) ] );
}
"orr %[out], %[out], %[db], lsl #0x0A \n\t" // out holds 0xmbbbbbgggggrrrrr
: [out] "=&r" (out), [db] "=&r" (db), [dg] "=&r" (dg)
: [r5] "r" (r5), [g5] "r" (g5), [b5] "r" (b5),
- [lut] "r" (gpu_senquack.LightLUT), [src] "r" (uSrc), "0" (out)
+ [lut] "r" (gpu_unai.LightLUT), [src] "r" (uSrc), "0" (out)
: "cc");
return out;
}
"orr %[out], %[out], %[db], lsl #0x0A \n\t" // out holds 0xmbbbbbgggggrrrrr
: [out] "=&r" (out), [db] "=&r" (db), [dg] "=&r" (dg),
[gtmp] "=&r" (gtmp) \
- : [gCol] "r" (gCol), [lut] "r" (gpu_senquack.LightLUT), "0" (out), [src] "r" (uSrc)
+ : [gCol] "r" (gCol), [lut] "r" (gpu_unai.LightLUT), "0" (out), [src] "r" (uSrc)
: "cc");
return out;
// Is 8x8 matrix overkill as a result, can we use 4x4?
component &= ~1;
- gpu_senquack.DitherMatrix[offset] = (component)
+ gpu_unai.DitherMatrix[offset] = (component)
| (component << 10)
| (component << 20);
}
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
template <int DITHER>
-GPU_INLINE u16 gpuColorQuantization24(u32 uSrc24, const u16 *pDst)
+GPU_INLINE u16 gpuColorQuantization24(u32 uSrc24, const le16_t *pDst)
{
if (DITHER)
{
- u16 fbpos = (u32)(pDst - gpu_senquack.vram);
+ uintptr_t fbpos = pDst - gpu_unai.vram;
u16 offset = ((fbpos & (0x7 << 10)) >> 7) | (fbpos & 0x7);
//clean overflow flags and add
- uSrc24 = (uSrc24 & 0x1FF7FDFF) + gpu_senquack.DitherMatrix[offset];
+ uSrc24 = (uSrc24 & 0x1FF7FDFF) + gpu_unai.DitherMatrix[offset];
if (uSrc24 & (1<< 9)) uSrc24 |= (0x1FF );
if (uSrc24 & (1<<19)) uSrc24 |= (0x1FF<<10);
void gpuLoadImage(PtrUnion packet)
{
u16 x0, y0, w0, h0;
- x0 = packet.U2[2] & 1023;
- y0 = packet.U2[3] & 511;
- w0 = packet.U2[4];
- h0 = packet.U2[5];
+ x0 = le16_to_u16(packet.U2[2]) & 1023;
+ y0 = le16_to_u16(packet.U2[3]) & 511;
+ w0 = le16_to_u16(packet.U2[4]);
+ h0 = le16_to_u16(packet.U2[5]);
if ((y0 + h0) > FRAME_HEIGHT)
{
h0 = FRAME_HEIGHT - y0;
}
- gpu_senquack.dma.FrameToWrite = ((w0)&&(h0));
+ gpu_unai.dma.FrameToWrite = ((w0)&&(h0));
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.py = 0;
- gpu_senquack.dma.x_end = w0;
- gpu_senquack.dma.y_end = h0;
- gpu_senquack.dma.pvram = &((u16*)gpu_senquack.vram)[x0+(y0*1024)];
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.py = 0;
+ gpu_unai.dma.x_end = w0;
+ gpu_unai.dma.y_end = h0;
+ gpu_unai.dma.pvram = &gpu_unai.vram[x0+(y0*1024)];
- gpu_senquack.GPU_GP1 |= 0x08000000;
+ gpu_unai.GPU_GP1 |= 0x08000000;
}
#endif // !USE_GPULIB
void gpuStoreImage(PtrUnion packet)
{
u16 x0, y0, w0, h0;
- x0 = packet.U2[2] & 1023;
- y0 = packet.U2[3] & 511;
- w0 = packet.U2[4];
- h0 = packet.U2[5];
+ x0 = le16_to_u16(packet.U2[2]) & 1023;
+ y0 = le16_to_u16(packet.U2[3]) & 511;
+ w0 = le16_to_u16(packet.U2[4]);
+ h0 = le16_to_u16(packet.U2[5]);
if ((y0 + h0) > FRAME_HEIGHT)
{
h0 = FRAME_HEIGHT - y0;
}
- gpu_senquack.dma.FrameToRead = ((w0)&&(h0));
+ gpu_unai.dma.FrameToRead = ((w0)&&(h0));
- gpu_senquack.dma.px = 0;
- gpu_senquack.dma.py = 0;
- gpu_senquack.dma.x_end = w0;
- gpu_senquack.dma.y_end = h0;
- gpu_senquack.dma.pvram = &((u16*)gpu_senquack.vram)[x0+(y0*1024)];
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.py = 0;
+ gpu_unai.dma.x_end = w0;
+ gpu_unai.dma.y_end = h0;
+ gpu_unai.dma.pvram = &gpu_unai.vram[x0+(y0*1024)];
- gpu_senquack.GPU_GP1 |= 0x08000000;
+ gpu_unai.GPU_GP1 |= 0x08000000;
}
#endif // !USE_GPULIB
{
u32 x0, y0, x1, y1;
s32 w0, h0;
- x0 = packet.U2[2] & 1023;
- y0 = packet.U2[3] & 511;
- x1 = packet.U2[4] & 1023;
- y1 = packet.U2[5] & 511;
- w0 = packet.U2[6];
- h0 = packet.U2[7];
+ x0 = le16_to_u16(packet.U2[2]) & 1023;
+ y0 = le16_to_u16(packet.U2[3]) & 511;
+ x1 = le16_to_u16(packet.U2[4]) & 1023;
+ y1 = le16_to_u16(packet.U2[5]) & 511;
+ w0 = le16_to_u16(packet.U2[6]);
+ h0 = le16_to_u16(packet.U2[7]);
if( (x0==x1) && (y0==y1) ) return;
if ((w0<=0) || (h0<=0)) return;
if (((y0+h0)>512)||((x0+w0)>1024)||((y1+h0)>512)||((x1+w0)>1024))
{
- u16 *psxVuw=gpu_senquack.vram;
+ le16_t *psxVuw=gpu_unai.vram;
s32 i,j;
for(j=0;j<h0;j++)
for(i=0;i<w0;i++)
}
else if ((x0&1)||(x1&1))
{
- u16 *lpDst, *lpSrc;
- lpDst = lpSrc = (u16*)gpu_senquack.vram;
+ le16_t *lpDst, *lpSrc;
+ lpDst = lpSrc = gpu_unai.vram;
lpSrc += FRAME_OFFSET(x0, y0);
lpDst += FRAME_OFFSET(x1, y1);
x1 = FRAME_WIDTH - w0;
}
else
{
- u32 *lpDst, *lpSrc;
- lpDst = lpSrc = (u32*)(void*)gpu_senquack.vram;
+ le32_t *lpDst, *lpSrc;
+ lpDst = lpSrc = (le32_t *)gpu_unai.vram;
lpSrc += ((FRAME_OFFSET(x0, y0))>>1);
lpDst += ((FRAME_OFFSET(x1, y1))>>1);
if (w0&1)
w0>>=1;
if (!w0) {
do {
- *((u16*)lpDst) = *((u16*)lpSrc);
+ *((le16_t*)lpDst) = *((le16_t*)lpSrc);
lpDst += x1;
lpSrc += x1;
} while (--h0);
do {
x0=w0;
do { *lpDst++ = *lpSrc++; } while (--x0);
- *((u16*)lpDst) = *((u16*)lpSrc);
+ *((le16_t*)lpDst) = *((le16_t*)lpSrc);
lpDst += x1;
lpSrc += x1;
} while (--h0);
void gpuClearImage(PtrUnion packet)
{
s32 x0, y0, w0, h0;
- x0 = packet.S2[2];
- y0 = packet.S2[3];
- w0 = packet.S2[4] & 0x3ff;
- h0 = packet.S2[5] & 0x3ff;
-
+ x0 = le16_to_s16(packet.U2[2]);
+ y0 = le16_to_s16(packet.U2[3]);
+ w0 = le16_to_s16(packet.U2[4]) & 0x3ff;
+ h0 = le16_to_s16(packet.U2[5]) & 0x3ff;
+
w0 += x0;
if (x0 < 0) x0 = 0;
if (w0 > FRAME_WIDTH) w0 = FRAME_WIDTH;
#ifdef ENABLE_GPU_LOG_SUPPORT
fprintf(stdout,"gpuClearImage(x0=%d,y0=%d,w0=%d,h0=%d)\n",x0,y0,w0,h0);
#endif
-
+
if (x0&1)
{
- u16* pixel = (u16*)gpu_senquack.vram + FRAME_OFFSET(x0, y0);
- u16 rgb = GPU_RGB16(packet.U4[0]);
+ le16_t* pixel = gpu_unai.vram + FRAME_OFFSET(x0, y0);
+ le16_t rgb = u16_to_le16(GPU_RGB16(le32_to_u32(packet.U4[0])));
y0 = FRAME_WIDTH - w0;
do {
x0=w0;
}
else
{
- u32* pixel = (u32*)gpu_senquack.vram + ((FRAME_OFFSET(x0, y0))>>1);
- u32 rgb = GPU_RGB16(packet.U4[0]);
- rgb |= (rgb<<16);
+ le32_t* pixel = (le32_t*)gpu_unai.vram + ((FRAME_OFFSET(x0, y0))>>1);
+ u32 _rgb = GPU_RGB16(le32_to_u32(packet.U4[0]));
+ le32_t rgb = u32_to_le32(_rgb | (_rgb << 16));
if (w0&1)
{
y0 = (FRAME_WIDTH - w0 +1)>>1;
do {
x0=w0;
do { *pixel++ = rgb; } while (--x0);
- *((u16*)pixel) = (u16)rgb;
+ *((u16*)pixel) = (u16)le32_raw(rgb);
pixel += y0;
} while (--h0);
}
// Clip region: xmax/ymax seem to normally be one *past* the rightmost/
// bottommost pixels of the draw area. Since we render every pixel between
// and including both line endpoints, subtract one from xmax/ymax.
- const int xmin = gpu_senquack.DrawingArea[0];
- const int ymin = gpu_senquack.DrawingArea[1];
- const int xmax = gpu_senquack.DrawingArea[2] - 1;
- const int ymax = gpu_senquack.DrawingArea[3] - 1;
+ const int xmin = gpu_unai.DrawingArea[0];
+ const int ymin = gpu_unai.DrawingArea[1];
+ const int xmax = gpu_unai.DrawingArea[2] - 1;
+ const int ymax = gpu_unai.DrawingArea[3] - 1;
- x0 = GPU_EXPANDSIGN(packet.S2[2]) + gpu_senquack.DrawingOffset[0];
- y0 = GPU_EXPANDSIGN(packet.S2[3]) + gpu_senquack.DrawingOffset[1];
- x1 = GPU_EXPANDSIGN(packet.S2[4]) + gpu_senquack.DrawingOffset[0];
- y1 = GPU_EXPANDSIGN(packet.S2[5]) + gpu_senquack.DrawingOffset[1];
+ x0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[2])) + gpu_unai.DrawingOffset[0];
+ y0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[3])) + gpu_unai.DrawingOffset[1];
+ x1 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[4])) + gpu_unai.DrawingOffset[0];
+ y1 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[5])) + gpu_unai.DrawingOffset[1];
// Always draw top to bottom, so ensure y0 <= y1
if (y0 > y1) {
err_adjdown; // Subract this from err_term after drawing longer run
// Color to draw with (16 bits, highest of which is unset mask bit)
- uintptr_t col16 = GPU_RGB16(packet.U4[0]);
+ uintptr_t col16 = GPU_RGB16(le32_to_u32(packet.U4[0]));
- // We use u8 pointers even though PS1 has u16 framebuffer.
- // This allows pixel-drawing functions to increment dst pointer
- // directly by the passed 'incr' value, not having to shift it first.
- u8 *dst = (u8*)gpu_senquack.vram + y0 * dst_stride + x0 * dst_depth;
+ le16_t *dst = gpu_unai.vram + (y0 * dst_stride + x0 * dst_depth) / FRAME_BYTES_PER_PIXEL;
// SPECIAL CASE: Vertical line
if (dx == 0) {
// First run of pixels
dst = gpuPixelSpanDriver(dst, col16, incr_major, start_length);
- dst += incr_minor;
+ dst += incr_minor / 2;
// Middle runs of pixels
while (--minor > 0) {
}
dst = gpuPixelSpanDriver(dst, col16, incr_major, run_length);
- dst += incr_minor;
+ dst += incr_minor / 2;
}
// Final run of pixels
// Clip region: xmax/ymax seem to normally be one *past* the rightmost/
// bottommost pixels of the draw area. We'll render every pixel between
// and including both line endpoints, so subtract one from xmax/ymax.
- const int xmin = gpu_senquack.DrawingArea[0];
- const int ymin = gpu_senquack.DrawingArea[1];
- const int xmax = gpu_senquack.DrawingArea[2] - 1;
- const int ymax = gpu_senquack.DrawingArea[3] - 1;
+ const int xmin = gpu_unai.DrawingArea[0];
+ const int ymin = gpu_unai.DrawingArea[1];
+ const int xmax = gpu_unai.DrawingArea[2] - 1;
+ const int ymax = gpu_unai.DrawingArea[3] - 1;
- x0 = GPU_EXPANDSIGN(packet.S2[2]) + gpu_senquack.DrawingOffset[0];
- y0 = GPU_EXPANDSIGN(packet.S2[3]) + gpu_senquack.DrawingOffset[1];
- x1 = GPU_EXPANDSIGN(packet.S2[6]) + gpu_senquack.DrawingOffset[0];
- y1 = GPU_EXPANDSIGN(packet.S2[7]) + gpu_senquack.DrawingOffset[1];
+ x0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[2])) + gpu_unai.DrawingOffset[0];
+ y0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[3])) + gpu_unai.DrawingOffset[1];
+ x1 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[6])) + gpu_unai.DrawingOffset[0];
+ y1 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[7])) + gpu_unai.DrawingOffset[1];
- u32 col0 = packet.U4[0];
- u32 col1 = packet.U4[2];
+ u32 col0 = le32_to_u32(packet.U4[0]);
+ u32 col1 = le32_to_u32(packet.U4[2]);
// Always draw top to bottom, so ensure y0 <= y1
if (y0 > y1) {
gcol.g = g0 << GPU_GOURAUD_FIXED_BITS;
gcol.b = b0 << GPU_GOURAUD_FIXED_BITS;
- // We use u8 pointers even though PS1 has u16 framebuffer.
- // This allows pixel-drawing functions to increment dst pointer
- // directly by the passed 'incr' value, not having to shift it first.
- u8 *dst = (u8*)gpu_senquack.vram + y0 * dst_stride + x0 * dst_depth;
+ le16_t *dst = gpu_unai.vram + (y0 * dst_stride + x0 * dst_depth) / FRAME_BYTES_PER_PIXEL;
// SPECIAL CASE: Vertical line
if (dx == 0) {
if (db) gcol.b_incr /= dy;
}
#endif
-
+
gpuPixelSpanDriver(dst, (uintptr_t)&gcol, dst_stride, dy+1);
return;
}
// First run of pixels
dst = gpuPixelSpanDriver(dst, (uintptr_t)&gcol, incr_major, start_length);
- dst += incr_minor;
+ dst += incr_minor / 2;
// Middle runs of pixels
while (--minor > 0) {
}
dst = gpuPixelSpanDriver(dst, (uintptr_t)&gcol, incr_major, run_length);
- dst += incr_minor;
+ dst += incr_minor / 2;
}
// Final run of pixels
struct PolyVertex {
s32 x, y; // Sign-extended 11-bit X,Y coords
union {
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ struct { u8 pad[2], v, u; } tex; // Texture coords (if used)
+#else
struct { u8 u, v, pad[2]; } tex; // Texture coords (if used)
+#endif
u32 tex_word;
};
union {
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ struct { u8 pad, b, g, r; } col; // 24-bit RGB color (if used)
+#else
struct { u8 r, g, b, pad; } col; // 24-bit RGB color (if used)
+#endif
u32 col_word;
};
};
vert_stride++;
int num_verts = (is_quad) ? 4 : 3;
- u32 *ptr;
+ le32_t *ptr;
// X,Y coords, adjusted by draw offsets
- s32 x_off = gpu_senquack.DrawingOffset[0];
- s32 y_off = gpu_senquack.DrawingOffset[1];
+ s32 x_off = gpu_unai.DrawingOffset[0];
+ s32 y_off = gpu_unai.DrawingOffset[1];
ptr = &packet.U4[1];
for (int i=0; i < num_verts; ++i, ptr += vert_stride) {
- s16* coord_ptr = (s16*)ptr;
- vbuf[i].x = GPU_EXPANDSIGN(coord_ptr[0]) + x_off;
- vbuf[i].y = GPU_EXPANDSIGN(coord_ptr[1]) + y_off;
+ u32 coords = le32_to_u32(*ptr);
+ vbuf[i].x = GPU_EXPANDSIGN((s16)coords) + x_off;
+ vbuf[i].y = GPU_EXPANDSIGN((s16)(coords >> 16)) + y_off;
}
// U,V texture coords (if applicable)
if (texturing) {
ptr = &packet.U4[2];
for (int i=0; i < num_verts; ++i, ptr += vert_stride)
- vbuf[i].tex_word = *ptr;
+ vbuf[i].tex_word = le32_to_u32(*ptr);
}
// Colors (if applicable)
if (gouraud) {
ptr = &packet.U4[0];
for (int i=0; i < num_verts; ++i, ptr += vert_stride)
- vbuf[i].col_word = *ptr;
+ vbuf[i].col_word = le32_to_u32(*ptr);
}
}
// Determine if triangle is completely outside clipping range
int xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
int clipped_lowest_x = Max2(xmin,lowest_x);
int clipped_lowest_y = Max2(ymin,lowest_y);
int clipped_highest_x = Min2(xmax,highest_x);
void gpuDrawPolyF(const PtrUnion packet, const PP gpuPolySpanDriver, u32 is_quad)
{
// Set up bgr555 color to be used across calls in inner driver
- gpu_senquack.PixelData = GPU_RGB16(packet.U4[0]);
+ gpu_unai.PixelData = GPU_RGB16(le32_to_u32(packet.U4[0]));
PolyVertex vbuf[4];
polyInitVertexBuffer(vbuf, packet, POLYTYPE_F, is_quad);
}
s32 xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
if ((ymin - ya) > 0) {
x3 += (dx3 * (ymin - ya));
if (loop1 <= 0)
continue;
- u16* PixelBase = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(0, ya)];
- int li=gpu_senquack.ilace_mask;
- int pi=(ProgressiveInterlaceEnabled()?(gpu_senquack.ilace_mask+1):0);
- int pif=(ProgressiveInterlaceEnabled()?(gpu_senquack.prog_ilace_flag?(gpu_senquack.ilace_mask+1):0):1);
+ le16_t* PixelBase = &gpu_unai.vram[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
for (; loop1; --loop1, ya++, PixelBase += FRAME_WIDTH,
x3 += dx3, x4 += dx4 )
if ((xmin - xa) > 0) xa = xmin;
if (xb > xmax) xb = xmax;
if ((xb - xa) > 0)
- gpuPolySpanDriver(gpu_senquack, PixelBase + xa, (xb - xa));
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
}
} while (++cur_pass < total_passes);
void gpuDrawPolyFT(const PtrUnion packet, const PP gpuPolySpanDriver, u32 is_quad)
{
// r8/g8/b8 used if texture-blending & dithering is applied (24-bit light)
- gpu_senquack.r8 = packet.U1[0];
- gpu_senquack.g8 = packet.U1[1];
- gpu_senquack.b8 = packet.U1[2];
+ gpu_unai.r8 = packet.U1[0];
+ gpu_unai.g8 = packet.U1[1];
+ gpu_unai.b8 = packet.U1[2];
// r5/g5/b5 used if just texture-blending is applied (15-bit light)
- gpu_senquack.r5 = packet.U1[0] >> 3;
- gpu_senquack.g5 = packet.U1[1] >> 3;
- gpu_senquack.b5 = packet.U1[2] >> 3;
+ gpu_unai.r5 = packet.U1[0] >> 3;
+ gpu_unai.g5 = packet.U1[1] >> 3;
+ gpu_unai.b5 = packet.U1[2] >> 3;
PolyVertex vbuf[4];
polyInitVertexBuffer(vbuf, packet, POLYTYPE_FT, is_quad);
#endif
#endif
// Set u,v increments for inner driver
- gpu_senquack.u_inc = du4;
- gpu_senquack.v_inc = dv4;
+ gpu_unai.u_inc = du4;
+ gpu_unai.v_inc = dv4;
//senquack - TODO: why is it always going through 2 iterations when sometimes one would suffice here?
// (SAME ISSUE ELSEWHERE)
}
s32 xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
if ((ymin - ya) > 0) {
x3 += dx3 * (ymin - ya);
if (loop1 <= 0)
continue;
- u16* PixelBase = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(0, ya)];
- int li=gpu_senquack.ilace_mask;
- int pi=(ProgressiveInterlaceEnabled()?(gpu_senquack.ilace_mask+1):0);
- int pif=(ProgressiveInterlaceEnabled()?(gpu_senquack.prog_ilace_flag?(gpu_senquack.ilace_mask+1):0):1);
+ le16_t* PixelBase = &gpu_unai.vram[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
for (; loop1; --loop1, ++ya, PixelBase += FRAME_WIDTH,
x3 += dx3, x4 += dx4,
}
// Set u,v coords for inner driver
- gpu_senquack.u = u4;
- gpu_senquack.v = v4;
+ gpu_unai.u = u4;
+ gpu_unai.v = v4;
if (xb > xmax) xb = xmax;
if ((xb - xa) > 0)
- gpuPolySpanDriver(gpu_senquack, PixelBase + xa, (xb - xa));
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
}
} while (++cur_pass < total_passes);
#endif
#endif
// Setup packed Gouraud increment for inner driver
- gpu_senquack.gInc = gpuPackGouraudColInc(dr4, dg4, db4);
+ gpu_unai.gInc = gpuPackGouraudColInc(dr4, dg4, db4);
for (s32 loop0 = 2; loop0; loop0--) {
if (loop0 == 2) {
}
s32 xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
if ((ymin - ya) > 0) {
x3 += (dx3 * (ymin - ya));
if (loop1 <= 0)
continue;
- u16* PixelBase = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(0, ya)];
- int li=gpu_senquack.ilace_mask;
- int pi=(ProgressiveInterlaceEnabled()?(gpu_senquack.ilace_mask+1):0);
- int pif=(ProgressiveInterlaceEnabled()?(gpu_senquack.prog_ilace_flag?(gpu_senquack.ilace_mask+1):0):1);
+ le16_t* PixelBase = &gpu_unai.vram[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
for (; loop1; --loop1, ++ya, PixelBase += FRAME_WIDTH,
x3 += dx3, x4 += dx4,
}
// Setup packed Gouraud color for inner driver
- gpu_senquack.gCol = gpuPackGouraudCol(r4, g4, b4);
+ gpu_unai.gCol = gpuPackGouraudCol(r4, g4, b4);
if (xb > xmax) xb = xmax;
if ((xb - xa) > 0)
- gpuPolySpanDriver(gpu_senquack, PixelBase + xa, (xb - xa));
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
}
} while (++cur_pass < total_passes);
#endif
#endif
// Set u,v increments and packed Gouraud increment for inner driver
- gpu_senquack.u_inc = du4;
- gpu_senquack.v_inc = dv4;
- gpu_senquack.gInc = gpuPackGouraudColInc(dr4, dg4, db4);
+ gpu_unai.u_inc = du4;
+ gpu_unai.v_inc = dv4;
+ gpu_unai.gInc = gpuPackGouraudColInc(dr4, dg4, db4);
for (s32 loop0 = 2; loop0; loop0--) {
if (loop0 == 2) {
}
s32 xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
if ((ymin - ya) > 0) {
x3 += (dx3 * (ymin - ya));
if (loop1 <= 0)
continue;
- u16* PixelBase = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(0, ya)];
- int li=gpu_senquack.ilace_mask;
- int pi=(ProgressiveInterlaceEnabled()?(gpu_senquack.ilace_mask+1):0);
- int pif=(ProgressiveInterlaceEnabled()?(gpu_senquack.prog_ilace_flag?(gpu_senquack.ilace_mask+1):0):1);
+ le16_t* PixelBase = &gpu_unai.vram[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
for (; loop1; --loop1, ++ya, PixelBase += FRAME_WIDTH,
x3 += dx3, x4 += dx4,
}
// Set packed Gouraud color and u,v coords for inner driver
- gpu_senquack.u = u4;
- gpu_senquack.v = v4;
- gpu_senquack.gCol = gpuPackGouraudCol(r4, g4, b4);
+ gpu_unai.u = u4;
+ gpu_unai.v = v4;
+ gpu_unai.gCol = gpuPackGouraudCol(r4, g4, b4);
if (xb > xmax) xb = xmax;
if ((xb - xa) > 0)
- gpuPolySpanDriver(gpu_senquack, PixelBase + xa, (xb - xa));
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
}
} while (++cur_pass < total_passes);
//NOTE: Must 11-bit sign-extend the whole sum here, not just packet X/Y,
// or sprites in 1st level of SkullMonkeys disappear when walking right.
// This now matches behavior of Mednafen and PCSX Rearmed's gpu_neon:
- x0 = GPU_EXPANDSIGN(packet.S2[2] + gpu_senquack.DrawingOffset[0]);
- y0 = GPU_EXPANDSIGN(packet.S2[3] + gpu_senquack.DrawingOffset[1]);
+ x0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[2]) + gpu_unai.DrawingOffset[0]);
+ y0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[3]) + gpu_unai.DrawingOffset[1]);
- u32 w = packet.U2[6] & 0x3ff; // Max width is 1023
- u32 h = packet.U2[7] & 0x1ff; // Max height is 511
+ u32 w = le16_to_u16(packet.U2[6]) & 0x3ff; // Max width is 1023
+ u32 h = le16_to_u16(packet.U2[7]) & 0x1ff; // Max height is 511
x1 = x0 + w;
y1 = y0 + h;
s32 xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
u0 = packet.U1[8];
v0 = packet.U1[9];
x1 -= x0;
if (x1 <= 0) return;
- gpu_senquack.r5 = packet.U1[0] >> 3;
- gpu_senquack.g5 = packet.U1[1] >> 3;
- gpu_senquack.b5 = packet.U1[2] >> 3;
+ gpu_unai.r5 = packet.U1[0] >> 3;
+ gpu_unai.g5 = packet.U1[1] >> 3;
+ gpu_unai.b5 = packet.U1[2] >> 3;
- u16 *Pixel = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(x0, y0)];
- const int li=gpu_senquack.ilace_mask;
- const int pi=(ProgressiveInterlaceEnabled()?(gpu_senquack.ilace_mask+1):0);
- const int pif=(ProgressiveInterlaceEnabled()?(gpu_senquack.prog_ilace_flag?(gpu_senquack.ilace_mask+1):0):1);
- unsigned int tmode = gpu_senquack.TEXT_MODE >> 5;
- const u32 v0_mask = gpu_senquack.TextureWindow[3];
- u8* pTxt_base = (u8*)gpu_senquack.TBA;
+ le16_t *Pixel = &gpu_unai.vram[FRAME_OFFSET(x0, y0)];
+ const int li=gpu_unai.ilace_mask;
+ const int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ const int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+ unsigned int tmode = gpu_unai.TEXT_MODE >> 5;
+ const u32 v0_mask = gpu_unai.TextureWindow[3];
+ u8* pTxt_base = (u8*)gpu_unai.TBA;
// Texture is accessed byte-wise, so adjust idx if 16bpp
if (tmode == 3) u0 <<= 1;
//NOTE: Must 11-bit sign-extend the whole sum here, not just packet X/Y,
// or sprites in 1st level of SkullMonkeys disappear when walking right.
// This now matches behavior of Mednafen and PCSX Rearmed's gpu_neon:
- x0 = GPU_EXPANDSIGN(packet.S2[2] + gpu_senquack.DrawingOffset[0]);
- y0 = GPU_EXPANDSIGN(packet.S2[3] + gpu_senquack.DrawingOffset[1]);
+ x0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[2]) + gpu_unai.DrawingOffset[0]);
+ y0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[3]) + gpu_unai.DrawingOffset[1]);
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
u0 = packet.U1[8];
v0 = packet.U1[9];
if (x0 > xmax - 16 || x0 < xmin ||
- ((u0 | v0) & 15) || !(gpu_senquack.TextureWindow[2] & gpu_senquack.TextureWindow[3] & 8)) {
+ ((u0 | v0) & 15) || !(gpu_unai.TextureWindow[2] & gpu_unai.TextureWindow[3] & 8)) {
// send corner cases to general handler
- packet.U4[3] = 0x00100010;
+ packet.U4[3] = u32_to_le32(0x00100010);
gpuDrawS(packet, gpuSpriteSpanFn<0x20>);
return;
}
else if (ymax - y0 < 16)
h = ymax - y0;
- draw_spr16_full(&gpu_senquack.vram[FRAME_OFFSET(x0, y0)], &gpu_senquack.TBA[FRAME_OFFSET(u0/4, v0)], gpu_senquack.CBA, h);
+ draw_spr16_full(&gpu_unai.vram[FRAME_OFFSET(x0, y0)], &gpu_unai.TBA[FRAME_OFFSET(u0/4, v0)], gpu_unai.CBA, h);
}
#endif // __arm__
s32 x0, x1, y0, y1;
// This now matches behavior of Mednafen and PCSX Rearmed's gpu_neon:
- x0 = GPU_EXPANDSIGN(packet.S2[2] + gpu_senquack.DrawingOffset[0]);
- y0 = GPU_EXPANDSIGN(packet.S2[3] + gpu_senquack.DrawingOffset[1]);
+ x0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[2]) + gpu_unai.DrawingOffset[0]);
+ y0 = GPU_EXPANDSIGN(le16_to_s16(packet.U2[3]) + gpu_unai.DrawingOffset[1]);
- u32 w = packet.U2[4] & 0x3ff; // Max width is 1023
- u32 h = packet.U2[5] & 0x1ff; // Max height is 511
+ u32 w = le16_to_u16(packet.U2[4]) & 0x3ff; // Max width is 1023
+ u32 h = le16_to_u16(packet.U2[5]) & 0x1ff; // Max height is 511
x1 = x0 + w;
y1 = y0 + h;
s32 xmin, xmax, ymin, ymax;
- xmin = gpu_senquack.DrawingArea[0]; xmax = gpu_senquack.DrawingArea[2];
- ymin = gpu_senquack.DrawingArea[1]; ymax = gpu_senquack.DrawingArea[3];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
if (y0 < ymin) y0 = ymin;
if (y1 > ymax) y1 = ymax;
x1 -= x0;
if (x1 <= 0) return;
- const u16 Data = GPU_RGB16(packet.U4[0]);
- u16 *Pixel = &((u16*)gpu_senquack.vram)[FRAME_OFFSET(x0, y0)];
- const int li=gpu_senquack.ilace_mask;
- const int pi=(ProgressiveInterlaceEnabled()?(gpu_senquack.ilace_mask+1):0);
- const int pif=(ProgressiveInterlaceEnabled()?(gpu_senquack.prog_ilace_flag?(gpu_senquack.ilace_mask+1):0):1);
+ const u16 Data = GPU_RGB16(le32_to_u32(packet.U4[0]));
+ le16_t *Pixel = &gpu_unai.vram[FRAME_OFFSET(x0, y0)];
+ const int li=gpu_unai.ilace_mask;
+ const int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ const int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
for (; y0<y1; ++y0) {
if (!(y0&li) && (y0&pi)!=pif)
#include "gpu.h"
-// Header shared between both standalone gpu_senquack (gpu.cpp) and new
-// gpulib-compatible gpu_senquack (gpulib_if.cpp)
-// -> Anything here should be for gpu_senquack's private use. <-
+// Header shared between both standalone gpu_unai (gpu.cpp) and new
+// gpulib-compatible gpu_unai (gpulib_if.cpp)
+// -> Anything here should be for gpu_unai's private use. <-
///////////////////////////////////////////////////////////////////////////////
// Compile Options
#define s32 int32_t
#define s64 int64_t
+typedef struct {
+ u32 v;
+} le32_t;
+
+typedef struct {
+ u16 v;
+} le16_t;
+
+static inline u32 le32_to_u32(le32_t le)
+{
+ return LE32TOH(le.v);
+}
+
+static inline s32 le32_to_s32(le32_t le)
+{
+ return (int32_t) LE32TOH(le.v);
+}
+
+static inline u32 le32_raw(le32_t le)
+{
+ return le.v;
+}
+
+static inline le32_t u32_to_le32(u32 u)
+{
+ return (le32_t){ .v = HTOLE32(u) };
+}
+
+static inline u16 le16_to_u16(le16_t le)
+{
+ return LE16TOH(le.v);
+}
+
+static inline s16 le16_to_s16(le16_t le)
+{
+ return (int16_t) LE16TOH(le.v);
+}
+
+static inline u16 le16_raw(le16_t le)
+{
+ return le.v;
+}
+
+static inline le16_t u16_to_le16(u16 u)
+{
+ return (le16_t){ .v = HTOLE16(u) };
+}
+
union PtrUnion
{
- u32 *U4;
- s32 *S4;
- u16 *U2;
- s16 *S2;
+ le32_t *U4;
+ le16_t *U2;
u8 *U1;
- s8 *S1;
void *ptr;
};
union GPUPacket
{
- u32 U4[16];
- s32 S4[16];
- u16 U2[32];
- s16 S2[32];
+ le32_t U4[16];
+ le16_t U2[32];
u8 U1[64];
- s8 S1[64];
};
template<class T> static inline void SwapValues(T &x, T &y)
// 'Unsafe' version of above that doesn't check for div-by-zero
#define GPU_FAST_DIV(rs, rt) ((signed)(rs) / (signed)(rt))
-struct gpu_senquack_t {
+struct gpu_unai_t {
u32 GPU_GP1;
GPUPacket PacketBuffer;
- u16 *vram;
+ le16_t *vram;
+#ifdef USE_GPULIB
+ le16_t *downscale_vram;
+#endif
+ ////////////////////////////////////////////////////////////////////////////
+ // Variables used only by older standalone version of gpu_unai (gpu.cpp)
#ifndef USE_GPULIB
u32 GPU_GP0;
u32 tex_window; // Current texture window vals (set by GP0(E2h) cmd)
bool fb_dirty; // Framebuffer is dirty (according to GPU)
// Display status
- // NOTE: Standalone older gpu_senquack didn't care about horiz display range
+ // NOTE: Standalone older gpu_unai didn't care about horiz display range
u16 DisplayArea[6]; // [0] : Start of display area (in VRAM) X
// [1] : Start of display area (in VRAM) Y
// [2] : Display mode resolution HORIZONTAL
struct {
s32 px,py;
s32 x_end,y_end;
- u16* pvram;
+ le16_t* pvram;
u32 *last_dma; // Last dma pointer
bool FrameToRead; // Load image in progress
bool FrameToWrite; // Store image in progress
bool skipGPU; // Skip GPU primitives
} frameskip;
#endif
- // END of standalone gpu_senquack variables
+ // END of standalone gpu_unai variables
////////////////////////////////////////////////////////////////////////////
u32 TextureWindowCur; // Current setting from last GP0(0xE2) cmd (raw form)
s16 DrawingOffset[2]; // [0] : Drawing offset X (signed)
// [1] : Drawing offset Y (signed)
- u16* TBA; // Ptr to current texture in VRAM
- u16* CBA; // Ptr to current CLUT in VRAM
+ le16_t* TBA; // Ptr to current texture in VRAM
+ le16_t* CBA; // Ptr to current CLUT in VRAM
////////////////////////////////////////////////////////////////////////////
// Inner Loop parameters
u16 PixelMSB;
- gpu_senquack_config_t config;
+ gpu_unai_config_t config;
u8 LightLUT[32*32]; // 5-bit lighting LUT (gpu_inner_light.h)
u32 DitherMatrix[64]; // Matrix of dither coefficients
};
-static gpu_senquack_t gpu_senquack;
+static gpu_unai_t gpu_unai;
// Global config that frontend can alter.. Values are read in GPU_init().
// TODO: if frontend menu modifies a setting, add a function that can notify
// GPU plugin to use new setting.
-gpu_senquack_config_t gpu_senquack_config_ext;
+gpu_unai_config_t gpu_unai_config_ext;
///////////////////////////////////////////////////////////////////////////////
// Internal inline funcs to get option status: (Allows flexibility)
static inline bool LightingEnabled()
{
- return gpu_senquack.config.lighting;
+ return gpu_unai.config.lighting;
}
static inline bool FastLightingEnabled()
{
- return gpu_senquack.config.fast_lighting;
+ return gpu_unai.config.fast_lighting;
}
static inline bool BlendingEnabled()
{
- return gpu_senquack.config.blending;
+ return gpu_unai.config.blending;
}
static inline bool DitheringEnabled()
{
- return gpu_senquack.config.dithering;
+ return gpu_unai.config.dithering;
}
// For now, this is just for development/experimentation purposes..
// for now when using new gpulib, since it also adds more work in loops.
return false;
#else
- return gpu_senquack.config.prog_ilace;
+ return gpu_unai.config.prog_ilace;
#endif
}
// running on higher-res device or a resampling downscaler is enabled.
static inline bool PixelSkipEnabled()
{
- return gpu_senquack.config.pixel_skip || gpu_senquack.config.scale_hires;
+ return gpu_unai.config.pixel_skip || gpu_unai.config.scale_hires;
}
static inline bool LineSkipEnabled()
#include <string.h>
#include "../gpulib/gpu.h"
+#ifdef THREAD_RENDERING
+#include "../gpulib/gpulib_thread_if.h"
+#define do_cmd_list real_do_cmd_list
+#define renderer_init real_renderer_init
+#define renderer_finish real_renderer_finish
+#define renderer_sync_ecmds real_renderer_sync_ecmds
+#define renderer_update_caches real_renderer_update_caches
+#define renderer_flush_queues real_renderer_flush_queues
+#define renderer_set_interlace real_renderer_set_interlace
+#define renderer_set_config real_renderer_set_config
+#define renderer_notify_res_change real_renderer_notify_res_change
+#define renderer_notify_update_lace real_renderer_notify_update_lace
+#define renderer_sync real_renderer_sync
+#define ex_regs scratch_ex_regs
+#endif
+
//#include "port.h"
-#include "gpu_senquack.h"
+#include "gpu_unai.h"
// GPU fixed point math
#include "gpu_fixedpoint.h"
/////////////////////////////////////////////////////////////////////////////
+#define DOWNSCALE_VRAM_SIZE (1024 * 512 * 2 * 2 + 4096)
+
+INLINE void scale_640_to_320(le16_t *dest, const le16_t *src, bool isRGB24) {
+ size_t uCount = 320;
+
+ if(isRGB24) {
+ const uint8_t* src8 = (const uint8_t *)src;
+ uint8_t* dst8 = (uint8_t *)dest;
+
+ do {
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8;
+ src8 += 4;
+ } while(--uCount);
+ } else {
+ const le16_t* src16 = src;
+ le16_t* dst16 = dest;
+
+ do {
+ *dst16++ = *src16;
+ src16 += 2;
+ } while(--uCount);
+ }
+}
+
+INLINE void scale_512_to_320(le16_t *dest, const le16_t *src, bool isRGB24) {
+ size_t uCount = 64;
+
+ if(isRGB24) {
+ const uint8_t* src8 = (const uint8_t *)src;
+ uint8_t* dst8 = (uint8_t *)dest;
+
+ do {
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8;
+ src8 += 4;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8;
+ src8 += 4;
+ *dst8++ = *src8++;
+ *dst8++ = *src8++;
+ *dst8++ = *src8;
+ src8 += 4;
+ } while(--uCount);
+ } else {
+ const le16_t* src16 = src;
+ le16_t* dst16 = dest;
+
+ do {
+ *dst16++ = *src16++;
+ *dst16++ = *src16;
+ src16 += 2;
+ *dst16++ = *src16++;
+ *dst16++ = *src16;
+ src16 += 2;
+ *dst16++ = *src16;
+ src16 += 2;
+ } while(--uCount);
+ }
+}
+
+static uint16_t *get_downscale_buffer(int *x, int *y, int *w, int *h, int *vram_h)
+{
+ le16_t *dest = gpu_unai.downscale_vram;
+ const le16_t *src = gpu_unai.vram;
+ bool isRGB24 = (gpu_unai.GPU_GP1 & 0x00200000 ? true : false);
+ int stride = 1024, dstride = 1024, lines = *h, orig_w = *w;
+
+ // PS1 fb read wraps around (fixes black screen in 'Tobal no. 1')
+ unsigned int fb_mask = 1024 * 512 - 1;
+
+ if (*h > 240) {
+ *h /= 2;
+ stride *= 2;
+ lines = *h;
+
+ // Ensure start at a non-skipped line
+ while (*y & gpu_unai.ilace_mask) ++*y;
+ }
+
+ unsigned int fb_offset_src = (*y * dstride + *x) & fb_mask;
+ unsigned int fb_offset_dest = fb_offset_src;
+
+ if (*w == 512 || *w == 640) {
+ *w = 320;
+ }
+
+ switch(orig_w) {
+ case 640:
+ do {
+ scale_640_to_320(dest + fb_offset_dest, src + fb_offset_src, isRGB24);
+ fb_offset_src = (fb_offset_src + stride) & fb_mask;
+ fb_offset_dest = (fb_offset_dest + dstride) & fb_mask;
+ } while(--lines);
+
+ break;
+ case 512:
+ do {
+ scale_512_to_320(dest + fb_offset_dest, src + fb_offset_src, isRGB24);
+ fb_offset_src = (fb_offset_src + stride) & fb_mask;
+ fb_offset_dest = (fb_offset_dest + dstride) & fb_mask;
+ } while(--lines);
+ break;
+ default:
+ size_t size = isRGB24 ? *w * 3 : *w * 2;
+
+ do {
+ memcpy(dest + fb_offset_dest, src + fb_offset_src, size);
+ fb_offset_src = (fb_offset_src + stride) & fb_mask;
+ fb_offset_dest = (fb_offset_dest + dstride) & fb_mask;
+ } while(--lines);
+ break;
+ }
+
+ return (uint16_t *)gpu_unai.downscale_vram;
+}
+
+static void map_downscale_buffer(void)
+{
+ if (gpu_unai.downscale_vram)
+ return;
+
+ gpu_unai.downscale_vram = (le16_t*)gpu.mmap(DOWNSCALE_VRAM_SIZE);
+
+ if (gpu_unai.downscale_vram == NULL) {
+ fprintf(stderr, "failed to map downscale buffer\n");
+ gpu.get_downscale_buffer = NULL;
+ }
+ else {
+ gpu.get_downscale_buffer = get_downscale_buffer;
+ }
+}
+
+static void unmap_downscale_buffer(void)
+{
+ if (gpu_unai.downscale_vram == NULL)
+ return;
+
+ gpu.munmap(gpu_unai.downscale_vram, DOWNSCALE_VRAM_SIZE);
+ gpu_unai.downscale_vram = NULL;
+ gpu.get_downscale_buffer = NULL;
+}
+
int renderer_init(void)
{
- memset((void*)&gpu_senquack, 0, sizeof(gpu_senquack));
- gpu_senquack.vram = (u16*)gpu.vram;
+ memset((void*)&gpu_unai, 0, sizeof(gpu_unai));
+ gpu_unai.vram = (le16_t *)gpu.vram;
- // Original standalone gpu_senquack initialized TextureWindow[]. I added the
+ // Original standalone gpu_unai initialized TextureWindow[]. I added the
// same behavior here, since it seems unsafe to leave [2],[3] unset when
// using HLE and Rearmed gpu_neon sets this similarly on init. -senquack
- gpu_senquack.TextureWindow[0] = 0;
- gpu_senquack.TextureWindow[1] = 0;
- gpu_senquack.TextureWindow[2] = 255;
- gpu_senquack.TextureWindow[3] = 255;
+ gpu_unai.TextureWindow[0] = 0;
+ gpu_unai.TextureWindow[1] = 0;
+ gpu_unai.TextureWindow[2] = 255;
+ gpu_unai.TextureWindow[3] = 255;
//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_senquack.u_msk = (((u32)gpu_senquack.TextureWindow[2]) << fb) | ((1 << fb) - 1);
- gpu_senquack.v_msk = (((u32)gpu_senquack.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+ 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);
// Configuration options
- gpu_senquack.config = gpu_senquack_config_ext;
+ gpu_unai.config = gpu_unai_config_ext;
//senquack - disabled, not sure this is needed and would require modifying
// sprite-span functions, perhaps unnecessarily. No Abe Oddysey hack was
// present in latest PCSX4ALL sources we were using.
- //gpu_senquack.config.enableAbbeyHack = gpu_senquack_config_ext.abe_hack;
- gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
+ //gpu_unai.config.enableAbbeyHack = gpu_unai_config_ext.abe_hack;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
// s_invTable
SetupLightLUT();
SetupDitheringConstants();
+ if (gpu_unai.config.scale_hires) {
+ map_downscale_buffer();
+ }
+
return 0;
}
void renderer_finish(void)
{
+ unmap_downscale_buffer();
}
void renderer_notify_res_change(void)
switch (gpu.screen.hres)
{
- case 512: gpu_senquack.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
- case 640: gpu_senquack.blit_mask = 0xaa; break; // GPU_BlitWS
- default: gpu_senquack.blit_mask = 0; break;
+ case 512: gpu_unai.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
+ case 640: gpu_unai.blit_mask = 0xaa; break; // GPU_BlitWS
+ default: gpu_unai.blit_mask = 0; break;
}
} else {
- gpu_senquack.blit_mask = 0;
+ gpu_unai.blit_mask = 0;
}
if (LineSkipEnabled()) {
// 480 vertical mode, or, optionally, force it for all video modes)
if (gpu.screen.vres == 480) {
- if (gpu_senquack.config.ilace_force) {
- gpu_senquack.ilace_mask = 3; // Only need 1/4 of lines
+ if (gpu_unai.config.ilace_force) {
+ gpu_unai.ilace_mask = 3; // Only need 1/4 of lines
} else {
- gpu_senquack.ilace_mask = 1; // Only need 1/2 of lines
+ gpu_unai.ilace_mask = 1; // Only need 1/2 of lines
}
} else {
// Vert resolution changed from 480 to lower one
- gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
}
} else {
- gpu_senquack.ilace_mask = 0;
+ gpu_unai.ilace_mask = 0;
}
/*
printf("res change hres: %d vres: %d depth: %d ilace_mask: %d\n",
- gpu.screen.hres, gpu.screen.vres, gpu.status.rgb24 ? 24 : 15,
- gpu_senquack.ilace_mask);
+ gpu.screen.hres, gpu.screen.vres, (gpu.status & PSX_GPU_STATUS_RGB24) ? 24 : 15,
+ gpu_unai.ilace_mask);
*/
}
#ifdef USE_GPULIB
// Handles GP0 draw settings commands 0xE1...0xE6
-static void gpuGP0Cmd_0xEx(gpu_senquack_t &gpu_senquack, u32 cmd_word)
+static void gpuGP0Cmd_0xEx(gpu_unai_t &gpu_unai, u32 cmd_word)
{
// Assume incoming GP0 command is 0xE1..0xE6, convert to 1..6
u8 num = (cmd_word >> 24) & 7;
switch (num) {
case 1: {
// GP0(E1h) - Draw Mode setting (aka "Texpage")
- u32 cur_texpage = gpu_senquack.GPU_GP1 & 0x7FF;
+ u32 cur_texpage = gpu_unai.GPU_GP1 & 0x7FF;
u32 new_texpage = cmd_word & 0x7FF;
if (cur_texpage != new_texpage) {
- gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x7FF) | new_texpage;
- gpuSetTexture(gpu_senquack.GPU_GP1);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x7FF) | new_texpage;
+ gpuSetTexture(gpu_unai.GPU_GP1);
}
} break;
case 2: {
// GP0(E2h) - Texture Window setting
- if (cmd_word != gpu_senquack.TextureWindowCur) {
+ if (cmd_word != gpu_unai.TextureWindowCur) {
static const u8 TextureMask[32] = {
255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7,
127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7
};
- gpu_senquack.TextureWindowCur = cmd_word;
- gpu_senquack.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
- gpu_senquack.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
- gpu_senquack.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
- gpu_senquack.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
- gpu_senquack.TextureWindow[0] &= ~gpu_senquack.TextureWindow[2];
- gpu_senquack.TextureWindow[1] &= ~gpu_senquack.TextureWindow[3];
+ gpu_unai.TextureWindowCur = cmd_word;
+ gpu_unai.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
+ gpu_unai.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
+ gpu_unai.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
+ gpu_unai.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
+ gpu_unai.TextureWindow[0] &= ~gpu_unai.TextureWindow[2];
+ gpu_unai.TextureWindow[1] &= ~gpu_unai.TextureWindow[3];
// Inner loop vars must be updated whenever texture window is changed:
const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
- gpu_senquack.u_msk = (((u32)gpu_senquack.TextureWindow[2]) << fb) | ((1 << fb) - 1);
- gpu_senquack.v_msk = (((u32)gpu_senquack.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+ 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);
- gpuSetTexture(gpu_senquack.GPU_GP1);
+ gpuSetTexture(gpu_unai.GPU_GP1);
}
} break;
case 3: {
// GP0(E3h) - Set Drawing Area top left (X1,Y1)
- gpu_senquack.DrawingArea[0] = cmd_word & 0x3FF;
- gpu_senquack.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
+ gpu_unai.DrawingArea[0] = cmd_word & 0x3FF;
+ gpu_unai.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
} break;
case 4: {
// GP0(E4h) - Set Drawing Area bottom right (X2,Y2)
- gpu_senquack.DrawingArea[2] = (cmd_word & 0x3FF) + 1;
- gpu_senquack.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
+ gpu_unai.DrawingArea[2] = (cmd_word & 0x3FF) + 1;
+ gpu_unai.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
} break;
case 5: {
// GP0(E5h) - Set Drawing Offset (X,Y)
- gpu_senquack.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
- gpu_senquack.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
+ gpu_unai.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
+ gpu_unai.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
} break;
case 6: {
// GP0(E6h) - Mask Bit Setting
- gpu_senquack.Masking = (cmd_word & 0x2) << 1;
- gpu_senquack.PixelMSB = (cmd_word & 0x1) << 8;
+ gpu_unai.Masking = (cmd_word & 0x2) << 1;
+ gpu_unai.PixelMSB = (cmd_word & 0x1) << 8;
} break;
}
}
extern const unsigned char cmd_lengths[256];
-int do_cmd_list(u32 *list, int list_len, int *last_cmd)
+int do_cmd_list(u32 *_list, int list_len, int *last_cmd)
{
u32 cmd = 0, len, i;
- u32 *list_start = list;
- u32 *list_end = list + list_len;
+ le32_t *list = (le32_t *)_list;
+ le32_t *list_start = list;
+ le32_t *list_end = list + list_len;
//TODO: set ilace_mask when resolution changes instead of every time,
// eliminate #ifdef below.
- gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
#ifdef HAVE_PRE_ARMV7 /* XXX */
- gpu_senquack.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE);
+ gpu_unai.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE);
#endif
- if (gpu_senquack.config.scale_hires) {
- gpu_senquack.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE);
+ if (gpu_unai.config.scale_hires) {
+ gpu_unai.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE);
}
for (; list < list_end; list += 1 + len)
{
- cmd = *list >> 24;
+ cmd = le32_to_u32(*list) >> 24;
len = cmd_lengths[cmd];
if (list + 1 + len > list_end) {
cmd = -1;
}
#define PRIM cmd
- gpu_senquack.PacketBuffer.U4[0] = list[0];
+ gpu_unai.PacketBuffer.U4[0] = list[0];
for (i = 1; i <= len; i++)
- gpu_senquack.PacketBuffer.U4[i] = list[i];
+ gpu_unai.PacketBuffer.U4[i] = list[i];
- PtrUnion packet = { .ptr = (void*)&gpu_senquack.PacketBuffer };
+ PtrUnion packet = { .ptr = (void*)&gpu_unai.PacketBuffer };
switch (cmd)
{
case 0x22:
case 0x23: { // Monochrome 3-pt poly
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Blending_Mode |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
];
gpuDrawPolyF(packet, driver, false);
} break;
case 0x25:
case 0x26:
case 0x27: { // Textured 3-pt poly
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture(gpu_senquack.PacketBuffer.U4[4] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture(le32_to_u32(gpu_unai.PacketBuffer.U4[4]) >> 16);
u32 driver_idx =
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB;
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
if (!FastLightingEnabled()) {
driver_idx |= Lighting;
} else {
- if (!((gpu_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F)))
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
driver_idx |= Lighting;
}
case 0x2A:
case 0x2B: { // Monochrome 4-pt poly
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Blending_Mode |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
];
gpuDrawPolyF(packet, driver, true); // is_quad = true
} break;
case 0x2D:
case 0x2E:
case 0x2F: { // Textured 4-pt poly
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture(gpu_senquack.PacketBuffer.U4[4] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture(le32_to_u32(gpu_unai.PacketBuffer.U4[4]) >> 16);
u32 driver_idx =
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | gpu_senquack.PixelMSB;
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
if (!FastLightingEnabled()) {
driver_idx |= Lighting;
} else {
- if (!((gpu_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F)))
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
driver_idx |= Lighting;
}
// shouldn't apply. Until the original array of template
// instantiation ptrs is fixed, we're stuck with this. (TODO)
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
Blending_Mode |
- gpu_senquack.Masking | Blending | 129 | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
];
gpuDrawPolyG(packet, driver, false);
} break;
case 0x35:
case 0x36:
case 0x37: { // Gouraud-shaded, textured 3-pt poly
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture (gpu_senquack.PacketBuffer.U4[5] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16);
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | ((Lighting)?129:0) | gpu_senquack.PixelMSB
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
];
gpuDrawPolyGT(packet, driver, false);
} break;
case 0x3B: { // Gouraud-shaded 4-pt poly
// See notes regarding '129' for 0x30..0x33 further above -senquack
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
Blending_Mode |
- gpu_senquack.Masking | Blending | 129 | gpu_senquack.PixelMSB
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
];
gpuDrawPolyG(packet, driver, true); // is_quad = true
} break;
case 0x3D:
case 0x3E:
case 0x3F: { // Gouraud-shaded, textured 4-pt poly
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- gpuSetTexture (gpu_senquack.PacketBuffer.U4[5] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
+ gpuSetTexture (le32_to_u32(gpu_unai.PacketBuffer.U4[5]) >> 16);
PP driver = gpuPolySpanDrivers[
- (gpu_senquack.blit_mask?1024:0) |
+ (gpu_unai.blit_mask?1024:0) |
Dithering |
- Blending_Mode | gpu_senquack.TEXT_MODE |
- gpu_senquack.Masking | Blending | ((Lighting)?129:0) | gpu_senquack.PixelMSB
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
];
gpuDrawPolyGT(packet, driver, true); // is_quad = true
} break;
case 0x42:
case 0x43: { // Monochrome line
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
PSD driver = gpuPixelSpanDrivers[driver_idx];
gpuDrawLineF(packet, driver);
} break;
case 0x48 ... 0x4F: { // Monochrome line strip
u32 num_vertexes = 1;
- u32 *list_position = &(list[2]);
+ le32_t *list_position = &list[2];
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
PSD driver = gpuPixelSpanDrivers[driver_idx];
gpuDrawLineF(packet, driver);
while(1)
{
- gpu_senquack.PacketBuffer.U4[1] = gpu_senquack.PacketBuffer.U4[2];
- gpu_senquack.PacketBuffer.U4[2] = *list_position++;
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[2] = *list_position++;
gpuDrawLineF(packet, driver);
num_vertexes++;
cmd = -1;
goto breakloop;
}
- if((*list_position & 0xf000f000) == 0x50005000)
+ if((le32_raw(*list_position) & HTOLE32(0xf000f000)) == HTOLE32(0x50005000))
break;
}
case 0x52:
case 0x53: { // Gouraud-shaded line
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
// Index MSB selects Gouraud-shaded PixelSpanDriver:
driver_idx |= (1 << 5);
PSD driver = gpuPixelSpanDrivers[driver_idx];
case 0x58 ... 0x5F: { // Gouraud-shaded line strip
u32 num_vertexes = 1;
- u32 *list_position = &(list[2]);
+ le32_t *list_position = &list[2];
// Shift index right by one, as untextured prims don't use lighting
- u32 driver_idx = (Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1;
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
// Index MSB selects Gouraud-shaded PixelSpanDriver:
driver_idx |= (1 << 5);
PSD driver = gpuPixelSpanDrivers[driver_idx];
while(1)
{
- gpu_senquack.PacketBuffer.U4[0] = gpu_senquack.PacketBuffer.U4[2];
- gpu_senquack.PacketBuffer.U4[1] = gpu_senquack.PacketBuffer.U4[3];
- gpu_senquack.PacketBuffer.U4[2] = *list_position++;
- gpu_senquack.PacketBuffer.U4[3] = *list_position++;
+ gpu_unai.PacketBuffer.U4[0] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[3];
+ gpu_unai.PacketBuffer.U4[2] = *list_position++;
+ gpu_unai.PacketBuffer.U4[3] = *list_position++;
gpuDrawLineG(packet, driver);
num_vertexes++;
cmd = -1;
goto breakloop;
}
- if((*list_position & 0xf000f000) == 0x50005000)
+ if((le32_raw(*list_position) & HTOLE32(0xf000f000)) == HTOLE32(0x50005000))
break;
}
case 0x61:
case 0x62:
case 0x63: { // Monochrome rectangle (variable size)
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
gpuDrawT(packet, driver);
} break;
case 0x65:
case 0x66:
case 0x67: { // Textured rectangle (variable size)
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- u32 driver_idx = Blending_Mode | gpu_senquack.TEXT_MODE | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>1);
+ 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_senquack uses a simple lighting LUT whereby only the upper
+ // 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_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F))
+ //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 ((gpu_senquack.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080))
driver_idx |= Lighting;
PS driver = gpuSpriteSpanDrivers[driver_idx];
gpuDrawS(packet, driver);
case 0x69:
case 0x6A:
case 0x6B: { // Monochrome rectangle (1x1 dot)
- gpu_senquack.PacketBuffer.U4[2] = 0x00010001;
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ 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);
} break;
case 0x71:
case 0x72:
case 0x73: { // Monochrome rectangle (8x8)
- gpu_senquack.PacketBuffer.U4[2] = 0x00080008;
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ 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);
} break;
case 0x75:
case 0x76:
case 0x77: { // Textured rectangle (8x8)
- gpu_senquack.PacketBuffer.U4[3] = 0x00080008;
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- u32 driver_idx = Blending_Mode | gpu_senquack.TEXT_MODE | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>1);
+ 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_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F))
+ //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 ((gpu_senquack.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080))
driver_idx |= Lighting;
PS driver = gpuSpriteSpanDrivers[driver_idx];
gpuDrawS(packet, driver);
case 0x79:
case 0x7A:
case 0x7B: { // Monochrome rectangle (16x16)
- gpu_senquack.PacketBuffer.U4[2] = 0x00100010;
- PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>3)) >> 1];
+ 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);
} break;
case 0x7C:
case 0x7D:
#ifdef __arm__
- if ((gpu_senquack.GPU_GP1 & 0x180) == 0 && (gpu_senquack.Masking | gpu_senquack.PixelMSB) == 0)
+ if ((gpu_unai.GPU_GP1 & 0x180) == 0 && (gpu_unai.Masking | gpu_unai.PixelMSB) == 0)
{
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
+ gpuSetCLUT (le32_to_u32(gpu_unai.PacketBuffer.U4[2]) >> 16);
gpuDrawS16(packet);
break;
}
#endif
case 0x7E:
case 0x7F: { // Textured rectangle (16x16)
- gpu_senquack.PacketBuffer.U4[3] = 0x00100010;
- gpuSetCLUT (gpu_senquack.PacketBuffer.U4[2] >> 16);
- u32 driver_idx = Blending_Mode | gpu_senquack.TEXT_MODE | gpu_senquack.Masking | Blending | (gpu_senquack.PixelMSB>>1);
+ 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_senquack.PacketBuffer.U1[0]>0x5F) && (gpu_senquack.PacketBuffer.U1[1]>0x5F) && (gpu_senquack.PacketBuffer.U1[2]>0x5F))
+ //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 ((gpu_senquack.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ if ((le32_raw(gpu_unai.PacketBuffer.U4[0]) & HTOLE32(0xF8F8F8)) != HTOLE32(0x808080))
driver_idx |= Lighting;
PS driver = gpuSpriteSpanDrivers[driver_idx];
gpuDrawS(packet, driver);
goto breakloop;
#endif
case 0xE1 ... 0xE6: { // Draw settings
- gpuGP0Cmd_0xEx(gpu_senquack, gpu_senquack.PacketBuffer.U4[0]);
+ gpuGP0Cmd_0xEx(gpu_unai, le32_to_u32(gpu_unai.PacketBuffer.U4[0]));
} break;
}
}
breakloop:
gpu.ex_regs[1] &= ~0x1ff;
- gpu.ex_regs[1] |= gpu_senquack.GPU_GP1 & 0x1ff;
+ gpu.ex_regs[1] |= gpu_unai.GPU_GP1 & 0x1ff;
*last_cmd = cmd;
return list - list_start;
}
-void renderer_sync_ecmds(uint32_t *ecmds)
+void renderer_sync_ecmds(u32 *ecmds)
{
int dummy;
do_cmd_list(&ecmds[1], 6, &dummy);
}
#include "../../frontend/plugin_lib.h"
-// Handle any gpulib settings applicable to gpu_senquack:
+// Handle any gpulib settings applicable to gpu_unai:
void renderer_set_config(const struct rearmed_cbs *cbs)
{
- gpu_senquack.vram = (u16*)gpu.vram;
- gpu_senquack.config.ilace_force = cbs->gpu_unai.ilace_force;
- gpu_senquack.config.pixel_skip = cbs->gpu_unai.pixel_skip;
- gpu_senquack.config.lighting = cbs->gpu_unai.lighting;
- gpu_senquack.config.fast_lighting = cbs->gpu_unai.fast_lighting;
- gpu_senquack.config.blending = cbs->gpu_unai.blending;
- gpu_senquack.config.dithering = cbs->gpu_unai.dithering;
- gpu_senquack.config.scale_hires = cbs->gpu_unai.scale_hires;
+ gpu_unai.vram = (le16_t *)gpu.vram;
+ 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.state.downscale_enable = gpu_unai.config.scale_hires;
+ if (gpu_unai.config.scale_hires) {
+ map_downscale_buffer();
+ } else {
+ unmap_downscale_buffer();
+ }
+}
+
+void renderer_sync(void)
+{
+}
+
+void renderer_notify_update_lace(int updated)
+{
}
// vim:shiftwidth=2:expandtab
uint32_t enhancement_enable:1;
uint32_t enhancement_active:1;
uint32_t enhancement_was_active:1;
+ uint32_t downscale_enable:1;
+ uint32_t downscale_active:1;
uint32_t dims_changed:1;
uint32_t *frame_count;
uint32_t *hcnt; /* hsync count */
} frameskip;
void *(*get_enhancement_bufer)
(int *x, int *y, int *w, int *h, int *vram_h);
+ uint16_t *(*get_downscale_buffer)
+ (int *x, int *y, int *w, int *h, int *vram_h);
void *(*mmap)(unsigned int size);
void (*munmap)(void *ptr, unsigned int size);
void (*gpu_state_change)(int what); // psx_gpu_state
notaz.gp2x.de / pcsx_rearmed.git / commitdiff