//#include "gpuStdafx.h"\r
\r
//#include <mmsystem.h>\r
-\r
#define _IN_GPU\r
\r
-#ifdef _WINDOWS\r
-#include "stdafx.h"\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <stdarg.h>\r
-#include <string.h>\r
-#include <mmsystem.h>\r
-\r
-#include "externals.h"\r
-#include "gpu.h"\r
-#include "draw.h"\r
-#include "prim.h"\r
-#include "texture.h"\r
-#include "fps.h"\r
-#include "resource.h"\r
-#else\r
#include <stdlib.h>\r
#include <stdio.h>\r
#include <stdarg.h>\r
//#include "NoPic.h"\r
\r
#include "gpuStdafx.h"\r
-#endif\r
\r
-extern void ProcessEvents();\r
- \r
short g_m1=255,g_m2=255,g_m3=255;\r
short DrawSemiTrans=FALSE;\r
short Ymin;\r
// memory image of the PSX vram\r
////////////////////////////////////////////////////////////////////////\r
\r
-u8 *psxVSecure;\r
-u8 *psxVub;\r
+unsigned char *psxVSecure;\r
+unsigned char *psxVub;\r
signed char *psxVsb;\r
unsigned short *psxVuw;\r
unsigned short *psxVuw_eom;\r
BOOL bNeedRGB24Update=FALSE;\r
BOOL bChangeWinMode=FALSE;\r
\r
-#ifdef _WINDOWS\r
-extern HGLRC GLCONTEXT;\r
-#endif\r
-\r
unsigned long ulStatusControl[256];\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
static long GPUdataRet;\r
long lGPUstatusRet;\r
-s8 szDispBuf[64];\r
+char szDispBuf[64];\r
\r
static unsigned long gpuDataM[256];\r
-static u8 gpuCommand = 0;\r
+static unsigned char gpuCommand = 0;\r
static long gpuDataC = 0;\r
static long gpuDataP = 0;\r
\r
GLuint uiScanLine=0;\r
int iUseScanLines=0;\r
long lSelectedSlot=0;\r
-u8 * pGfxCardScreen=0;\r
+unsigned char * pGfxCardScreen=0;\r
int iBlurBuffer=0;\r
int iScanBlend=0;\r
int iRenderFVR=0;\r
int iRumbleVal = 0;\r
int iRumbleTime = 0;\r
\r
+static void (*rearmed_get_layer_pos)(int *x, int *y, int *w, int *h);\r
+static void flipEGL(void);\r
+\r
////////////////////////////////////////////////////////////////////////\r
// stuff to make this a true PDK module\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-s8 * CALLBACK PSEgetLibName(void)\r
-{\r
- return "name";\r
-}\r
-\r
-unsigned long CALLBACK PSEgetLibType(void)\r
-{\r
- return 1;\r
-}\r
-\r
-unsigned long CALLBACK PSEgetLibVersion(void)\r
-{\r
- return 1<<16|1<<8|1;\r
-}\r
-#endif\r
-\r
////////////////////////////////////////////////////////////////////////\r
// snapshot funcs (saves screen to bitmap / text infos into file)\r
////////////////////////////////////////////////////////////////////////\r
glViewport(rRatioRect.left, // init viewport by ratio rect\r
iResY-(rRatioRect.top+rRatioRect.bottom),\r
rRatioRect.right, \r
- rRatioRect.bottom); \r
+ rRatioRect.bottom); glError();\r
\r
- glScissor(0, 0, iResX, iResY); // init clipping (fullscreen)\r
- glEnable(GL_SCISSOR_TEST); \r
+ glScissor(0, 0, iResX, iResY); glError(); // init clipping (fullscreen)\r
+ glEnable(GL_SCISSOR_TEST); glError();\r
\r
#ifndef OWNSCALE\r
glMatrixMode(GL_TEXTURE); // init psx tex sow and tow if not "ownscale"\r
glScalef(1.0f/255.99f,1.0f/255.99f,1.0f); // geforce precision hack\r
#endif \r
\r
- glMatrixMode(GL_PROJECTION); // init projection with psx resolution\r
- glLoadIdentity();\r
+ glMatrixMode(GL_PROJECTION); glError(); // init projection with psx resolution\r
+ glLoadIdentity(); glError();\r
glOrtho(0,PSXDisplay.DisplayMode.x,\r
- PSXDisplay.DisplayMode.y, 0, -1, 1);\r
+ PSXDisplay.DisplayMode.y, 0, -1, 1); glError();\r
if (bKeepRatio)\r
SetAspectRatio();\r
}\r
\r
-s8 * GetConfigInfos(int hW)\r
+char * GetConfigInfos(int hW)\r
{\r
-#ifdef _WINDOWS\r
- HDC hdc;HGLRC hglrc;\r
-#endif\r
- s8 szO[2][4]={"off","on "};\r
- s8 szTxt[256];\r
- s8 * pB=(s8 *)malloc(32767);\r
+ char szO[2][4]={"off","on "};\r
+ char szTxt[256];\r
+ char * pB=(char *)malloc(32767);\r
/*\r
if(!pB) return NULL;\r
*pB=0;\r
strcat(pB,szTxt);\r
sprintf(szTxt,"OGL version: %s\r\n\r\n",(char *)glGetString(GL_VERSION));\r
strcat(pB,szTxt);\r
- //strcat(pB,(s8 *)glGetString(GL_EXTENSIONS));\r
+ //strcat(pB,(char *)glGetString(GL_EXTENSIONS));\r
//strcat(pB,"\r\n\r\n");\r
\r
#ifdef _WINDOWS\r
{\r
} \r
\r
-#ifdef _WINDOWS\r
void CALLBACK GPUmakeSnapshot(void)\r
-#else\r
-void CALLBACK GPUmakeSnapshot(void)\r
-#endif\r
{\r
//bSnapShot = TRUE;\r
} \r
// GPU INIT... here starts it all (first func called by emu)\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
long CALLBACK GPUinit()\r
-#else\r
-long CALLBACK GPUinit()\r
-#endif\r
{\r
memset(ulStatusControl,0,256*sizeof(unsigned long));\r
\r
-#ifdef _WINDOWS\r
-iResX=240;iResY=320;\r
-#endif\r
bChangeRes=FALSE;\r
-#ifdef _WINDOWS\r
-bWindowMode=TRUE;\r
-#else\r
bWindowMode=FALSE;\r
-#endif \r
-#ifdef _WINDOWS\r
-iWinSize=MAKELONG(iResX,iResY);\r
-#endif\r
\r
bKeepRatio = TRUE;\r
// different ways of accessing PSX VRAM\r
\r
-psxVSecure=(u8 *)malloc((iGPUHeight*2)*1024 + (1024*1024)); // always alloc one extra MB for soft drawing funcs security\r
+psxVSecure=(unsigned char *)malloc((iGPUHeight*2)*1024 + (1024*1024)); // always alloc one extra MB for soft drawing funcs security\r
if(!psxVSecure) return -1;\r
\r
psxVub=psxVSecure+512*1024; // security offset into double sized psx vram!\r
} \r
\r
\r
-////////////////////////////////////////////////////////////////////////\r
-// GPU OPEN: funcs to open up the gpu display (Windows)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-#ifdef _WINDOWS\r
-\r
-void ChangeDesktop() // change destop resolution\r
-{\r
- DEVMODE dv;long lRes,iTry=0; \r
-\r
- while(iTry<10) // keep on hammering...\r
- {\r
- memset(&dv,0,sizeof(DEVMODE));\r
- dv.dmSize=sizeof(DEVMODE);\r
- dv.dmBitsPerPel=iColDepth;\r
- dv.dmPelsWidth=iResX;\r
- dv.dmPelsHeight=iResY;\r
-\r
- dv.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;\r
-\r
- lRes=ChangeDisplaySettings(&dv,0); // ...hammering the anvil\r
-\r
- if(lRes==DISP_CHANGE_SUCCESSFUL) return;\r
- iTry++;Sleep(10);\r
- }\r
-}\r
-\r
////////////////////////////////////////////////////////////////////////\r
// OPEN interface func: attention! \r
// some emus are calling this func in their main Window thread,\r
// some PAD or SPU plugins would not work anymore)\r
////////////////////////////////////////////////////////////////////////\r
\r
-HMENU hPSEMenu=NULL;\r
-\r
-long CALLBACK GPUopen(HWND hwndGPU) \r
-#else\r
long CALLBACK GPUopen(int hwndGPU)\r
-#endif\r
{\r
- #ifdef _WINDOWS\r
- HDC hdc;RECT r;DEVMODE dv;\r
-\r
- hWWindow = hwndGPU; // store hwnd globally\r
- #endif\r
- // InitKeyHandler(); // init key handler (subclass window)\r
-\r
-\r
-\r
- #ifdef _WINDOWS\r
- iResX=240;iResY=320;\r
- #endif\r
-#ifdef MAEMO_CHANGES\r
- iResX=640;iResY=480;\r
-#endif\r
+ iResX=800;iResY=480;\r
iColDepth=8;\r
bChangeRes=FALSE;\r
- #ifdef _WINDOWS\r
- bWindowMode=TRUE;\r
- #else\r
bWindowMode=FALSE;\r
- #endif \r
bFullVRam=FALSE;\r
iFilterType=0;\r
// bAdvancedBlend=FALSE;\r
//bOpaquePass=FALSE;\r
//bUseAntiAlias=FALSE;\r
//iTexQuality=0;\r
- #ifdef _WINDOWS\r
- iWinSize=MAKELONG(iResX,iResY);\r
- #endif\r
iUseMask=0;\r
iZBufferDepth=0;\r
bUseFastMdec=FALSE;\r
\r
\r
\r
-#ifdef _WINDOWS\r
- memset(&dv,0,sizeof(DEVMODE));\r
- dv.dmSize=sizeof(DEVMODE);\r
- EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&dv);\r
-#endif\r
bIsFirstFrame = TRUE; // flag: we have to init OGL later in windows!\r
\r
-#ifdef _WINDOWS\r
- if(bWindowMode) // win mode?\r
- {\r
- DWORD dw=GetWindowLong(hWWindow, GWL_STYLE); // -> adjust wnd style (owndc needed by some stupid ogl drivers)\r
- dw&=~WS_THICKFRAME;\r
- dw|=WS_BORDER|WS_CAPTION|CS_OWNDC;\r
- SetWindowLong(hWWindow, GWL_STYLE, dw);\r
-\r
- hPSEMenu=GetMenu(hWWindow); // -> hide emu menu (if any)\r
- if(hPSEMenu!=NULL) SetMenu(hWWindow,NULL);\r
-\r
- iResX=LOWORD(iWinSize);iResY=HIWORD(iWinSize);\r
- ShowWindow(hWWindow,SW_SHOWNORMAL);\r
-\r
- MoveWindow(hWWindow, // -> center wnd\r
- GetSystemMetrics(SM_CXFULLSCREEN)/2-iResX/2,\r
- GetSystemMetrics(SM_CYFULLSCREEN)/2-iResY/2,\r
- iResX+GetSystemMetrics(SM_CXFIXEDFRAME)+3,\r
- iResY+GetSystemMetrics(SM_CYFIXEDFRAME)+GetSystemMetrics(SM_CYCAPTION)+3,\r
- TRUE);\r
- UpdateWindow(hWWindow); // -> let windows do some update\r
-\r
- if(dv.dmBitsPerPel==16 || dv.dmBitsPerPel==32) // -> overwrite user color info with desktop color info\r
- iColDepth=dv.dmBitsPerPel;\r
- }\r
- else // fullscreen mode:\r
- {\r
- if(dv.dmBitsPerPel!=(unsigned int)iColDepth || // -> check, if we have to change resolution\r
- dv.dmPelsWidth !=(unsigned int)iResX ||\r
- dv.dmPelsHeight!=(unsigned int)iResY)\r
- bChangeRes=TRUE; else bChangeRes=FALSE;\r
-\r
- if(bChangeRes) ChangeDesktop(); // -> change the res (had to do an own func because of some MS 'optimizations')\r
-\r
- SetWindowLong(hWWindow, GWL_STYLE, CS_OWNDC); // -> adjust wnd style as well (to be sure)\r
- \r
- hPSEMenu=GetMenu(hWWindow); // -> hide menu\r
- if(hPSEMenu!=NULL) SetMenu(hWWindow,NULL);\r
- ShowWindow(hWWindow,SW_SHOWMAXIMIZED); // -> max mode\r
- }\r
-#endif\r
rRatioRect.left = rRatioRect.top=0;\r
rRatioRect.right = iResX;\r
rRatioRect.bottom = iResY;\r
\r
-#ifdef _WINDOWS\r
- r.left=r.top=0;r.right=iResX;r.bottom=iResY; // hack for getting a clean black window until OGL gets initialized\r
- hdc = GetDC(hWWindow);\r
- FillRect(hdc,&r,(HBRUSH)GetStockObject(BLACK_BRUSH));\r
- bSetupPixelFormat(hdc);\r
- ReleaseDC(hWWindow,hdc);\r
-#endif\r
bDisplayNotSet = TRUE; \r
bSetClip=TRUE;\r
\r
\r
InitializeTextureStore(); // init texture mem\r
\r
+ CSTEXTURE = CSVERTEX = CSCOLOR = 0;\r
+\r
// lGPUstatusRet = 0x74000000;\r
\r
// with some emus, we could do the OGL init right here... oh my\r
-// if(bIsFirstFrame) GLinitialize();\r
+ if(bIsFirstFrame) GLinitialize();\r
\r
return 0;\r
}\r
// close\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-long CALLBACK GPUclose() // WINDOWS CLOSE\r
-{\r
-// ExitKeyHandler();\r
-\r
- GLcleanup(); // close OGL\r
-\r
- if(bChangeRes) // change res back\r
- ChangeDisplaySettings(NULL,0);\r
-\r
- if(hPSEMenu) // set menu again\r
- SetMenu(hWWindow,hPSEMenu);\r
-\r
- if(pGfxCardScreen) free(pGfxCardScreen); // free helper memory\r
- pGfxCardScreen=0;\r
-\r
-// if(iNoScreenSaver) EnableScreenSaver(TRUE); // enable screen saver again\r
-\r
- return 0;\r
-}\r
-\r
-#else\r
\r
long GPUclose() // LINUX CLOSE\r
{\r
\r
return 0;\r
}\r
-#endif\r
\r
////////////////////////////////////////////////////////////////////////\r
// I shot the sheriff... last function called from emu \r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
long CALLBACK GPUshutdown()\r
-#else\r
-long CALLBACK GPUshutdown()\r
-#endif\r
{\r
if(psxVSecure) free(psxVSecure); // kill emulated vram memory\r
psxVSecure=0;\r
void PaintBlackBorders(void)\r
{\r
short s;\r
+ glDisable(GL_SCISSOR_TEST); glError();\r
+ if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;} glError();\r
+ if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;} glError();\r
+ if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;} glError();\r
+ glDisable(GL_ALPHA_TEST); glError();\r
\r
- glDisable(GL_SCISSOR_TEST);\r
- if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;}\r
- if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}\r
- if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;}\r
- glDisable(GL_ALPHA_TEST);\r
+ glEnable(GL_ALPHA_TEST); glError();\r
+ glEnable(GL_SCISSOR_TEST); glError();\r
\r
- glEnable(GL_ALPHA_TEST);\r
- glEnable(GL_SCISSOR_TEST);\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
{\r
BOOL bBlur=FALSE;\r
\r
-#ifdef _WINDOWS\r
-HDC hdc=GetDC(hWWindow); // windows:\r
-wglMakeCurrent(hdc,GLCONTEXT); // -> make context current again\r
-#endif\r
\r
bFakeFrontBuffer=FALSE;\r
bRenderFrontBuffer=FALSE;\r
\r
if(PSXDisplay.Disabled) // display disabled?\r
{\r
+ //LOGE("PSXDisplay.Disabled");\r
+\r
// moved here\r
- glDisable(GL_SCISSOR_TEST); \r
- glClearColor(0,0,0,128); // -> clear whole backbuffer\r
- glClear(uiBufferBits);\r
- glEnable(GL_SCISSOR_TEST); \r
+ glDisable(GL_SCISSOR_TEST); glError(); \r
+ glClearColor(0,0,0,128); glError(); // -> clear whole backbuffer\r
+ glClear(uiBufferBits); glError();\r
+ glEnable(GL_SCISSOR_TEST); glError(); \r
gl_z=0.0f;\r
bDisplayNotSet = TRUE;\r
}\r
{\r
if(!bSkipNextFrame) \r
{\r
- if(iDrawnSomething)\r
-#ifdef _WINDOWS\r
- SwapBuffers(wglGetCurrentDC()); // -> to skip or not to skip\r
-#else\r
- eglSwapBuffers(display,surface);\r
-#endif\r
+ if(iDrawnSomething) flipEGL();\r
}\r
- if(dwActFixes&0x180) // -> special old frame skipping: skip max one in a row\r
- {\r
if((fps_skip < fFrameRateHz) && !(bSkipNextFrame)) \r
{bSkipNextFrame = TRUE; fps_skip=fFrameRateHz;}\r
else bSkipNextFrame = FALSE;\r
- }\r
- else FrameSkip();\r
+\r
}\r
else // no skip ?\r
{\r
- if(iDrawnSomething)\r
-#ifdef _WINDOWS\r
- SwapBuffers(wglGetCurrentDC()); // -> swap\r
-#else\r
- eglSwapBuffers(display,surface);\r
-#endif\r
+ if(iDrawnSomething) flipEGL();\r
}\r
\r
iDrawnSomething=0;\r
g=((GLclampf)GREEN(lClearOnSwapColor))/255.0f; // -> get col\r
b=((GLclampf)BLUE(lClearOnSwapColor))/255.0f;\r
r=((GLclampf)RED(lClearOnSwapColor))/255.0f;\r
- \r
- glDisable(GL_SCISSOR_TEST); \r
- glClearColor(r,g,b,128); // -> clear \r
- glClear(uiBufferBits);\r
- glEnable(GL_SCISSOR_TEST); \r
+ glDisable(GL_SCISSOR_TEST); glError(); \r
+ glClearColor(r,g,b,128); glError(); // -> clear \r
+ glClear(uiBufferBits); glError();\r
+ glEnable(GL_SCISSOR_TEST); glError(); \r
lClearOnSwap=0; // -> done\r
}\r
else \r
\r
if(iZBufferDepth) // clear zbuffer as well (if activated)\r
{\r
- glDisable(GL_SCISSOR_TEST); \r
- glClear(GL_DEPTH_BUFFER_BIT);\r
- glEnable(GL_SCISSOR_TEST); \r
+ glDisable(GL_SCISSOR_TEST); glError();\r
+ glClear(GL_DEPTH_BUFFER_BIT); glError();\r
+ glEnable(GL_SCISSOR_TEST); glError();\r
}\r
}\r
+\r
gl_z=0.0f;\r
\r
//----------------------------------------------------//\r
glViewport(rRatioRect.left+i1, \r
iResY-(rRatioRect.top+rRatioRect.bottom)+i2,\r
rRatioRect.right+i3, \r
- rRatioRect.bottom+i4); \r
+ rRatioRect.bottom+i4); glError();\r
}\r
\r
//----------------------------------------------------//\r
// if(gTexPicName) DisplayPic();\r
// if(ulKeybits&KEY_SHOWFPS) DisplayText();\r
\r
-#ifdef _WINDOWS\r
- { // windows: \r
- HDC hdc=GetDC(hWWindow);\r
- wglMakeCurrent(hdc,GLCONTEXT); // -> make current again\r
- if(iDrawnSomething)\r
- SwapBuffers(wglGetCurrentDC()); // -> swap\r
- ReleaseDC(hWWindow,hdc); // -> ! important !\r
- }\r
-#else\r
if(iDrawnSomething) // linux:\r
- eglSwapBuffers(display,surface);\r
-#endif\r
+ flipEGL();\r
+\r
\r
//if(iBlurBuffer) UnBlurBackBuffer();\r
}\r
if(!PSXDisplay.DisplayModeNew.x) return;\r
if(!PSXDisplay.DisplayModeNew.y) return;\r
\r
+#if 0\r
xs=(float)iResX/(float)PSXDisplay.DisplayModeNew.x;\r
ys=(float)iResY/(float)PSXDisplay.DisplayModeNew.y;\r
\r
\r
r.left = (iResX-r.right)/2;\r
r.top = (iResY-r.bottom)/2;\r
-\r
if(r.bottom<rRatioRect.bottom ||\r
r.right <rRatioRect.right)\r
{\r
RECT rC;\r
- glClearColor(0,0,0,128); \r
+ glClearColor(0,0,0,128); glError();\r
\r
if(r.right <rRatioRect.right)\r
{\r
rC.top=0;\r
rC.right=r.left;\r
rC.bottom=iResY;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
+ glScissor(rC.left,rC.top,rC.right,rC.bottom); glError();\r
+ glClear(uiBufferBits); glError();\r
rC.left=iResX-rC.right;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
+ glScissor(rC.left,rC.top,rC.right,rC.bottom); glError();\r
+ \r
+ glClear(uiBufferBits); glError();\r
}\r
\r
if(r.bottom <rRatioRect.bottom)\r
rC.top=0;\r
rC.right=iResX;\r
rC.bottom=r.top;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
+ glScissor(rC.left,rC.top,rC.right,rC.bottom); glError();\r
+\r
+ glClear(uiBufferBits); glError();\r
rC.top=iResY-rC.bottom;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
+ glScissor(rC.left,rC.top,rC.right,rC.bottom); glError();\r
+ glClear(uiBufferBits); glError();\r
}\r
\r
bSetClip=TRUE;\r
}\r
\r
rRatioRect=r;\r
-\r
+#else\r
+ // pcsx-rearmed hack\r
+ if (rearmed_get_layer_pos != NULL)\r
+ rearmed_get_layer_pos(&rRatioRect.left, &rRatioRect.top, &rRatioRect.right, &rRatioRect.bottom);\r
+#endif\r
\r
glViewport(rRatioRect.left,\r
iResY-(rRatioRect.top+rRatioRect.bottom),\r
rRatioRect.right,\r
- rRatioRect.bottom); // init viewport\r
+ rRatioRect.bottom); glError(); // init viewport\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
}\r
else // some res change?\r
{\r
- glLoadIdentity();\r
+ glLoadIdentity(); glError();\r
glOrtho(0,PSXDisplay.DisplayModeNew.x, // -> new psx resolution\r
- PSXDisplay.DisplayModeNew.y, 0, -1, 1);\r
+ PSXDisplay.DisplayModeNew.y, 0, -1, 1); glError();\r
if(bKeepRatio) SetAspectRatio();\r
}\r
\r
// window mode <-> fullscreen mode (windows)\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-void ChangeWindowMode(void)\r
-{\r
- GPUclose();\r
- bWindowMode=!bWindowMode;\r
- GPUopen(hWWindow);\r
- bChangeWinMode=FALSE;\r
-}\r
-#endif\r
\r
////////////////////////////////////////////////////////////////////////\r
// swap update check (called by psx vsync function)\r
\r
static unsigned short usFirstPos=2;\r
\r
-#ifdef _WINDOWS\r
-void CALLBACK GPUupdateLace(void)\r
-#else\r
void CALLBACK GPUupdateLace(void)\r
-#endif\r
{\r
if(!(dwActFixes&0x1000)) \r
STATUSREG^=0x80000000; // interlaced bit toggle, if the CC game fix is not active (see gpuReadStatus)\r
updateDisplay();\r
}\r
\r
-#ifdef _WINDOWS\r
-if(bChangeWinMode) ChangeWindowMode();\r
-#endif\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
// process read request from GPU status register\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-unsigned long CALLBACK GPUreadStatus(void)\r
-#else\r
unsigned long CALLBACK GPUreadStatus(void)\r
-#endif\r
{\r
if(dwActFixes&0x1000) // CC game fix\r
{\r
// these are always single packet commands.\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-void CALLBACK GPUwriteStatus(unsigned long gdata)\r
-#else\r
void CALLBACK GPUwriteStatus(unsigned long gdata)\r
-#endif\r
{\r
unsigned long lCommand=(gdata>>24)&0xff;\r
\r
-#ifdef _WINDOWS\r
if(bIsFirstFrame) GLinitialize(); // real ogl startup (needed by some emus)\r
-#endif\r
\r
ulStatusControl[lCommand]=gdata;\r
\r
int ux,uy,udx,udy,wx,wy;\r
unsigned short * p1, *p2;\r
float XS,YS;\r
- u8 * ps;\r
- u8 * px;\r
+ unsigned char * ps;\r
+ unsigned char * px;\r
unsigned short s,sx;\r
\r
if(STATUSREG&GPUSTATUS_RGB24) return;\r
\r
if(!pGfxCardScreen)\r
{\r
- glPixelStorei(GL_PACK_ALIGNMENT,1);\r
- pGfxCardScreen=(u8 *)malloc(iResX*iResY*4);\r
+ glPixelStorei(GL_PACK_ALIGNMENT,1); glError();\r
+ pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);\r
}\r
\r
ps=pGfxCardScreen;\r
\r
//if(!sArea) glReadBuffer(GL_FRONT);\r
\r
- glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps);\r
- \r
+ glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps); glError();\r
//if(!sArea) glReadBuffer(GL_BACK);\r
\r
s=0;\r
{\r
unsigned short sArea;unsigned short * p;\r
int ux,uy,udx,udy,wx,wy;float XS,YS;\r
- u8 * ps, * px;\r
+ unsigned char * ps, * px;\r
unsigned short s=0,sx;\r
\r
if(STATUSREG&GPUSTATUS_RGB24) return;\r
\r
if(!pGfxCardScreen)\r
{\r
- glPixelStorei(GL_PACK_ALIGNMENT,1);\r
- pGfxCardScreen=(u8 *)malloc(iResX*iResY*4);\r
+ glPixelStorei(GL_PACK_ALIGNMENT,1); glError();\r
+ pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);\r
}\r
\r
ps=pGfxCardScreen;\r
\r
// if(bFront) glReadBuffer(GL_FRONT);\r
\r
- glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps);\r
- \r
+ glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps); glError(); glError();\r
// if(bFront) glReadBuffer(GL_BACK);\r
\r
XS=(float)dx/(float)(udx);\r
// core read from vram\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-void CALLBACK GPUreadDataMem(unsigned int * pMem, int iSize)\r
-#else\r
void CALLBACK GPUreadDataMem(unsigned long * pMem, int iSize)\r
-#endif\r
{\r
int i;\r
\r
GPUIsIdle;\r
}\r
\r
-#ifdef _WINDOWS\r
-unsigned long CALLBACK GPUreadData(void)\r
-#else\r
unsigned long CALLBACK GPUreadData(void)\r
-#endif\r
{\r
unsigned long l;\r
-#ifdef _WINDOWS\r
GPUreadDataMem(&l,1);\r
-#else\r
- GPUreadDataMem(&l,1);\r
-#endif \r
return GPUdataRet;\r
}\r
\r
// helper table to know how much data is used by drawing commands\r
////////////////////////////////////////////////////////////////////////\r
\r
-const u8 primTableCX[256] =\r
+const unsigned char primTableCX[256] =\r
{\r
// 00\r
0,0,3,0,0,0,0,0,\r
// processes data send to GPU data register\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
void CALLBACK GPUwriteDataMem(unsigned long * pMem, int iSize)\r
-#else\r
-void CALLBACK GPUwriteDataMem(unsigned long * pMem, int iSize)\r
-#endif\r
{\r
-u8 command;\r
+unsigned char command;\r
unsigned long gdata=0;\r
int i=0;\r
GPUIsBusy;\r
\r
if(iDataWriteMode==DR_NORMAL)\r
{\r
- void (* *primFunc)(u8 *);\r
+ void (* *primFunc)(unsigned char *);\r
if(bSkipNextFrame) primFunc=primTableSkip;\r
else primFunc=primTableJ;\r
\r
\r
if(gpuDataC == 0)\r
{\r
- command = (u8)((gdata>>24) & 0xff);\r
+ command = (unsigned char)((gdata>>24) & 0xff);\r
\r
if(primTableCX[command])\r
{\r
if(gpuDataP == gpuDataC)\r
{\r
gpuDataC=gpuDataP=0;\r
- primFunc[gpuCommand]((u8 *)gpuDataM);\r
+ primFunc[gpuCommand]((unsigned char *)gpuDataM);\r
\r
if(dwEmuFixes&0x0001 || dwActFixes&0x20000) // hack for emulating "gpu busy" in some games\r
iFakePrimBusy=4;\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
void CALLBACK GPUwriteData(unsigned long gdata)\r
-#else\r
-void CALLBACK GPUwriteData(unsigned long gdata)\r
-#endif\r
{\r
-#ifdef _WINDOWS\r
- GPUwriteDataMem(&gdata,1);\r
-#else\r
GPUwriteDataMem(&gdata,1);\r
-#endif \r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
/*#include <unistd.h>\r
\r
-void StartCfgTool(s8 * pCmdLine) // linux: start external cfg tool\r
+void StartCfgTool(char * pCmdLine) // linux: start external cfg tool\r
{\r
- FILE * cf;s8 filename[255],t[255];\r
+ FILE * cf;char filename[255],t[255];\r
\r
strcpy(filename,"cfg/cfgPeopsMesaGL"); // look in cfg sub folder first\r
cf=fopen(filename,"rb");\r
#endif\r
\r
\r
-#ifdef _WINDOWS\r
-long CALLBACK GPUconfigure(void)\r
-#else\r
long CALLBACK GPUconfigure(void)\r
-#endif\r
{\r
\r
-#ifdef _WINDOWS\r
-// HWND hWP=GetActiveWindow();\r
-// DialogBox(hInst,MAKEINTRESOURCE(IDD_CFGDLG),\r
-// hWP,(DLGPROC)CfgDlgProc);\r
-#else\r
-\r
-// StartCfgTool("CFG");\r
-\r
-#endif\r
\r
return 0;\r
}\r
// core gives a dma chain to gpu: same as the gpuwrite interface funcs\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
long CALLBACK GPUdmaChain(unsigned long * baseAddrL, unsigned long addr)\r
-#else\r
-long CALLBACK GPUdmaChain(unsigned long * baseAddrL, unsigned long addr)\r
-#endif\r
{\r
unsigned long dmaMem;\r
-u8 * baseAddrB;\r
+unsigned char * baseAddrB;\r
short count;unsigned int DMACommandCounter = 0;\r
\r
if(bIsFirstFrame) GLinitialize();\r
\r
lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=0xffffff;\r
\r
-baseAddrB = (u8*) baseAddrL;\r
+baseAddrB = (unsigned char*) baseAddrL;\r
\r
do\r
{\r
\r
dmaMem=addr+4;\r
\r
-#ifdef _WINDOWS\r
- if(count>0) GPUwriteDataMem(&baseAddrL[dmaMem>>2],count);\r
-#else\r
if(count>0) GPUwriteDataMem(&baseAddrL[dmaMem>>2],count);\r
-#endif\r
\r
addr = baseAddrL[addr>>2]&0xffffff;\r
}\r
// show about dlg\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-void CALLBACK GPUabout(void)\r
-#else\r
void CALLBACK GPUabout(void)\r
-#endif\r
{\r
\r
}\r
// We are ever fine ;)\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-long CALLBACK GPUtest(void)\r
-#else\r
long CALLBACK GPUtest(void)\r
-#endif\r
{\r
// if test fails this function should return negative value for error (unable to continue)\r
// and positive value for warning (can continue but output might be crappy)\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
long CALLBACK GPUfreeze(unsigned long ulGetFreezeData,GPUFreeze_t * pF)\r
-#else\r
-long CALLBACK GPUfreeze(unsigned long ulGetFreezeData,GPUFreeze_t * pF)\r
-#endif\r
{\r
if(ulGetFreezeData==2) \r
{\r
\r
ResetTextureArea(TRUE);\r
\r
-#ifdef _WINDOWS\r
- GPUwriteStatus(ulStatusControl[0]);\r
- GPUwriteStatus(ulStatusControl[1]);\r
- GPUwriteStatus(ulStatusControl[2]);\r
- GPUwriteStatus(ulStatusControl[3]);\r
- GPUwriteStatus(ulStatusControl[8]);\r
- GPUwriteStatus(ulStatusControl[6]);\r
- GPUwriteStatus(ulStatusControl[7]);\r
- GPUwriteStatus(ulStatusControl[5]);\r
- GPUwriteStatus(ulStatusControl[4]);\r
-#else\r
GPUwriteStatus(ulStatusControl[0]);\r
GPUwriteStatus(ulStatusControl[1]);\r
GPUwriteStatus(ulStatusControl[2]);\r
GPUwriteStatus(ulStatusControl[7]);\r
GPUwriteStatus(ulStatusControl[5]);\r
GPUwriteStatus(ulStatusControl[4]);\r
-#endif\r
return 1;\r
}\r
\r
//10 = red\r
//11 = transparent\r
\r
-u8 cFont[10][120]=\r
+unsigned char cFont[10][120]=\r
{\r
// 0\r
{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
-void PaintPicDot(u8 * p,u8 c)\r
+void PaintPicDot(unsigned char * p,unsigned char c)\r
{\r
if(c==0) {*p++=0x00;*p++=0x00;*p=0x00;return;}\r
if(c==1) {*p++=0xff;*p++=0xff;*p=0xff;return;}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-void CALLBACK GPUgetScreenPic(u8 * pMem)\r
-#else\r
-long CALLBACK GPUgetScreenPic(u8 * pMem)\r
-#endif\r
+long CALLBACK GPUgetScreenPic(unsigned char * pMem)\r
{\r
float XS,YS;int x,y,v;\r
- u8 * ps, * px, * pf;\r
- u8 c;\r
+ unsigned char * ps, * px, * pf;\r
+ unsigned char c;\r
\r
if(!pGfxCardScreen)\r
{\r
- glPixelStorei(GL_PACK_ALIGNMENT,1);\r
- pGfxCardScreen=(u8 *)malloc(iResX*iResY*4);\r
+ glPixelStorei(GL_PACK_ALIGNMENT,1); glError();\r
+ pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);\r
}\r
\r
ps=pGfxCardScreen;\r
\r
// glReadBuffer(GL_FRONT);\r
\r
- glReadPixels(0,0,iResX,iResY,GL_RGB,GL_UNSIGNED_BYTE,ps);\r
+ glReadPixels(0,0,iResX,iResY,GL_RGB,GL_UNSIGNED_BYTE,ps); glError();\r
\r
// glReadBuffer(GL_BACK);\r
\r
{\r
c=cFont[lSelectedSlot][x+y*6];\r
v=(c&0xc0)>>6;\r
- PaintPicDot(pf,(u8)v);pf+=3; // paint the dots into the rect\r
+ PaintPicDot(pf,(unsigned char)v);pf+=3; // paint the dots into the rect\r
v=(c&0x30)>>4;\r
- PaintPicDot(pf,(u8)v);pf+=3;\r
+ PaintPicDot(pf,(unsigned char)v);pf+=3;\r
v=(c&0x0c)>>2;\r
- PaintPicDot(pf,(u8)v);pf+=3;\r
+ PaintPicDot(pf,(unsigned char)v);pf+=3;\r
v=c&0x03;\r
- PaintPicDot(pf,(u8)v);pf+=3;\r
+ PaintPicDot(pf,(unsigned char)v);pf+=3;\r
}\r
pf+=104*3;\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
-#ifdef _WINDOWS\r
-void CALLBACK GPUshowScreenPic(u8 * pMem)\r
-#else\r
-long CALLBACK GPUshowScreenPic(u8 * pMem)\r
-#endif\r
+long CALLBACK GPUshowScreenPic(unsigned char * pMem)\r
{\r
// DestroyPic();\r
// if(pMem==0) return;\r
{\r
// dwCoreFlags=dwFlags;\r
}\r
+\r
+// pcsx-rearmed callbacks\r
+void CALLBACK GPUrearmedCallbacks(const void **cbs)\r
+{\r
+ rearmed_get_layer_pos = cbs[0];\r
+}\r
+\r
+static void flipEGL(void)\r
+{\r
+ eglSwapBuffers(display, surface);\r
+}\r
notaz.gp2x.de / pcsx_rearmed.git / blobdiff