ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

zzogl-pg: Ran a bunch of the files through AStyle, so I don't find myself messing with the source code formatting so much. 

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@2931 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
arcum42 2010-05-01 20:33:53 +00:00
parent 7e8c22b4f5
commit a6c4df49ea
23 changed files with 5863 additions and 3923 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
plugins/zzogl-pg/opengl/GLWin32.cpp
View File

@ -21,13 +21,15 @@
#ifdef GL_WIN32_WINDOW #ifdef GL_WIN32_WINDOW
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{ {
static int nWindowWidth = 0, nWindowHeight = 0; static int nWindowWidth = 0, nWindowHeight = 0;
switch( msg ) { switch (msg)
{
case WM_DESTROY: case WM_DESTROY:
PostQuitMessage( 0 ); PostQuitMessage(0);
return 0; return 0;
case WM_KEYDOWN: case WM_KEYDOWN:
@ -39,24 +41,23 @@ LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
break; break;
case WM_ACTIVATE: case WM_ACTIVATE:
if (wParam != WA_INACTIVE)
if( wParam != WA_INACTIVE ) { {
//ZZLog::Debug_Log("Restoring device."); //ZZLog::Debug_Log("Restoring device.");
ZeroGS::Restore(); ZeroGS::Restore();
} }
break; break;
case WM_SIZE: case WM_SIZE:
nWindowWidth = lParam&0xffff; nWindowWidth = lParam & 0xffff;
nWindowHeight = lParam>>16; nWindowHeight = lParam >> 16;
ZeroGS::ChangeWindowSize(nWindowWidth, nWindowHeight); ZeroGS::ChangeWindowSize(nWindowWidth, nWindowHeight);
break; break;
case WM_SIZING: case WM_SIZING:
// if button is 0, then just released so can resize // if button is 0, then just released so can resize
if( GetSystemMetrics(SM_SWAPBUTTON) ? !GetAsyncKeyState(VK_RBUTTON) : !GetAsyncKeyState(VK_LBUTTON) ) { if (GetSystemMetrics(SM_SWAPBUTTON) ? !GetAsyncKeyState(VK_RBUTTON) : !GetAsyncKeyState(VK_LBUTTON))
{
ZeroGS::SetChangeDeviceSize(nWindowWidth, nWindowHeight); ZeroGS::SetChangeDeviceSize(nWindowWidth, nWindowHeight);
} }
break; break;
@ -66,14 +67,16 @@ LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
break; break;
} }
return DefWindowProc( hWnd, msg, wParam, lParam ); return DefWindowProc(hWnd, msg, wParam, lParam);
} }
bool GLWindow::CreateWindow(void *pDisplay) bool GLWindow::CreateWindow(void *pDisplay)
{ {
RECT rc, rcdesktop; RECT rc, rcdesktop;
rc.left = 0; rc.top = 0; rc.left = 0;
rc.right = conf.width; rc.bottom = conf.height; rc.top = 0;
rc.right = conf.width;
rc.bottom = conf.height;
WNDCLASSEX wc; WNDCLASSEX wc;
HINSTANCE hInstance = GetModuleHandle(NULL); HINSTANCE hInstance = GetModuleHandle(NULL);
@ -92,9 +95,9 @@ bool GLWindow::CreateWindow(void *pDisplay)
wc.lpszMenuName = NULL; wc.lpszMenuName = NULL;
wc.lpszClassName = "PS2EMU_ZEROGS"; wc.lpszClassName = "PS2EMU_ZEROGS";
RegisterClassEx( &wc ); RegisterClassEx(&wc);
if( conf.options & GSOPTION_FULLSCREEN) if (conf.options & GSOPTION_FULLSCREEN)
{ {
dwExStyle = WS_EX_APPWINDOW; dwExStyle = WS_EX_APPWINDOW;
dwStyle = WS_POPUP; dwStyle = WS_POPUP;
@ -106,31 +109,34 @@ bool GLWindow::CreateWindow(void *pDisplay)
} }
AdjustWindowRectEx(&rc, dwStyle, FALSE, dwExStyle); AdjustWindowRectEx(&rc, dwStyle, FALSE, dwExStyle);
GetWindowRect(GetDesktopWindow(), &rcdesktop); GetWindowRect(GetDesktopWindow(), &rcdesktop);
GShwnd = CreateWindowEx( GShwnd = CreateWindowEx(
dwExStyle, dwExStyle,
"PS2EMU_ZEROGS", "PS2EMU_ZEROGS",
"ZeroGS", "ZeroGS",
dwStyle, dwStyle,
(rcdesktop.right - (rc.right - rc.left)) / 2, (rcdesktop.right - (rc.right - rc.left)) / 2,
(rcdesktop.bottom - (rc.bottom - rc.top)) / 2, (rcdesktop.bottom - (rc.bottom - rc.top)) / 2,
rc.right - rc.left, rc.right - rc.left,
rc.bottom - rc.top, rc.bottom - rc.top,
NULL, NULL,
NULL, NULL,
hInstance, hInstance,
NULL); NULL);
if (GShwnd == NULL) return false; if (GShwnd == NULL) return false;
if (pDisplay != NULL) *(HWND*)pDisplay = GShwnd; if (pDisplay != NULL) *(HWND*)pDisplay = GShwnd;
// set just in case // set just in case
SetWindowLongPtr(GShwnd, GWLP_WNDPROC, (LPARAM)(WNDPROC)MsgProc); SetWindowLongPtr(GShwnd, GWLP_WNDPROC, (LPARAM)(WNDPROC)MsgProc);
ShowWindow( GShwnd, SW_SHOWDEFAULT ); ShowWindow(GShwnd, SW_SHOWDEFAULT);
UpdateWindow( GShwnd );
UpdateWindow(GShwnd);
SetFocus(GShwnd); SetFocus(GShwnd);
return (pDisplay != NULL); return (pDisplay != NULL);
@ -140,22 +146,23 @@ bool GLWindow::ReleaseWindow()
{ {
if (hRC) // Do We Have A Rendering Context? if (hRC) // Do We Have A Rendering Context?
{ {
if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts? if (!wglMakeCurrent(NULL, NULL)) // Are We Able To Release The DC And RC Contexts?
{ {
MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Release Of DC And RC Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
} }
if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC? if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
{ {
MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Release Rendering Context Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
} }
hRC=NULL; // Set RC To NULL
hRC = NULL; // Set RC To NULL
} }
if (hDC && !ReleaseDC(GShwnd,hDC)) // Are We Able To Release The DC if (hDC && !ReleaseDC(GShwnd, hDC)) // Are We Able To Release The DC
{ {
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Release Device Context Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
hDC=NULL; // Set DC To NULL hDC = NULL; // Set DC To NULL
} }
return true; return true;
@ -163,7 +170,7 @@ bool GLWindow::ReleaseWindow()
void GLWindow::CloseWindow() void GLWindow::CloseWindow()
{ {
if( GShwnd != NULL ) if (GShwnd != NULL)
{ {
DestroyWindow(GShwnd); DestroyWindow(GShwnd);
GShwnd = NULL; GShwnd = NULL;
@ -179,55 +186,64 @@ bool GLWindow::DisplayWindow(int _width, int _height)
RECT rcdesktop; RECT rcdesktop;
GetWindowRect(GetDesktopWindow(), &rcdesktop); GetWindowRect(GetDesktopWindow(), &rcdesktop);
if( conf.options & GSOPTION_FULLSCREEN) { if (conf.options & GSOPTION_FULLSCREEN)
{
nBackbufferWidth = rcdesktop.right - rcdesktop.left; nBackbufferWidth = rcdesktop.right - rcdesktop.left;
nBackbufferHeight = rcdesktop.bottom - rcdesktop.top; nBackbufferHeight = rcdesktop.bottom - rcdesktop.top;
dwExStyle=WS_EX_APPWINDOW; dwExStyle = WS_EX_APPWINDOW;
dwStyle=WS_POPUP; dwStyle = WS_POPUP;
ShowCursor(FALSE); ShowCursor(FALSE);
} }
else { else
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; {
dwStyle=WS_OVERLAPPEDWINDOW; dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_OVERLAPPEDWINDOW;
} }
RECT rc; RECT rc;
rc.left = 0; rc.top = 0;
rc.right = nBackbufferWidth; rc.bottom = nBackbufferHeight; rc.left = 0;
rc.top = 0;
rc.right = nBackbufferWidth;
rc.bottom = nBackbufferHeight;
AdjustWindowRectEx(&rc, dwStyle, FALSE, dwExStyle); AdjustWindowRectEx(&rc, dwStyle, FALSE, dwExStyle);
int X = (rcdesktop.right-rcdesktop.left)/2 - (rc.right-rc.left)/2; int X = (rcdesktop.right - rcdesktop.left) / 2 - (rc.right - rc.left) / 2;
int Y = (rcdesktop.bottom-rcdesktop.top)/2 - (rc.bottom-rc.top)/2; int Y = (rcdesktop.bottom - rcdesktop.top) / 2 - (rc.bottom - rc.top) / 2;
SetWindowLong( GShwnd, GWL_STYLE, dwStyle ); SetWindowLong(GShwnd, GWL_STYLE, dwStyle);
SetWindowLong( GShwnd, GWL_EXSTYLE, dwExStyle ); SetWindowLong(GShwnd, GWL_EXSTYLE, dwExStyle);
SetWindowPos(GShwnd, HWND_TOP, X, Y, rc.right-rc.left, rc.bottom-rc.top, SWP_SHOWWINDOW); SetWindowPos(GShwnd, HWND_TOP, X, Y, rc.right - rc.left, rc.bottom - rc.top, SWP_SHOWWINDOW);
if (conf.options & GSOPTION_FULLSCREEN) { if (conf.options & GSOPTION_FULLSCREEN)
{
DEVMODE dmScreenSettings; DEVMODE dmScreenSettings;
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize=sizeof(dmScreenSettings); dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = nBackbufferWidth; dmScreenSettings.dmPelsWidth = nBackbufferWidth;
dmScreenSettings.dmPelsHeight = nBackbufferHeight; dmScreenSettings.dmPelsHeight = nBackbufferHeight;
dmScreenSettings.dmBitsPerPel = 32; dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar. // Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{ {
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) if (MessageBox(NULL, "The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?", "NeHe GL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
conf.options &= ~GSOPTION_FULLSCREEN; conf.options &= ~GSOPTION_FULLSCREEN;
else else
return false; return false;
} }
} }
else { else
{
// change to default resolution // change to default resolution
ChangeDisplaySettings(NULL, 0); ChangeDisplaySettings(NULL, 0);
} }
PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be
{ {
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number 1, // Version Number
@ -249,32 +265,38 @@ bool GLWindow::DisplayWindow(int _width, int _height)
0, 0, 0 // Layer Masks Ignored 0, 0, 0 // Layer Masks Ignored
}; };
if (!(hDC=GetDC(GShwnd))) { if (!(hDC = GetDC(GShwnd)))
MessageBox(NULL,"(1) Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); {
MessageBox(NULL, "(1) Can't Create A GL Device Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return false; return false;
} }
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) { if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))
MessageBox(NULL,"(2) Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); {
MessageBox(NULL, "(2) Can't Find A Suitable PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return false; return false;
} }
if(!SetPixelFormat(hDC,PixelFormat,&pfd)) { if (!SetPixelFormat(hDC, PixelFormat, &pfd))
MessageBox(NULL,"(3) Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); {
MessageBox(NULL, "(3) Can't Set The PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return false; return false;
} }
if (!(hRC=wglCreateContext(hDC))) { if (!(hRC = wglCreateContext(hDC)))
MessageBox(NULL,"(4) Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); {
MessageBox(NULL, "(4) Can't Create A GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return false; return false;
} }
if(!wglMakeCurrent(hDC,hRC)) { if (!wglMakeCurrent(hDC, hRC))
MessageBox(NULL,"(5) Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); {
MessageBox(NULL, "(5) Can't Activate The GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return false; return false;
} }
UpdateWindow(GShwnd); UpdateWindow(GShwnd);
return true; return true;
} }

92
plugins/zzogl-pg/opengl/GLWinX11.cpp
View File

@ -23,14 +23,14 @@
bool GLWindow::CreateWindow(void *pDisplay) bool GLWindow::CreateWindow(void *pDisplay)
{ {
glDisplay = XOpenDisplay(0); glDisplay = XOpenDisplay(0);
glScreen = DefaultScreen(glDisplay); glScreen = DefaultScreen(glDisplay);
if ( pDisplay == NULL ) return false; if (pDisplay == NULL) return false;
*(Display**)pDisplay = glDisplay; *(Display**)pDisplay = glDisplay;
return true; return true;
} }
bool GLWindow::ReleaseWindow() bool GLWindow::ReleaseWindow()
@ -43,11 +43,12 @@ bool GLWindow::ReleaseWindow()
} }
glXDestroyContext(glDisplay, context); glXDestroyContext(glDisplay, context);
context = NULL; context = NULL;
} }
/* switch back to original desktop resolution if we were in fullscreen */ /* switch back to original desktop resolution if we were in fullscreen */
if ( glDisplay != NULL ) if (glDisplay != NULL)
{ {
if (fullScreen) if (fullScreen)
{ {
@ -55,6 +56,7 @@ bool GLWindow::ReleaseWindow()
XF86VidModeSetViewPort(glDisplay, glScreen, 0, 0); XF86VidModeSetViewPort(glDisplay, glScreen, 0, 0);
} }
} }
return true; return true;
} }
@ -63,8 +65,9 @@ void GLWindow::CloseWindow()
conf.x = x; conf.x = x;
conf.y = y; conf.y = y;
SaveConfig(); SaveConfig();
if ( glDisplay != NULL )
{ if (glDisplay != NULL)
{
XCloseDisplay(glDisplay); XCloseDisplay(glDisplay);
glDisplay = NULL; glDisplay = NULL;
} }
@ -84,14 +87,15 @@ bool GLWindow::DisplayWindow(int _width, int _height)
x = conf.x; x = conf.x;
y = conf.y; y = conf.y;
// attributes for a single buffered visual in RGBA format with at least // attributes for a single buffered visual in RGBA format with at least
// 8 bits per color and a 24 bit depth buffer // 8 bits per color and a 24 bit depth buffer
int attrListSgl[] = {GLX_RGBA, GLX_RED_SIZE, 8, int attrListSgl[] = {GLX_RGBA, GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8, GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8, GLX_BLUE_SIZE, 8,
GLX_DEPTH_SIZE, 24, GLX_DEPTH_SIZE, 24,
None}; None
};
// attributes for a double buffered visual in RGBA format with at least // attributes for a double buffered visual in RGBA format with at least
// 8 bits per color and a 24 bit depth buffer // 8 bits per color and a 24 bit depth buffer
@ -100,12 +104,14 @@ bool GLWindow::DisplayWindow(int _width, int _height)
GLX_GREEN_SIZE, 8, GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8, GLX_BLUE_SIZE, 8,
GLX_DEPTH_SIZE, 24, GLX_DEPTH_SIZE, 24,
None }; None
};
GLWin.fullScreen = !!(conf.options & GSOPTION_FULLSCREEN); GLWin.fullScreen = !!(conf.options & GSOPTION_FULLSCREEN);
/* get an appropriate visual */ /* get an appropriate visual */
vi = glXChooseVisual(glDisplay, glScreen, attrListDbl); vi = glXChooseVisual(glDisplay, glScreen, attrListDbl);
if (vi == NULL) if (vi == NULL)
{ {
vi = glXChooseVisual(glDisplay, glScreen, attrListSgl); vi = glXChooseVisual(glDisplay, glScreen, attrListSgl);
@ -117,6 +123,7 @@ bool GLWindow::DisplayWindow(int _width, int _height)
doubleBuffered = true; doubleBuffered = true;
ZZLog::Error_Log("Got Doublebuffered Visual!"); ZZLog::Error_Log("Got Doublebuffered Visual!");
} }
if (vi == NULL) if (vi == NULL)
{ {
ZZLog::Error_Log("Failed to get buffered Visual!"); ZZLog::Error_Log("Failed to get buffered Visual!");
@ -124,6 +131,7 @@ bool GLWindow::DisplayWindow(int _width, int _height)
} }
glXQueryVersion(glDisplay, &glxMajorVersion, &glxMinorVersion); glXQueryVersion(glDisplay, &glxMajorVersion, &glxMinorVersion);
ZZLog::Error_Log("glX-Version %d.%d", glxMajorVersion, glxMinorVersion); ZZLog::Error_Log("glX-Version %d.%d", glxMajorVersion, glxMinorVersion);
/* create a GLX context */ /* create a GLX context */
@ -149,12 +157,13 @@ bool GLWindow::DisplayWindow(int _width, int _height)
ZZLog::Error_Log("XF86VidModeExtension-Version %d.%d.", vidModeMajorVersion, vidModeMinorVersion); ZZLog::Error_Log("XF86VidModeExtension-Version %d.%d.", vidModeMajorVersion, vidModeMinorVersion);
XF86VidModeGetAllModeLines(glDisplay, glScreen, &modeNum, &modes); XF86VidModeGetAllModeLines(glDisplay, glScreen, &modeNum, &modes);
if( modeNum > 0 && modes != NULL ) if (modeNum > 0 && modes != NULL)
{ {
/* save desktop-resolution before switching modes */ /* save desktop-resolution before switching modes */
deskMode = *modes[0]; deskMode = *modes[0];
/* look for mode with requested resolution */ /* look for mode with requested resolution */
for (i = 0; i < modeNum; i++) for (i = 0; i < modeNum; i++)
{ {
if ((modes[i]->hdisplay == _width) && (modes[i]->vdisplay == _height)) if ((modes[i]->hdisplay == _width) && (modes[i]->vdisplay == _height))
@ -164,6 +173,7 @@ bool GLWindow::DisplayWindow(int _width, int _height)
} }
XF86VidModeSwitchToMode(glDisplay, glScreen, modes[bestMode]); XF86VidModeSwitchToMode(glDisplay, glScreen, modes[bestMode]);
XF86VidModeSetViewPort(glDisplay, glScreen, 0, 0); XF86VidModeSetViewPort(glDisplay, glScreen, 0, 0);
dpyWidth = modes[bestMode]->hdisplay; dpyWidth = modes[bestMode]->hdisplay;
dpyHeight = modes[bestMode]->vdisplay; dpyHeight = modes[bestMode]->vdisplay;
@ -174,9 +184,9 @@ bool GLWindow::DisplayWindow(int _width, int _height)
attr.override_redirect = True; attr.override_redirect = True;
attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | StructureNotifyMask; attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | StructureNotifyMask;
glWindow = XCreateWindow(glDisplay, RootWindow(glDisplay, vi->screen), glWindow = XCreateWindow(glDisplay, RootWindow(glDisplay, vi->screen),
0, 0, dpyWidth, dpyHeight, 0, vi->depth, InputOutput, vi->visual, 0, 0, dpyWidth, dpyHeight, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect,
&attr); &attr);
XWarpPointer(glDisplay, None, glWindow, 0, 0, 0, 0, 0, 0); XWarpPointer(glDisplay, None, glWindow, 0, 0, 0, 0, 0, 0);
XMapRaised(glDisplay, glWindow); XMapRaised(glDisplay, glWindow);
XGrabKeyboard(glDisplay, glWindow, True, GrabModeAsync, GrabModeAsync, CurrentTime); XGrabKeyboard(glDisplay, glWindow, True, GrabModeAsync, GrabModeAsync, CurrentTime);
@ -185,9 +195,9 @@ bool GLWindow::DisplayWindow(int _width, int _height)
else else
{ {
ZZLog::Error_Log("Failed to start fullscreen. If you received the \n" ZZLog::Error_Log("Failed to start fullscreen. If you received the \n"
"\"XFree86-VidModeExtension\" extension is missing, add\n" "\"XFree86-VidModeExtension\" extension is missing, add\n"
"Load \"extmod\"\n" "Load \"extmod\"\n"
"to your X configuration file (under the Module Section)"); "to your X configuration file (under the Module Section)");
fullScreen = false; fullScreen = false;
} }
} }
@ -197,8 +207,8 @@ bool GLWindow::DisplayWindow(int _width, int _height)
// create a window in window mode // create a window in window mode
attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | StructureNotifyMask; attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | StructureNotifyMask;
glWindow = XCreateWindow(glDisplay, RootWindow(glDisplay, vi->screen), glWindow = XCreateWindow(glDisplay, RootWindow(glDisplay, vi->screen),
0, 0, _width, _height, 0, vi->depth, InputOutput, vi->visual, 0, 0, _width, _height, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask, &attr); CWBorderPixel | CWColormap | CWEventMask, &attr);
// only set window title and handle wm_delete_events if in windowed mode // only set window title and handle wm_delete_events if in windowed mode
wmDelete = XInternAtom(glDisplay, "WM_DELETE_WINDOW", True); wmDelete = XInternAtom(glDisplay, "WM_DELETE_WINDOW", True);
@ -211,8 +221,11 @@ bool GLWindow::DisplayWindow(int _width, int _height)
// connect the glx-context to the window // connect the glx-context to the window
glXMakeCurrent(glDisplay, glWindow, context); glXMakeCurrent(glDisplay, glWindow, context);
XGetGeometry(glDisplay, glWindow, &winDummy, &x, &y, &width, &height, &borderDummy, &depth); XGetGeometry(glDisplay, glWindow, &winDummy, &x, &y, &width, &height, &borderDummy, &depth);
ZZLog::Error_Log("Depth %d", depth); ZZLog::Error_Log("Depth %d", depth);
if (glXIsDirect(glDisplay, context)) if (glXIsDirect(glDisplay, context))
ZZLog::Error_Log("You have Direct Rendering!"); ZZLog::Error_Log("You have Direct Rendering!");
else else
@ -221,14 +234,14 @@ bool GLWindow::DisplayWindow(int _width, int _height)
// better for pad plugin key input (thc) // better for pad plugin key input (thc)
XSelectInput(glDisplay, glWindow, ExposureMask | KeyPressMask | KeyReleaseMask | XSelectInput(glDisplay, glWindow, ExposureMask | KeyPressMask | KeyReleaseMask |
ButtonPressMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask | ButtonPressMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask |
FocusChangeMask ); FocusChangeMask);
return true; return true;
} }
void GLWindow::SwapGLBuffers() void GLWindow::SwapGLBuffers()
{ {
glXSwapBuffers(glDisplay, glWindow); glXSwapBuffers(glDisplay, glWindow);
} }
void GLWindow::SetTitle(char *strtitle) void GLWindow::SetTitle(char *strtitle)
@ -236,29 +249,32 @@ void GLWindow::SetTitle(char *strtitle)
XTextProperty prop; XTextProperty prop;
memset(&prop, 0, sizeof(prop)); memset(&prop, 0, sizeof(prop));
char* ptitle = strtitle; char* ptitle = strtitle;
if( XStringListToTextProperty(&ptitle, 1, &prop) )
if (XStringListToTextProperty(&ptitle, 1, &prop))
XSetWMName(glDisplay, glWindow, &prop); XSetWMName(glDisplay, glWindow, &prop);
XFree(prop.value); XFree(prop.value);
} }
void GLWindow::ResizeCheck() void GLWindow::ResizeCheck()
{ {
XEvent event; XEvent event;
while(XCheckTypedEvent(glDisplay, ConfigureNotify, &event)) while (XCheckTypedEvent(glDisplay, ConfigureNotify, &event))
{ {
if ((event.xconfigure.width != width) || (event.xconfigure.height != height)) if ((event.xconfigure.width != width) || (event.xconfigure.height != height))
{ {
ZeroGS::ChangeWindowSize(event.xconfigure.width, event.xconfigure.height); ZeroGS::ChangeWindowSize(event.xconfigure.width, event.xconfigure.height);
width = event.xconfigure.width; width = event.xconfigure.width;
height = event.xconfigure.height; height = event.xconfigure.height;
} }
if ((event.xconfigure.x != x) || (event.xconfigure.y != y))
{ if ((event.xconfigure.x != x) || (event.xconfigure.y != y))
x = event.xconfigure.x; {
y = event.xconfigure.y; x = event.xconfigure.x;
} y = event.xconfigure.y;
} }
}
} }
#endif #endif

715
plugins/zzogl-pg/opengl/GSmain.cpp
View File

File diff suppressed because it is too large Load Diff

539
plugins/zzogl-pg/opengl/GifTransfer.cpp
View File

@ -74,18 +74,22 @@ extern HANDLE g_hCurrentThread;
__forceinline void gifTransferLog(int index, u32 *pMem, u32 size) __forceinline void gifTransferLog(int index, u32 *pMem, u32 size)
{ {
#ifdef _DEBUG #ifdef _DEBUG
if( conf.log /*& 0x20*/ )
if (conf.log /*& 0x20*/)
{ {
static int nSaveIndex = 0; static int nSaveIndex = 0;
ZZLog::GS_Log("%d: p:%d %x", nSaveIndex++, index + 1, size); ZZLog::GS_Log("%d: p:%d %x", nSaveIndex++, index + 1, size);
int vals[4] = {0}; int vals[4] = {0};
for(u32 i = 0; i < size; i++)
for (u32 i = 0; i < size; i++)
{ {
for(u32 j = 0; j < 4; ++j ) for (u32 j = 0; j < 4; ++j)
vals[j] ^= pMem[4*i+j]; vals[j] ^= pMem[4*i+j];
} }
ZZLog::GS_Log("%x %x %x %x", vals[0], vals[1], vals[2], vals[3]); ZZLog::GS_Log("%x %x %x %x", vals[0], vals[1], vals[2], vals[3]);
} }
#endif #endif
} }
@ -94,151 +98,157 @@ extern int g_GSMultiThreaded;
template<int index> void _GSgifTransfer(u32 *pMem, u32 size) template<int index> void _GSgifTransfer(u32 *pMem, u32 size)
{ {
FUNCLOG FUNCLOG
pathInfo *path = &gs.path[index]; pathInfo *path = &gs.path[index];
#ifdef _WIN32 #ifdef _WIN32
assert( g_hCurrentThread == GetCurrentThread() ); assert(g_hCurrentThread == GetCurrentThread());
#endif #endif
#ifdef _DEBUG #ifdef _DEBUG
gifTransferLog(index, pMem, size); gifTransferLog(index, pMem, size);
#endif #endif
while(size > 0) while (size > 0)
{ {
//LOG(_T("Transfer(%08x, %d) START\n"), pMem, size); //LOG(_T("Transfer(%08x, %d) START\n"), pMem, size);
if (path->nloop == 0) if (path->nloop == 0)
{
path->setTag(pMem);
pMem += 4;
size--;
if ((g_GameSettings & GAME_PATH3HACK) && (index == 2) && path->eop) nPath3Hack = 1;
// eeuser 7.2.2. GIFtag: "... when NLOOP is 0, the GIF does not output anything, and
// values other than the EOP field are disregarded."
if (path->nloop > 0)
{ {
path->setTag(pMem); gs.q = 1.0f;
pMem += 4;
size--;
if ((g_GameSettings & GAME_PATH3HACK) && (index == 2) && path->eop) nPath3Hack = 1; if (path->tag.PRE && (path->tag.FLG == GIF_FLG_PACKED))
// eeuser 7.2.2. GIFtag: "... when NLOOP is 0, the GIF does not output anything, and
// values other than the EOP field are disregarded."
if (path->nloop > 0)
{ {
gs.q = 1.0f; u32 tagprim = path->tag.PRIM;
GIFRegHandlerPRIM((u32*)&tagprim);
if(path->tag.PRE && (path->tag.FLG == GIF_FLG_PACKED))
{
u32 tagprim = path->tag.PRIM;
GIFRegHandlerPRIM((u32*)&tagprim);
}
} }
} }
else }
else
{
switch (path->mode)
{ {
switch(path->mode) case GIF_FLG_PACKED:
{ {
case GIF_FLG_PACKED: // Needs to be looked at.
// first try a shortcut for a very common case
/*if(path.adonly && size >= path.nloop)
{ {
// Needs to be looked at. size -= path.nloop;
// first try a shortcut for a very common case
/*if(path.adonly && size >= path.nloop)
{
size -= path.nloop;
do
{
GIFPackedRegHandlerA_D(pMem);
mem += sizeof(GIFPackedReg);
}
while(--path.nloop > 0);*/
do do
{ {
g_GIFPackedRegHandlers[path->GetReg()](pMem); GIFPackedRegHandlerA_D(pMem);
pMem += 4; mem += sizeof(GIFPackedReg);
size--;
} }
while (path->StepReg() && (size > 0)); while(--path.nloop > 0);*/
break; do
}
case GIF_FLG_REGLIST:
{ {
// Needs to be looked at. g_GIFPackedRegHandlers[path->GetReg()](pMem);
//ZZLog::GS_Log("%8.8x%8.8x %d L", ((u32*)&gs.regs)[1], *(u32*)&gs.regs, path->tag.nreg/4);
size *= 2; pMem += 4;
size--;
do
{
g_GIFRegHandlers[path->GetReg()](pMem);
pMem += 2;
size--;
}
while(path->StepReg() && (size > 0));
if(size & 1) pMem += 2;
size /= 2;
break;
} }
while (path->StepReg() && (size > 0));
case GIF_FLG_IMAGE: // FROM_VFRAM
case GIF_FLG_IMAGE2: // Used in the DirectX version, so we'll use it here too.
{
int len = min(size, path->nloop);
//ZZLog::Error_Log("GIF_FLG_IMAGE(%d)=%d", gs.imageTransfer, len);
switch(gs.imageTransfer)
{
case 0:
ZeroGS::TransferHostLocal(pMem, len * 4);
break;
case 1:
ZeroGS::TransferLocalHost(pMem, len);
break;
case 2:
//Move();
//ZZLog::Error_Log("GIF_FLG_IMAGE MOVE");
break;
case 3:
//assert(0);
break;
default:
//assert(0);
break;
}
pMem += len * 4;
path->nloop -= len;
size -= len;
break;
}
default: // GIF_IMAGE
ZZLog::GS_Log("*** WARNING **** Unexpected GIFTag flag.");
assert(0);
path->nloop = 0;
break;
}
}
if (index == 0)
{
if(path->tag.EOP && path->nloop == 0)
{
break; break;
} }
case GIF_FLG_REGLIST:
{
// Needs to be looked at.
//ZZLog::GS_Log("%8.8x%8.8x %d L", ((u32*)&gs.regs)[1], *(u32*)&gs.regs, path->tag.nreg/4);
size *= 2;
do
{
g_GIFRegHandlers[path->GetReg()](pMem);
pMem += 2;
size--;
}
while (path->StepReg() && (size > 0));
if (size & 1) pMem += 2;
size /= 2;
break;
}
case GIF_FLG_IMAGE: // FROM_VFRAM
case GIF_FLG_IMAGE2: // Used in the DirectX version, so we'll use it here too.
{
int len = min(size, path->nloop);
//ZZLog::Error_Log("GIF_FLG_IMAGE(%d)=%d", gs.imageTransfer, len);
switch (gs.imageTransfer)
{
case 0:
ZeroGS::TransferHostLocal(pMem, len * 4);
break;
case 1:
ZeroGS::TransferLocalHost(pMem, len);
break;
case 2:
//Move();
//ZZLog::Error_Log("GIF_FLG_IMAGE MOVE");
break;
case 3:
//assert(0);
break;
default:
//assert(0);
break;
}
pMem += len * 4;
path->nloop -= len;
size -= len;
break;
}
default: // GIF_IMAGE
ZZLog::GS_Log("*** WARNING **** Unexpected GIFTag flag.");
assert(0);
path->nloop = 0;
break;
} }
} }
if (index == 0)
{
if (path->tag.EOP && path->nloop == 0)
{
break;
}
}
}
// This is the case when not all data was readed from one try: VU1 has too much data. // This is the case when not all data was readed from one try: VU1 has too much data.
// So we should redo reading from the start. // So we should redo reading from the start.
if (index == 0) if (index == 0)
{ {
if(size == 0 && path->nloop > 0) if (size == 0 && path->nloop > 0)
{ {
if (g_GSMultiThreaded) if (g_GSMultiThreaded)
{ {
@ -263,7 +273,7 @@ void CALLBACK GSgifTransfer1(u32 *pMem, u32 addr)
count++; count++;
#endif #endif
_GSgifTransfer<0>((u32*)((u8*)pMem + addr), (0x4000 - addr)/16); _GSgifTransfer<0>((u32*)((u8*)pMem + addr), (0x4000 - addr) / 16);
} }
void CALLBACK GSgifTransfer2(u32 *pMem, u32 size) void CALLBACK GSgifTransfer2(u32 *pMem, u32 size)
@ -283,180 +293,194 @@ void CALLBACK GSgifTransfer3(u32 *pMem, u32 size)
_GSgifTransfer<2>(pMem, size); _GSgifTransfer<2>(pMem, size);
} }
#else #else
template<int index> void _GSgifTransfer(u32 *pMem, u32 size) template<int index> void _GSgifTransfer(u32 *pMem, u32 size)
{ {
FUNCLOG FUNCLOG
pathInfo *path = &gs.path[index]; pathInfo *path = &gs.path[index];
#ifdef _WIN32 #ifdef _WIN32
assert( g_hCurrentThread == GetCurrentThread() ); assert(g_hCurrentThread == GetCurrentThread());
#endif #endif
#ifdef _DEBUG #ifdef _DEBUG
gifTransferLog(index, pMem, size); gifTransferLog(index, pMem, size);
#endif #endif
while(size > 0) while (size > 0)
{ {
//LOG(_T("Transfer(%08x, %d) START\n"), pMem, size); //LOG(_T("Transfer(%08x, %d) START\n"), pMem, size);
if (path->nloop == 0) if (path->nloop == 0)
{ {
path->setTag(pMem); path->setTag(pMem);
gs.q = 1; gs.q = 1;
pMem += 4; pMem += 4;
size--; size--;
if ((g_GameSettings & GAME_PATH3HACK) && (index == 2) && path->eop) nPath3Hack = 1; if ((g_GameSettings & GAME_PATH3HACK) && (index == 2) && path->eop) nPath3Hack = 1;
if (index == 0) if (index == 0)
{ {
if (path->mode == GIF_FLG_PACKED) if (path->mode == GIF_FLG_PACKED)
{ {
// check if 0xb is in any reg, if yes, exit (kh2) // check if 0xb is in any reg, if yes, exit (kh2)
for(int i = 0; i < path->nreg; i += 4) for (int i = 0; i < path->nreg; i += 4)
{ {
if (((path->regs >> i) & 0xf) == 11) if (((path->regs >> i) & 0xf) == 11)
{ {
ERROR_LOG_SPAM("Invalid unpack type\n"); ERROR_LOG_SPAM("Invalid unpack type\n");
path->nloop = 0; path->nloop = 0;
return; return;
} }
} }
} }
} }
if(path->nloop == 0 ) if (path->nloop == 0)
{ {
if (index == 0) if (index == 0)
{ {
// ffx hack // ffx hack
if( path->eop ) return; if (path->eop) return;
continue;
}
/*if( !path->eop ) continue;
{ }
//ZZLog::Debug_Log("Continuing from eop.");
continue;
}*/
// Issue 174 fix! /*if( !path->eop )
continue; {
} //ZZLog::Debug_Log("Continuing from eop.");
} continue;
}*/
switch(path->mode) // Issue 174 fix!
{ continue;
case GIF_FLG_PACKED: }
{ }
assert( path->nloop > 0 );
for(; size > 0; size--, pMem += 4)
{
int reg = (int)((path->regs >> path->regn) & 0xf);
g_GIFPackedRegHandlers[reg](pMem); switch (path->mode)
{
path->regn += 4; case GIF_FLG_PACKED:
{
assert(path->nloop > 0);
if (path->nreg == path->regn) for (; size > 0; size--, pMem += 4)
{ {
path->regn = 0; int reg = (int)((path->regs >> path->regn) & 0xf);
if( path->nloop-- <= 1 ) g_GIFPackedRegHandlers[reg](pMem);
{
size--;
pMem += 4;
break;
}
}
}
break;
}
case GIF_FLG_REGLIST:
{
//GS_LOG("%8.8x%8.8x %d L", ((u32*)&gs.regs)[1], *(u32*)&gs.regs, path->tag.nreg/4);
assert( path->nloop > 0 );
size *= 2;
for(; size > 0; pMem+= 2, size--) path->regn += 4;
{
int reg = (int)((path->regs >> path->regn) & 0xf);
g_GIFRegHandlers[reg](pMem); if (path->nreg == path->regn)
{
path->regn = 0;
path->regn += 4; if (path->nloop-- <= 1)
{
size--;
pMem += 4;
break;
}
}
}
if (path->nreg == path->regn) break;
{ }
path->regn = 0;
if( path->nloop-- <= 1 )
{
size--;
pMem += 2;
break;
}
}
}
if( size & 1 ) pMem += 2; case GIF_FLG_REGLIST:
size /= 2; {
break; //GS_LOG("%8.8x%8.8x %d L", ((u32*)&gs.regs)[1], *(u32*)&gs.regs, path->tag.nreg/4);
} assert(path->nloop > 0);
case GIF_FLG_IMAGE: // FROM_VFRAM size *= 2;
case GIF_FLG_IMAGE2: // Used in the DirectX version, so we'll use it here too.
{
if(gs.imageTransfer >= 0 && gs.imageTransfer <= 1)
{
int process = min((int)size, path->nloop);
if( process > 0 ) for (; size > 0; pMem += 2, size--)
{ {
if ( gs.imageTransfer ) int reg = (int)((path->regs >> path->regn) & 0xf);
ZeroGS::TransferLocalHost(pMem, process);
else
ZeroGS::TransferHostLocal(pMem, process*4);
path->nloop -= process; g_GIFRegHandlers[reg](pMem);
pMem += process*4;
size -= process;
assert( size == 0 || path->nloop == 0 ); path->regn += 4;
}
break;
}
else
{
// simulate
int process = min((int)size, path->nloop);
path->nloop -= process; if (path->nreg == path->regn)
pMem += process*4; {
size -= process; path->regn = 0;
}
break; if (path->nloop-- <= 1)
} {
default: // GIF_IMAGE size--;
ZZLog::GS_Log("*** WARNING **** Unexpected GIFTag flag."); pMem += 2;
assert(0); break;
path->nloop = 0; }
break; }
} }
if ((index == 0) && path->eop) return; if (size & 1) pMem += 2;
}
// This is the case when not all data was readed from one try: VU1 has too much data. size /= 2;
// So we should redo reading from the start.
if ((index == 0) && size == 0 && path->nloop > 0) break;
{ }
ERROR_LOG_SPAMA("VU1 too much data, ignore if gfx are fine %d\n", path->nloop)
// TODO: this code is not working correctly. Anyway, ringing work only in single-threaded mode. case GIF_FLG_IMAGE: // FROM_VFRAM
// _GSgifTransfer(&gs.path[0], (u32*)((u8*)pMem-0x4000), (0x4000)/16); case GIF_FLG_IMAGE2: // Used in the DirectX version, so we'll use it here too.
} {
if (gs.imageTransfer >= 0 && gs.imageTransfer <= 1)
{
int process = min((int)size, path->nloop);
if (process > 0)
{
if (gs.imageTransfer)
ZeroGS::TransferLocalHost(pMem, process);
else
ZeroGS::TransferHostLocal(pMem, process*4);
path->nloop -= process;
pMem += process * 4;
size -= process;
assert(size == 0 || path->nloop == 0);
}
break;
}
else
{
// simulate
int process = min((int)size, path->nloop);
path->nloop -= process;
pMem += process * 4;
size -= process;
}
break;
}
default: // GIF_IMAGE
ZZLog::GS_Log("*** WARNING **** Unexpected GIFTag flag.");
assert(0);
path->nloop = 0;
break;
}
if ((index == 0) && path->eop) return;
}
// This is the case when not all data was readed from one try: VU1 has too much data.
// So we should redo reading from the start.
if ((index == 0) && size == 0 && path->nloop > 0)
{
ERROR_LOG_SPAMA("VU1 too much data, ignore if gfx are fine %d\n", path->nloop)
// TODO: this code is not working correctly. Anyway, ringing work only in single-threaded mode.
// _GSgifTransfer(&gs.path[0], (u32*)((u8*)pMem-0x4000), (0x4000)/16);
}
} }
void CALLBACK GSgifTransfer1(u32 *pMem, u32 addr) void CALLBACK GSgifTransfer1(u32 *pMem, u32 addr)
@ -476,11 +500,11 @@ void CALLBACK GSgifTransfer1(u32 *pMem, u32 addr)
path->nloop = 0; path->nloop = 0;
path->eop = 0; path->eop = 0;
_GSgifTransfer<0>((u32*)((u8*)pMem + addr), (0x4000 - addr)/16); _GSgifTransfer<0>((u32*)((u8*)pMem + addr), (0x4000 - addr) / 16);
if (!path->eop && (path->nloop > 0)) if (!path->eop && (path->nloop > 0))
{ {
assert( (addr&0xf) == 0 ); //BUG assert((addr&0xf) == 0); //BUG
path->nloop = 0; path->nloop = 0;
ZZLog::Error_Log("Transfer1 - 2."); ZZLog::Error_Log("Transfer1 - 2.");
return; return;
@ -505,4 +529,5 @@ void CALLBACK GSgifTransfer3(u32 *pMem, u32 size)
nPath3Hack = 0; nPath3Hack = 0;
_GSgifTransfer<2>(pMem, size); _GSgifTransfer<2>(pMem, size);
} }
#endif #endif

24
plugins/zzogl-pg/opengl/Linux/Conf.cpp
View File

@ -26,8 +26,8 @@
void SaveConfig() void SaveConfig()
{ {
const std::string iniFile( s_strIniPath + "zzogl-pg.ini" ); const std::string iniFile(s_strIniPath + "zzogl-pg.ini");
FILE* f = fopen(iniFile.c_str(),"w"); FILE* f = fopen(iniFile.c_str(), "w");
if (f == NULL) if (f == NULL)
{ {
@ -36,6 +36,7 @@ void SaveConfig()
} }
fprintf(f, "interlace = %hhx\n", conf.interlace); fprintf(f, "interlace = %hhx\n", conf.interlace);
fprintf(f, "mrtdepth = %hhx\n", conf.mrtdepth); fprintf(f, "mrtdepth = %hhx\n", conf.mrtdepth);
fprintf(f, "options = %x\n", conf.options); //u32 fprintf(f, "options = %x\n", conf.options); //u32
fprintf(f, "bilinear = %hhx\n", conf.bilinear); fprintf(f, "bilinear = %hhx\n", conf.bilinear);
@ -64,15 +65,18 @@ void LoadConfig()
conf.aa = 0; conf.aa = 0;
conf.log = 1; conf.log = 1;
const std::string iniFile( s_strIniPath + "zzogl-pg.ini" ); const std::string iniFile(s_strIniPath + "zzogl-pg.ini");
FILE* f = fopen(iniFile.c_str(), "r"); FILE* f = fopen(iniFile.c_str(), "r");
if (f == NULL) if (f == NULL)
{ {
printf("failed to open %s\n", iniFile.c_str()); printf("failed to open %s\n", iniFile.c_str());
SaveConfig();//save and return SaveConfig();//save and return
return; return;
} }
err = fscanf(f, "interlace = %hhx\n", &conf.interlace); err = fscanf(f, "interlace = %hhx\n", &conf.interlace);
err = fscanf(f, "mrtdepth = %hhx\n", &conf.mrtdepth); err = fscanf(f, "mrtdepth = %hhx\n", &conf.mrtdepth);
err = fscanf(f, "options = %x\n", &conf.options);//u32 err = fscanf(f, "options = %x\n", &conf.options);//u32
err = fscanf(f, "bilinear = %hhx\n", &conf.bilinear); err = fscanf(f, "bilinear = %hhx\n", &conf.bilinear);
@ -86,23 +90,29 @@ void LoadConfig()
fclose(f); fclose(f);
// filter bad files // filter bad files
if ((conf.aa < 0) || (conf.aa > 4)) conf.aa = 0; if ((conf.aa < 0) || (conf.aa > 4)) conf.aa = 0;
conf.isWideScreen = conf.options & GSOPTION_WIDESCREEN; conf.isWideScreen = conf.options & GSOPTION_WIDESCREEN;
switch(conf.options & GSOPTION_WINDIMS)
switch (conf.options & GSOPTION_WINDIMS)
{ {
case GSOPTION_WIN640: case GSOPTION_WIN640:
conf.width = 640; conf.width = 640;
conf.height = conf.isWideScreen ? 360 : 480; conf.height = conf.isWideScreen ? 360 : 480;
break; break;
case GSOPTION_WIN800: case GSOPTION_WIN800:
conf.width = 800; conf.width = 800;
conf.height = conf.isWideScreen ? 450 : 600; conf.height = conf.isWideScreen ? 450 : 600;
break; break;
case GSOPTION_WIN1024: case GSOPTION_WIN1024:
conf.width = 1024; conf.width = 1024;
conf.height = conf.isWideScreen ? 576 : 768; conf.height = conf.isWideScreen ? 576 : 768;
break; break;
case GSOPTION_WIN1280: case GSOPTION_WIN1280:
conf.width = 1280; conf.width = 1280;
conf.height = conf.isWideScreen ? 720 : 960; conf.height = conf.isWideScreen ? 720 : 960;
@ -111,14 +121,16 @@ void LoadConfig()
// turn off all hacks by default // turn off all hacks by default
conf.options &= ~(GSOPTION_WIREFRAME | GSOPTION_CAPTUREAVI); conf.options &= ~(GSOPTION_WIREFRAME | GSOPTION_CAPTUREAVI);
conf.options |= GSOPTION_LOADED; conf.options |= GSOPTION_LOADED;
if( conf.width <= 0 || conf.height <= 0 ) if (conf.width <= 0 || conf.height <= 0)
{ {
conf.width = 640; conf.width = 640;
conf.height = 480; conf.height = 480;
} }
if( conf.x <= 0 || conf.y <= 0 )
if (conf.x <= 0 || conf.y <= 0)
{ {
conf.x = 0; conf.x = 0;
conf.y = 0; conf.y = 0;

284
plugins/zzogl-pg/opengl/Linux/Linux.cpp
View File

@ -35,37 +35,44 @@ void CALLBACK GSkeyEvent(keyEvent *ev)
//static bool bShift = false; //static bool bShift = false;
static bool bAlt = false; static bool bAlt = false;
switch(ev->evt) { switch (ev->evt)
{
case KEYPRESS: case KEYPRESS:
switch(ev->key) { switch (ev->key)
{
case XK_F5: case XK_F5:
case XK_F6: case XK_F6:
case XK_F7: case XK_F7:
case XK_F9: case XK_F9:
THR_KeyEvent = ev->key ; THR_KeyEvent = ev->key ;
break; break;
case XK_Escape: case XK_Escape:
if (conf.options & GSOPTION_FULLSCREEN) if (conf.options & GSOPTION_FULLSCREEN) GSclose();
GSclose();
break; break;
case XK_Shift_L: case XK_Shift_L:
case XK_Shift_R: case XK_Shift_R:
//bShift = true; //bShift = true;
THR_bShift = true; THR_bShift = true;
break; break;
case XK_Alt_L: case XK_Alt_L:
case XK_Alt_R: case XK_Alt_R:
bAlt = true; bAlt = true;
break; break;
} }
break; break;
case KEYRELEASE: case KEYRELEASE:
switch(ev->key) { switch (ev->key)
{
case XK_Shift_L: case XK_Shift_L:
case XK_Shift_R: case XK_Shift_R:
//bShift = false; //bShift = false;
THR_bShift = false; THR_bShift = false;
break; break;
case XK_Alt_L: case XK_Alt_L:
case XK_Alt_R: case XK_Alt_R:
bAlt = false; bAlt = false;
@ -91,7 +98,7 @@ void CreateGameHackTable(GtkWidget *treeview)
GtkTreeViewColumn *treecol; GtkTreeViewColumn *treecol;
//--------- Let's build a treeview for our advanced options! --------// //--------- Let's build a treeview for our advanced options! --------//
treestore = gtk_list_store_new(2,G_TYPE_BOOLEAN, G_TYPE_STRING); treestore = gtk_list_store_new(2, G_TYPE_BOOLEAN, G_TYPE_STRING);
//setup columns in treeview //setup columns in treeview
//COLUMN 0 is the checkboxes //COLUMN 0 is the checkboxes
@ -139,15 +146,16 @@ void CreateGameHackTable(GtkWidget *treeview)
add_map_entry(GAME_NOLOGZ, "20000000", "No logarithmic Z, could decrease number of Z-artefacts - 20000000"); add_map_entry(GAME_NOLOGZ, "20000000", "No logarithmic Z, could decrease number of Z-artefacts - 20000000");
add_map_entry(GAME_INTERLACE2X, "00000004", "Interlace 2X - 00000004\nFixes 2x bigger screen (Gradius 3)."); add_map_entry(GAME_INTERLACE2X, "00000004", "Interlace 2X - 00000004\nFixes 2x bigger screen (Gradius 3).");
for(map<string, confOptsStruct>::iterator it = mapConfOpts.begin(); it != mapConfOpts.end(); ++it) for (map<string, confOptsStruct>::iterator it = mapConfOpts.begin(); it != mapConfOpts.end(); ++it)
{ {
gtk_list_store_append(treestore, &treeiter);//new row gtk_list_store_append(treestore, &treeiter);//new row
itval = (conf.gamesettings&it->second.value)?TRUE:FALSE; itval = (conf.gamesettings & it->second.value) ? TRUE : FALSE;
snprintf(descbuf, 254, "%s", it->second.desc); snprintf(descbuf, 254, "%s", it->second.desc);
gtk_list_store_set(treestore, &treeiter, 0, itval, 1, descbuf, -1); gtk_list_store_set(treestore, &treeiter, 0, itval, 1, descbuf, -1);
} }
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));//NB: store is cast as tree model. gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));//NB: store is cast as tree model.
g_object_unref(treestore);//allow model to be destroyed when the tree is destroyed. g_object_unref(treestore);//allow model to be destroyed when the tree is destroyed.
//don't select/highlight rows //don't select/highlight rows
@ -166,17 +174,19 @@ void SaveGameHackTable(GtkWidget *treeview)
gtk_tree_model_get_iter_first(treemodel, &treeiter); gtk_tree_model_get_iter_first(treemodel, &treeiter);
conf.gamesettings = 0; conf.gamesettings = 0;
for(map<string, confOptsStruct>::iterator it = mapConfOpts.begin(); it != mapConfOpts.end(); ++it)
for (map<string, confOptsStruct>::iterator it = mapConfOpts.begin(); it != mapConfOpts.end(); ++it)
{ {
treeoptval = FALSE; treeoptval = FALSE;
gtk_tree_model_get(treemodel, &treeiter, 0, &treeoptval, -1); gtk_tree_model_get(treemodel, &treeiter, 0, &treeoptval, -1);
if(treeoptval) conf.gamesettings |= it->second.value; if (treeoptval) conf.gamesettings |= it->second.value;
gtk_tree_model_iter_next(treemodel,&treeiter); gtk_tree_model_iter_next(treemodel, &treeiter);
} }
GSsetGameCRC(0, conf.gamesettings); GSsetGameCRC(0, conf.gamesettings);
//---------- done getting advanced options ---------// //---------- done getting advanced options ---------//
} }
@ -193,94 +203,105 @@ void OnToggle_advopts(GtkCellRendererToggle *cell, gchar *path, gpointer user_da
void DisplayDialog() void DisplayDialog()
{ {
int return_value; int return_value;
GtkWidget *dialog; GtkWidget *dialog;
GtkWidget *main_frame, *main_box; GtkWidget *main_frame, *main_box;
GtkWidget *option_frame, *option_box; GtkWidget *option_frame, *option_box;
GtkWidget *log_check; GtkWidget *log_check;
GtkWidget *int_label, *int_box; GtkWidget *int_label, *int_box;
GtkWidget *bilinear_check, *bilinear_label; GtkWidget *bilinear_check, *bilinear_label;
GtkWidget *aa_label, *aa_box; GtkWidget *aa_label, *aa_box;
GtkWidget *wireframe_check, *avi_check; GtkWidget *wireframe_check, *avi_check;
GtkWidget *snap_label, *snap_box; GtkWidget *snap_label, *snap_box;
GtkWidget *size_label, *size_box; GtkWidget *size_label, *size_box;
GtkWidget *fullscreen_check, *widescreen_check; GtkWidget *fullscreen_check, *widescreen_check;
GtkWidget *advanced_frame, *advanced_box; GtkWidget *advanced_frame, *advanced_box;
GtkWidget *advanced_scroll; GtkWidget *advanced_scroll;
GtkWidget *tree; GtkWidget *tree;
if (!(conf.options & GSOPTION_LOADED)) LoadConfig(); if (!(conf.options & GSOPTION_LOADED)) LoadConfig();
/* Create the widgets */ /* Create the widgets */
dialog = gtk_dialog_new_with_buttons ( dialog = gtk_dialog_new_with_buttons(
"ZZOgl PG Config", "ZZOgl PG Config",
NULL, /* parent window*/ NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_CANCEL, GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT, GTK_RESPONSE_ACCEPT,
NULL); NULL);
log_check = gtk_check_button_new_with_label("Logging (For Debugging):"); log_check = gtk_check_button_new_with_label("Logging (For Debugging):");
int_label = gtk_label_new ("Interlacing: (F5 to toggle)");
int_box = gtk_combo_box_new_text (); int_label = gtk_label_new("Interlacing: (F5 to toggle)");
gtk_combo_box_append_text(GTK_COMBO_BOX(int_box), "No Interlacing");
gtk_combo_box_append_text(GTK_COMBO_BOX(int_box), "Interlace 0"); int_box = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(int_box), "Interlace 1");
gtk_combo_box_set_active(GTK_COMBO_BOX(int_box), conf.interlace); gtk_combo_box_append_text(GTK_COMBO_BOX(int_box), "No Interlacing");
gtk_combo_box_append_text(GTK_COMBO_BOX(int_box), "Interlace 0");
gtk_combo_box_append_text(GTK_COMBO_BOX(int_box), "Interlace 1");
gtk_combo_box_set_active(GTK_COMBO_BOX(int_box), conf.interlace);
bilinear_check = gtk_check_button_new_with_label("Bilinear Filtering (Shift + F5)"); bilinear_check = gtk_check_button_new_with_label("Bilinear Filtering (Shift + F5)");
bilinear_label = gtk_label_new ("Best quality is off. Turn on for speed."); bilinear_label = gtk_label_new("Best quality is off. Turn on for speed.");
aa_label = gtk_label_new ("Anti-Aliasing for Higher Quality(F6)"); aa_label = gtk_label_new("Anti-Aliasing for Higher Quality(F6)");
aa_box = gtk_combo_box_new_text (); aa_box = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "1X - No Anti-Aliasing");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "2X - Anti-Aliasing x 2");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "4X - Anti-Aliasing x 4");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "8X - Anti-Aliasing x 8");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "16X - Anti-Aliasing x 16");
gtk_combo_box_set_active(GTK_COMBO_BOX(aa_box), conf.aa);
wireframe_check = gtk_check_button_new_with_label("Wireframe Rendering(Shift + F6)"); gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "1X - No Anti-Aliasing");
avi_check = gtk_check_button_new_with_label("Capture Avi (as zerogs.avi)(F7)"); gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "2X - Anti-Aliasing x 2");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "4X - Anti-Aliasing x 4");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "8X - Anti-Aliasing x 8");
gtk_combo_box_append_text(GTK_COMBO_BOX(aa_box), "16X - Anti-Aliasing x 16");
gtk_combo_box_set_active(GTK_COMBO_BOX(aa_box), conf.aa);
snap_label = gtk_label_new ("Snapshot format:"); wireframe_check = gtk_check_button_new_with_label("Wireframe Rendering(Shift + F6)");
snap_box = gtk_combo_box_new_text (); avi_check = gtk_check_button_new_with_label("Capture Avi (as zerogs.avi)(F7)");
gtk_combo_box_append_text(GTK_COMBO_BOX(snap_box), "JPEG");
gtk_combo_box_append_text(GTK_COMBO_BOX(snap_box), "TIFF");
gtk_combo_box_set_active(GTK_COMBO_BOX(snap_box), conf.options&GSOPTION_TGASNAP);
fullscreen_check = gtk_check_button_new_with_label("Fullscreen (Alt + Enter)"); snap_label = gtk_label_new("Snapshot format:");
snap_box = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(snap_box), "JPEG");
gtk_combo_box_append_text(GTK_COMBO_BOX(snap_box), "TIFF");
gtk_combo_box_set_active(GTK_COMBO_BOX(snap_box), conf.options & GSOPTION_TGASNAP);
fullscreen_check = gtk_check_button_new_with_label("Fullscreen (Alt + Enter)");
widescreen_check = gtk_check_button_new_with_label("Widescreen"); widescreen_check = gtk_check_button_new_with_label("Widescreen");
size_label = gtk_label_new ("Default Window Size: (no speed impact)"); size_label = gtk_label_new("Default Window Size: (no speed impact)");
size_box = gtk_combo_box_new_text ();
gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "640x480");
gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "800x600");
gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "1024x768");
gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "1280x960");
gtk_combo_box_set_active(GTK_COMBO_BOX(size_box), (conf.options&GSOPTION_WINDIMS)>>4);
main_box = gtk_hbox_new(false, 5); size_box = gtk_combo_box_new_text();
main_frame = gtk_frame_new ("ZZOgl PG Config");
gtk_container_add (GTK_CONTAINER(main_frame), main_box);
option_box = gtk_vbox_new(false, 5); gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "640x480");
option_frame = gtk_frame_new (""); gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "800x600");
gtk_container_add (GTK_CONTAINER(option_frame), option_box); gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "1024x768");
gtk_combo_box_append_text(GTK_COMBO_BOX(size_box), "1280x960");
advanced_box = gtk_vbox_new(false, 5); gtk_combo_box_set_active(GTK_COMBO_BOX(size_box), (conf.options&GSOPTION_WINDIMS) >> 4);
advanced_frame = gtk_frame_new ("Advanced Settings:");
gtk_container_add (GTK_CONTAINER(advanced_frame), advanced_box); main_box = gtk_hbox_new(false, 5);
main_frame = gtk_frame_new("ZZOgl PG Config");
gtk_container_add(GTK_CONTAINER(main_frame), main_box);
option_box = gtk_vbox_new(false, 5);
option_frame = gtk_frame_new("");
gtk_container_add(GTK_CONTAINER(option_frame), option_box);
advanced_box = gtk_vbox_new(false, 5);
advanced_frame = gtk_frame_new("Advanced Settings:");
gtk_container_add(GTK_CONTAINER(advanced_frame), advanced_box);
tree = gtk_tree_view_new(); tree = gtk_tree_view_new();
CreateGameHackTable(tree); CreateGameHackTable(tree);
advanced_scroll = gtk_scrolled_window_new(NULL, NULL); advanced_scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(advanced_scroll), tree); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(advanced_scroll), tree);
gtk_box_pack_start(GTK_BOX(option_box), log_check, false, false, 2); gtk_box_pack_start(GTK_BOX(option_box), log_check, false, false, 2);
@ -298,68 +319,80 @@ void DisplayDialog()
gtk_box_pack_start(GTK_BOX(option_box), widescreen_check, false, false, 2); gtk_box_pack_start(GTK_BOX(option_box), widescreen_check, false, false, 2);
gtk_box_pack_start(GTK_BOX(option_box), size_label, false, false, 2); gtk_box_pack_start(GTK_BOX(option_box), size_label, false, false, 2);
gtk_box_pack_start(GTK_BOX(option_box), size_box, false, false, 2); gtk_box_pack_start(GTK_BOX(option_box), size_box, false, false, 2);
gtk_box_pack_start(GTK_BOX(advanced_box), advanced_scroll, true, true, 2); gtk_box_pack_start(GTK_BOX(advanced_box), advanced_scroll, true, true, 2);
gtk_box_pack_start(GTK_BOX(main_box), option_frame, false, false, 2); gtk_box_pack_start(GTK_BOX(main_box), option_frame, false, false, 2);
gtk_box_pack_start(GTK_BOX(main_box), advanced_frame, true, true, 2); gtk_box_pack_start(GTK_BOX(main_box), advanced_frame, true, true, 2);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_check), conf.log); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_check), conf.log);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bilinear_check), conf.bilinear); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bilinear_check), conf.bilinear);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wireframe_check), (conf.options & GSOPTION_WIREFRAME)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wireframe_check), (conf.options & GSOPTION_WIREFRAME));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(avi_check), (conf.options & GSOPTION_CAPTUREAVI)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(avi_check), (conf.options & GSOPTION_CAPTUREAVI));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fullscreen_check), (conf.options & GSOPTION_FULLSCREEN)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fullscreen_check), (conf.options & GSOPTION_FULLSCREEN));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widescreen_check), (conf.options & GSOPTION_WIDESCREEN)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widescreen_check), (conf.options & GSOPTION_WIDESCREEN));
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_frame); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), main_frame);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_show_all(dialog);
if (return_value == GTK_RESPONSE_ACCEPT) return_value = gtk_dialog_run(GTK_DIALOG(dialog));
{
int fake_options = 0; if (return_value == GTK_RESPONSE_ACCEPT)
SaveGameHackTable(tree); {
int fake_options = 0;
if (gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)) != -1) SaveGameHackTable(tree);
if (gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)) != -1)
conf.interlace = gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)); conf.interlace = gtk_combo_box_get_active(GTK_COMBO_BOX(int_box));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(aa_box)) != -1) if (gtk_combo_box_get_active(GTK_COMBO_BOX(aa_box)) != -1)
conf.aa = gtk_combo_box_get_active(GTK_COMBO_BOX(aa_box)); conf.aa = gtk_combo_box_get_active(GTK_COMBO_BOX(aa_box));
conf.negaa = 0; conf.negaa = 0;
switch(gtk_combo_box_get_active(GTK_COMBO_BOX(size_box))) switch (gtk_combo_box_get_active(GTK_COMBO_BOX(size_box)))
{ {
case 0: fake_options |= GSOPTION_WIN640; break; case 0:
case 1: fake_options |= GSOPTION_WIN800; break; fake_options |= GSOPTION_WIN640;
case 2: fake_options |= GSOPTION_WIN1024; break; break;
case 3: fake_options |= GSOPTION_WIN1280; break;
case 1:
fake_options |= GSOPTION_WIN800;
break;
case 2:
fake_options |= GSOPTION_WIN1024;
break;
case 3:
fake_options |= GSOPTION_WIN1280;
break;
} }
conf.log = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_check)); conf.log = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_check));
conf.bilinear = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(bilinear_check)); conf.bilinear = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(bilinear_check));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wireframe_check))) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wireframe_check)))
fake_options |= GSOPTION_WIREFRAME; fake_options |= GSOPTION_WIREFRAME;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(avi_check))) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(avi_check)))
fake_options |= GSOPTION_CAPTUREAVI; fake_options |= GSOPTION_CAPTUREAVI;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fullscreen_check))) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fullscreen_check)))
fake_options |= GSOPTION_FULLSCREEN; fake_options |= GSOPTION_FULLSCREEN;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widescreen_check))) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widescreen_check)))
fake_options |= GSOPTION_WIDESCREEN; fake_options |= GSOPTION_WIDESCREEN;
if (gtk_combo_box_get_active(GTK_COMBO_BOX(snap_box)) == 1) if (gtk_combo_box_get_active(GTK_COMBO_BOX(snap_box)) == 1)
fake_options |= GSOPTION_TGASNAP; fake_options |= GSOPTION_TGASNAP;
conf.options = fake_options; conf.options = fake_options;
SaveConfig();
}
gtk_widget_destroy (dialog); SaveConfig();
}
gtk_widget_destroy(dialog);
} }
void CALLBACK GSconfigure() void CALLBACK GSconfigure()
@ -374,23 +407,26 @@ void CALLBACK GSconfigure()
void SysMessage(const char *fmt, ...) void SysMessage(const char *fmt, ...)
{ {
va_list list; va_list list;
char msg[512]; char msg[512];
va_start(list, fmt); va_start(list, fmt);
vsprintf(msg, fmt, list); vsprintf(msg, fmt, list);
va_end(list); va_end(list);
if (msg[strlen(msg)-1] == '\n') msg[strlen(msg)-1] = 0; if (msg[strlen(msg)-1] == '\n') msg[strlen(msg)-1] = 0;
GtkWidget *dialog; GtkWidget *dialog;
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT, dialog = gtk_message_dialog_new(NULL,
GTK_MESSAGE_INFO, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_BUTTONS_OK, GTK_MESSAGE_INFO,
"%s", msg); GTK_BUTTONS_OK,
gtk_dialog_run (GTK_DIALOG (dialog)); "%s", msg);
gtk_widget_destroy (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
} }
void CALLBACK GSabout() void CALLBACK GSabout()
@ -411,7 +447,9 @@ void *SysLoadLibrary(char *lib)
void *SysLoadSym(void *lib, char *sym) void *SysLoadSym(void *lib, char *sym)
{ {
void *ret = dlsym(lib, sym); void *ret = dlsym(lib, sym);
if (ret == NULL) printf("null: %s\n", sym); if (ret == NULL) printf("null: %s\n", sym);
return dlsym(lib, sym); return dlsym(lib, sym);
} }

95
plugins/zzogl-pg/opengl/Mem.cpp
View File

@ -57,8 +57,8 @@ static __forceinline const T* AlignOnBlockBoundry(TransferData data, TransferFun
{ {
/* hack */ /* hack */
int testwidth = (int)nSize - int testwidth = (int)nSize -
(gs.imageEndY - gs.imageY) * (gs.imageEndX - gs.trxpos.dx) (gs.imageEndY - gs.imageY) * (gs.imageEndX - gs.trxpos.dx)
+ (gs.imageX - gs.trxpos.dx); + (gs.imageX - gs.trxpos.dx);
if ((testwidth <= data.widthlimit) && (testwidth >= -data.widthlimit)) if ((testwidth <= data.widthlimit) && (testwidth >= -data.widthlimit))
{ {
@ -67,17 +67,19 @@ static __forceinline const T* AlignOnBlockBoundry(TransferData data, TransferFun
//ZZLog::Error_Log("Bad texture: testwidth = %d; data.widthlimit = %d", testwidth, data.widthlimit); //ZZLog::Error_Log("Bad texture: testwidth = %d; data.widthlimit = %d", testwidth, data.widthlimit);
gs.imageTransfer = -1; gs.imageTransfer = -1;
} }
bCanAlign = false; bCanAlign = false;
} }
/* first align on block boundary */ /* first align on block boundary */
if ( MOD_POW2(gs.imageY, data.blockheight) || !bCanAlign ) if (MOD_POW2(gs.imageY, data.blockheight) || !bCanAlign)
{ {
u32 transwidth; u32 transwidth;
if( !bCanAlign ) if (!bCanAlign)
endY = gs.imageEndY; /* transfer the whole image */ endY = gs.imageEndY; /* transfer the whole image */
else else
assert( endY < gs.imageEndY); /* part of alignment condition */ assert(endY < gs.imageEndY); /* part of alignment condition */
if (((gs.imageEndX - gs.trxpos.dx) % data.widthlimit) || ((gs.imageEndX - gs.imageX) % data.widthlimit)) if (((gs.imageEndX - gs.trxpos.dx) % data.widthlimit) || ((gs.imageEndX - gs.imageX) % data.widthlimit))
{ {
@ -90,10 +92,12 @@ static __forceinline const T* AlignOnBlockBoundry(TransferData data, TransferFun
} }
pbuf = TransmitHostLocalY<T>(data, fun.wp, transwidth, endY, pbuf); pbuf = TransmitHostLocalY<T>(data, fun.wp, transwidth, endY, pbuf);
if (pbuf == NULL) return NULL; if (pbuf == NULL) return NULL;
if( nSize == 0 || tempY == gs.imageEndY ) return NULL; if (nSize == 0 || tempY == gs.imageEndY) return NULL;
} }
return pbuf; return pbuf;
} }
@ -112,43 +116,45 @@ static __forceinline const T* TransferAligningToBlocks(TransferData data, Transf
/* on top of checking whether pbuf is aligned, make sure that the width is at least aligned to its limits (due to bugs in pcsx2) */ /* on top of checking whether pbuf is aligned, make sure that the width is at least aligned to its limits (due to bugs in pcsx2) */
bAligned = !((uptr)pbuf & 0xf) && (TransPitch(pitch, data.transfersize) & 0xf) == 0; bAligned = !((uptr)pbuf & 0xf) && (TransPitch(pitch, data.transfersize) & 0xf) == 0;
if ( bAligned || ((DSTPSM==PSMCT24) || (DSTPSM==PSMT8H) || (DSTPSM==PSMT4HH) || (DSTPSM==PSMT4HL))) if (bAligned || ((DSTPSM == PSMCT24) || (DSTPSM == PSMT8H) || (DSTPSM == PSMT4HH) || (DSTPSM == PSMT4HL)))
swizzle = (fun.Swizzle); swizzle = (fun.Swizzle);
else else
swizzle = (fun.Swizzle_u); swizzle = (fun.Swizzle_u);
//Transfer aligning to blocks. //Transfer aligning to blocks.
for(; tempY < alignedPt.y && nSize >= area; tempY += data.blockheight, nSize -= area) for (; tempY < alignedPt.y && nSize >= area; tempY += data.blockheight, nSize -= area)
{ {
for(int tempj = gs.trxpos.dx; tempj < alignedPt.x; tempj += data.blockwidth, pbuf += TransPitch(data.blockwidth, data.transfersize)/TSize) for (int tempj = gs.trxpos.dx; tempj < alignedPt.x; tempj += data.blockwidth, pbuf += TransPitch(data.blockwidth, data.transfersize) / TSize)
{ {
u8 *temp = pstart + fun.gp(tempj, tempY, gs.dstbuf.bw) * data.blockbits/8; u8 *temp = pstart + fun.gp(tempj, tempY, gs.dstbuf.bw) * data.blockbits / 8;
swizzle(temp, (u8*)pbuf, TransPitch(pitch, data.transfersize), 0xffffffff); swizzle(temp, (u8*)pbuf, TransPitch(pitch, data.transfersize), 0xffffffff);
} }
/* transfer the rest */ /* transfer the rest */
if (alignedPt.x < gs.imageEndX) if (alignedPt.x < gs.imageEndX)
{ {
pbuf = TransmitHostLocalX<T>(data, fun.wp, data.widthlimit, data.blockheight, alignedPt.x, pbuf); pbuf = TransmitHostLocalX<T>(data, fun.wp, data.widthlimit, data.blockheight, alignedPt.x, pbuf);
if (pbuf == NULL) return NULL; if (pbuf == NULL) return NULL;
pbuf -= TransPitch((alignedPt.x - gs.trxpos.dx), data.transfersize)/TSize; pbuf -= TransPitch((alignedPt.x - gs.trxpos.dx), data.transfersize) / TSize;
} }
else else
{ {
pbuf += (data.blockheight - 1)* TransPitch(pitch, data.transfersize)/TSize; pbuf += (data.blockheight - 1) * TransPitch(pitch, data.transfersize) / TSize;
} }
tempX = gs.trxpos.dx; tempX = gs.trxpos.dx;
} }
return pbuf; return pbuf;
} }
static __forceinline int FinishTransfer(TransferData data, int nLeftOver) static __forceinline int FinishTransfer(TransferData data, int nLeftOver)
{ {
if( tempY >= gs.imageEndY ) if (tempY >= gs.imageEndY)
{ {
assert( gs.imageTransfer == -1 || tempY == gs.imageEndY ); assert(gs.imageTransfer == -1 || tempY == gs.imageEndY);
gs.imageTransfer = -1; gs.imageTransfer = -1;
/*int start, end; /*int start, end;
ZeroGS::GetRectMemAddress(start, end, gs.dstbuf.psm, gs.trxpos.dx, gs.trxpos.dy, gs.imageWnew, gs.imageHnew, gs.dstbuf.bp, gs.dstbuf.bw); ZeroGS::GetRectMemAddress(start, end, gs.dstbuf.psm, gs.trxpos.dx, gs.trxpos.dy, gs.imageWnew, gs.imageHnew, gs.dstbuf.bp, gs.dstbuf.bw);
@ -161,22 +167,23 @@ static __forceinline int FinishTransfer(TransferData data, int nLeftOver)
gs.imageX = tempX; gs.imageX = tempX;
} }
return (nSize * TransPitch(2, data.transfersize) + nLeftOver)/2; return (nSize * TransPitch(2, data.transfersize) + nLeftOver) / 2;
} }
template <class T> template <class T>
static __forceinline int RealTransfer(TransferData data, TransferFuncts fun, const void* pbyMem, u32 nQWordSize) static __forceinline int RealTransfer(TransferData data, TransferFuncts fun, const void* pbyMem, u32 nQWordSize)
{ {
assert( gs.imageTransfer == 0 ); assert(gs.imageTransfer == 0);
pstart = g_pbyGSMemory + gs.dstbuf.bp*256; pstart = g_pbyGSMemory + gs.dstbuf.bp * 256;
const T* pbuf = (const T*)pbyMem; const T* pbuf = (const T*)pbyMem;
const int tp2 = TransPitch(2, data.transfersize); const int tp2 = TransPitch(2, data.transfersize);
int nLeftOver = (nQWordSize*4*2)%tp2; int nLeftOver = (nQWordSize * 4 * 2) % tp2;
tempY = gs.imageY; tempX = gs.imageX; tempY = gs.imageY;
tempX = gs.imageX;
Point alignedPt; Point alignedPt;
nSize = (nQWordSize*4*2)/tp2; nSize = (nQWordSize * 4 * 2) / tp2;
nSize = min(nSize, gs.imageWnew * gs.imageHnew); nSize = min(nSize, gs.imageWnew * gs.imageHnew);
int endY = ROUND_UPPOW2(gs.imageY, data.blockheight); int endY = ROUND_UPPOW2(gs.imageY, data.blockheight);
@ -184,17 +191,21 @@ static __forceinline int RealTransfer(TransferData data, TransferFuncts fun, con
alignedPt.x = ROUND_DOWNPOW2(gs.imageEndX, data.blockwidth); alignedPt.x = ROUND_DOWNPOW2(gs.imageEndX, data.blockwidth);
pbuf = AlignOnBlockBoundry<T>(data, fun, alignedPt, endY, pbuf); pbuf = AlignOnBlockBoundry<T>(data, fun, alignedPt, endY, pbuf);
if (pbuf == NULL) return FinishTransfer(data, nLeftOver); if (pbuf == NULL) return FinishTransfer(data, nLeftOver);
pbuf = TransferAligningToBlocks<T>(data, fun, alignedPt, pbuf); pbuf = TransferAligningToBlocks<T>(data, fun, alignedPt, pbuf);
if (pbuf == NULL) return FinishTransfer(data, nLeftOver); if (pbuf == NULL) return FinishTransfer(data, nLeftOver);
if (TransPitch(nSize, data.transfersize)/4 > 0) if (TransPitch(nSize, data.transfersize) / 4 > 0)
{ {
pbuf = TransmitHostLocalY<T>(data, fun.wp, data.widthlimit, gs.imageEndY, pbuf); pbuf = TransmitHostLocalY<T>(data, fun.wp, data.widthlimit, gs.imageEndY, pbuf);
if (pbuf == NULL) return FinishTransfer(data, nLeftOver); if (pbuf == NULL) return FinishTransfer(data, nLeftOver);
/* sometimes wrong sizes are sent (tekken tag) */ /* sometimes wrong sizes are sent (tekken tag) */
assert( gs.imageTransfer == -1 || TransPitch(nSize, data.transfersize)/4 <= 2 ); assert(gs.imageTransfer == -1 || TransPitch(nSize, data.transfersize) / 4 <= 2);
} }
return FinishTransfer(data, nLeftOver); return FinishTransfer(data, nLeftOver);
@ -203,7 +214,7 @@ static __forceinline int RealTransfer(TransferData data, TransferFuncts fun, con
//DEFINE_TRANSFERLOCAL(32, u32, 2, 32, 8, 8, _, SwizzleBlock32); //DEFINE_TRANSFERLOCAL(32, u32, 2, 32, 8, 8, _, SwizzleBlock32);
int TransferHostLocal32(const void* pbyMem, u32 nQWordSize) int TransferHostLocal32(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(2,32,8,8,32, PSM_); TransferData data(2, 32, 8, 8, 32, PSM_);
TransferFuncts fun(writePixel32_0, getPixelAddress32_0, SwizzleBlock32, SwizzleBlock32u); TransferFuncts fun(writePixel32_0, getPixelAddress32_0, SwizzleBlock32, SwizzleBlock32u);
return RealTransfer<u32>(data, fun, pbyMem, nQWordSize); return RealTransfer<u32>(data, fun, pbyMem, nQWordSize);
@ -212,7 +223,7 @@ int TransferHostLocal32(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(32Z, u32, 2, 32, 8, 8, _, SwizzleBlock32); //DEFINE_TRANSFERLOCAL(32Z, u32, 2, 32, 8, 8, _, SwizzleBlock32);
int TransferHostLocal32Z(const void* pbyMem, u32 nQWordSize) int TransferHostLocal32Z(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(2,32,8,8,32, PSM_); TransferData data(2, 32, 8, 8, 32, PSM_);
TransferFuncts fun(writePixel32Z_0, getPixelAddress32Z_0, SwizzleBlock32, SwizzleBlock32u); TransferFuncts fun(writePixel32Z_0, getPixelAddress32Z_0, SwizzleBlock32, SwizzleBlock32u);
return RealTransfer<u32>(data, fun, pbyMem, nQWordSize); return RealTransfer<u32>(data, fun, pbyMem, nQWordSize);
@ -221,7 +232,7 @@ int TransferHostLocal32Z(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(24, u8, 8, 32, 8, 8, _24, SwizzleBlock24); //DEFINE_TRANSFERLOCAL(24, u8, 8, 32, 8, 8, _24, SwizzleBlock24);
int TransferHostLocal24(const void* pbyMem, u32 nQWordSize) int TransferHostLocal24(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(8,32,8,8,24, PSM_24_); TransferData data(8, 32, 8, 8, 24, PSM_24_);
TransferFuncts fun(writePixel24_0, getPixelAddress24_0, SwizzleBlock24, SwizzleBlock24u); TransferFuncts fun(writePixel24_0, getPixelAddress24_0, SwizzleBlock24, SwizzleBlock24u);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -230,7 +241,7 @@ int TransferHostLocal24(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(24Z, u8, 8, 32, 8, 8, _24, SwizzleBlock24); //DEFINE_TRANSFERLOCAL(24Z, u8, 8, 32, 8, 8, _24, SwizzleBlock24);
int TransferHostLocal24Z(const void* pbyMem, u32 nQWordSize) int TransferHostLocal24Z(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(8,32,8,8,24, PSM_24_); TransferData data(8, 32, 8, 8, 24, PSM_24_);
TransferFuncts fun(writePixel24Z_0, getPixelAddress24Z_0, SwizzleBlock24, SwizzleBlock24u); TransferFuncts fun(writePixel24Z_0, getPixelAddress24Z_0, SwizzleBlock24, SwizzleBlock24u);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -239,7 +250,7 @@ int TransferHostLocal24Z(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(16, u16, 4, 16, 16, 8, _, SwizzleBlock16); //DEFINE_TRANSFERLOCAL(16, u16, 4, 16, 16, 8, _, SwizzleBlock16);
int TransferHostLocal16(const void* pbyMem, u32 nQWordSize) int TransferHostLocal16(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(4,16,16,8,16, PSM_); TransferData data(4, 16, 16, 8, 16, PSM_);
TransferFuncts fun(writePixel16_0, getPixelAddress16_0, SwizzleBlock16, SwizzleBlock16u); TransferFuncts fun(writePixel16_0, getPixelAddress16_0, SwizzleBlock16, SwizzleBlock16u);
return RealTransfer<u16>(data, fun, pbyMem, nQWordSize); return RealTransfer<u16>(data, fun, pbyMem, nQWordSize);
@ -248,7 +259,7 @@ int TransferHostLocal16(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(16S, u16, 4, 16, 16, 8, _, SwizzleBlock16); //DEFINE_TRANSFERLOCAL(16S, u16, 4, 16, 16, 8, _, SwizzleBlock16);
int TransferHostLocal16S(const void* pbyMem, u32 nQWordSize) int TransferHostLocal16S(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(4,16,16,8,16, PSM_); TransferData data(4, 16, 16, 8, 16, PSM_);
TransferFuncts fun(writePixel16S_0, getPixelAddress16S_0, SwizzleBlock16, SwizzleBlock16u); TransferFuncts fun(writePixel16S_0, getPixelAddress16S_0, SwizzleBlock16, SwizzleBlock16u);
return RealTransfer<u16>(data, fun, pbyMem, nQWordSize); return RealTransfer<u16>(data, fun, pbyMem, nQWordSize);
@ -257,7 +268,7 @@ int TransferHostLocal16S(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(16Z, u16, 4, 16, 16, 8, _, SwizzleBlock16); //DEFINE_TRANSFERLOCAL(16Z, u16, 4, 16, 16, 8, _, SwizzleBlock16);
int TransferHostLocal16Z(const void* pbyMem, u32 nQWordSize) int TransferHostLocal16Z(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(4,16,16,8,16, PSM_); TransferData data(4, 16, 16, 8, 16, PSM_);
TransferFuncts fun(writePixel16Z_0, getPixelAddress16Z_0, SwizzleBlock16, SwizzleBlock16u); TransferFuncts fun(writePixel16Z_0, getPixelAddress16Z_0, SwizzleBlock16, SwizzleBlock16u);
return RealTransfer<u16>(data, fun, pbyMem, nQWordSize); return RealTransfer<u16>(data, fun, pbyMem, nQWordSize);
@ -266,7 +277,7 @@ int TransferHostLocal16Z(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(16SZ, u16, 4, 16, 16, 8, _, SwizzleBlock16); //DEFINE_TRANSFERLOCAL(16SZ, u16, 4, 16, 16, 8, _, SwizzleBlock16);
int TransferHostLocal16SZ(const void* pbyMem, u32 nQWordSize) int TransferHostLocal16SZ(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(4,16,16,8,16, PSM_); TransferData data(4, 16, 16, 8, 16, PSM_);
TransferFuncts fun(writePixel16SZ_0, getPixelAddress16SZ_0, SwizzleBlock16, SwizzleBlock16u); TransferFuncts fun(writePixel16SZ_0, getPixelAddress16SZ_0, SwizzleBlock16, SwizzleBlock16u);
return RealTransfer<u16>(data, fun, pbyMem, nQWordSize); return RealTransfer<u16>(data, fun, pbyMem, nQWordSize);
@ -275,7 +286,7 @@ int TransferHostLocal16SZ(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(8, u8, 4, 8, 16, 16, _, SwizzleBlock8); //DEFINE_TRANSFERLOCAL(8, u8, 4, 8, 16, 16, _, SwizzleBlock8);
int TransferHostLocal8(const void* pbyMem, u32 nQWordSize) int TransferHostLocal8(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(4,8,16,16,8, PSM_); TransferData data(4, 8, 16, 16, 8, PSM_);
TransferFuncts fun(writePixel8_0, getPixelAddress8_0, SwizzleBlock8, SwizzleBlock8u); TransferFuncts fun(writePixel8_0, getPixelAddress8_0, SwizzleBlock8, SwizzleBlock8u);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -284,7 +295,7 @@ int TransferHostLocal8(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(4, u8, 8, 4, 32, 16, _4, SwizzleBlock4); //DEFINE_TRANSFERLOCAL(4, u8, 8, 4, 32, 16, _4, SwizzleBlock4);
int TransferHostLocal4(const void* pbyMem, u32 nQWordSize) int TransferHostLocal4(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(8,4,32,16,4, PSM_4_); TransferData data(8, 4, 32, 16, 4, PSM_4_);
TransferFuncts fun(writePixel4_0, getPixelAddress4_0, SwizzleBlock4, SwizzleBlock4u); TransferFuncts fun(writePixel4_0, getPixelAddress4_0, SwizzleBlock4, SwizzleBlock4u);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -293,7 +304,7 @@ int TransferHostLocal4(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(8H, u8, 4, 32, 8, 8, _, SwizzleBlock8H); //DEFINE_TRANSFERLOCAL(8H, u8, 4, 32, 8, 8, _, SwizzleBlock8H);
int TransferHostLocal8H(const void* pbyMem, u32 nQWordSize) int TransferHostLocal8H(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(4,32,8,8,8, PSM_); TransferData data(4, 32, 8, 8, 8, PSM_);
TransferFuncts fun(writePixel8H_0, getPixelAddress8H_0, SwizzleBlock8H, SwizzleBlock8Hu); TransferFuncts fun(writePixel8H_0, getPixelAddress8H_0, SwizzleBlock8H, SwizzleBlock8Hu);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -302,7 +313,7 @@ int TransferHostLocal8H(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(4HL, u8, 8, 32, 8, 8, _4, SwizzleBlock4HL); //DEFINE_TRANSFERLOCAL(4HL, u8, 8, 32, 8, 8, _4, SwizzleBlock4HL);
int TransferHostLocal4HL(const void* pbyMem, u32 nQWordSize) int TransferHostLocal4HL(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(8,32,8,8,4, PSM_4_); TransferData data(8, 32, 8, 8, 4, PSM_4_);
TransferFuncts fun(writePixel4HL_0, getPixelAddress4HL_0, SwizzleBlock4HL, SwizzleBlock4HLu); TransferFuncts fun(writePixel4HL_0, getPixelAddress4HL_0, SwizzleBlock4HL, SwizzleBlock4HLu);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -311,7 +322,7 @@ int TransferHostLocal4HL(const void* pbyMem, u32 nQWordSize)
//DEFINE_TRANSFERLOCAL(4HH, u8, 8, 32, 8, 8, _4, SwizzleBlock4HH); //DEFINE_TRANSFERLOCAL(4HH, u8, 8, 32, 8, 8, _4, SwizzleBlock4HH);
int TransferHostLocal4HH(const void* pbyMem, u32 nQWordSize) int TransferHostLocal4HH(const void* pbyMem, u32 nQWordSize)
{ {
TransferData data(8,32,8,8,4, PSM_4_); TransferData data(8, 32, 8, 8, 4, PSM_4_);
TransferFuncts fun(writePixel4HH_0, getPixelAddress4HH_0, SwizzleBlock4HH, SwizzleBlock4HHu); TransferFuncts fun(writePixel4HH_0, getPixelAddress4HH_0, SwizzleBlock4HH, SwizzleBlock4HHu);
return RealTransfer<u8>(data, fun, pbyMem, nQWordSize); return RealTransfer<u8>(data, fun, pbyMem, nQWordSize);
@ -382,24 +393,30 @@ void TransferLocalHost16SZ(void* pbyMem, u32 nQWordSize) {FUNCLOG}
b.TransferHostLocal = TransferHostLocal##psm; \ b.TransferHostLocal = TransferHostLocal##psm; \
b.TransferLocalHost = TransferLocalHost##psm; \ b.TransferLocalHost = TransferLocalHost##psm; \
} \ } \
void BLOCK::FillBlocks(vector<char>& vBlockData, vector<char>& vBilinearData, int floatfmt) void BLOCK::FillBlocks(vector<char>& vBlockData, vector<char>& vBilinearData, int floatfmt)
{ {
FUNCLOG FUNCLOG
vBlockData.resize(BLOCK_TEXWIDTH * BLOCK_TEXHEIGHT * (floatfmt ? 4 : 2)); vBlockData.resize(BLOCK_TEXWIDTH * BLOCK_TEXHEIGHT * (floatfmt ? 4 : 2));
if( floatfmt )
if (floatfmt)
vBilinearData.resize(BLOCK_TEXWIDTH * BLOCK_TEXHEIGHT * sizeof(Vector)); vBilinearData.resize(BLOCK_TEXWIDTH * BLOCK_TEXHEIGHT * sizeof(Vector));
int i, j; int i, j;
BLOCK b; BLOCK b;
float* psrcf = NULL; float* psrcf = NULL;
u16* psrcw = NULL; u16* psrcw = NULL;
Vector* psrcv = NULL; Vector* psrcv = NULL;
memset(m_Blocks, 0, sizeof(m_Blocks)); memset(m_Blocks, 0, sizeof(m_Blocks));
// 32 // 32
FILL_BLOCK(64, 32, 0, 0, 1, 32, 32); FILL_BLOCK(64, 32, 0, 0, 1, 32, 32);
m_Blocks[PSMCT32] = b; m_Blocks[PSMCT32] = b;
// 24 (same as 32 except write/readPixel are different) // 24 (same as 32 except write/readPixel are different)
@ -427,8 +444,8 @@ void BLOCK::FillBlocks(vector<char>& vBlockData, vector<char>& vBilinearData, in
m_Blocks[PSMT4HL].readPixel_0 = readPixel4HL_0; m_Blocks[PSMT4HL].readPixel_0 = readPixel4HL_0;
m_Blocks[PSMT4HL].TransferHostLocal = TransferHostLocal4HL; m_Blocks[PSMT4HL].TransferHostLocal = TransferHostLocal4HL;
m_Blocks[PSMT4HL].TransferLocalHost = TransferLocalHost4HL; m_Blocks[PSMT4HL].TransferLocalHost = TransferLocalHost4HL;
m_Blocks[PSMT4HH] = b; m_Blocks[PSMT4HH] = b;
m_Blocks[PSMT4HH].writePixel = writePixel4HH; m_Blocks[PSMT4HH].writePixel = writePixel4HH;
m_Blocks[PSMT4HH].writePixel_0 = writePixel4HH_0; m_Blocks[PSMT4HH].writePixel_0 = writePixel4HH_0;
m_Blocks[PSMT4HH].readPixel = readPixel4HH; m_Blocks[PSMT4HH].readPixel = readPixel4HH;

116
plugins/zzogl-pg/opengl/Mem_Swizzle.cpp
View File

@ -32,30 +32,37 @@ __forceinline void SwizzleBlock16(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock16_sse2(dst, src, pitch/*, WriteMask*/); SwizzleBlock16_sse2(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock8(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock8(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock8_sse2(dst, src, pitch/*, WriteMask*/); SwizzleBlock8_sse2(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock4(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock4(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock4_sse2(dst, src, pitch/*, WriteMask*/); SwizzleBlock4_sse2(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock32u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock32u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock32u_sse2(dst, src, pitch, WriteMask); SwizzleBlock32u_sse2(dst, src, pitch, WriteMask);
} }
__forceinline void SwizzleBlock16u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock16u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock16u_sse2(dst, src, pitch/*, WriteMask*/); SwizzleBlock16u_sse2(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock8u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock8u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock8u_sse2(dst, src, pitch/*, WriteMask*/); SwizzleBlock8u_sse2(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock4u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock4u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock4u_sse2(dst, src, pitch/*, WriteMask*/); SwizzleBlock4u_sse2(dst, src, pitch/*, WriteMask*/);
} }
#else #else
__forceinline void SwizzleBlock32(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock32(u8 *dst, u8 *src, int pitch, u32 WriteMask)
@ -67,26 +74,32 @@ __forceinline void SwizzleBlock16(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock16_c(dst, src, pitch/*, WriteMask*/); SwizzleBlock16_c(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock8(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock8(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock8_c(dst, src, pitch/*, WriteMask*/); SwizzleBlock8_c(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock4(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock4(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock4_c(dst, src, pitch/*, WriteMask*/); SwizzleBlock4_c(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock32u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock32u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock32_c(dst, src, pitch, WriteMask); SwizzleBlock32_c(dst, src, pitch, WriteMask);
} }
__forceinline void SwizzleBlock16u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock16u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock16_c(dst, src, pitch/*, WriteMask*/); SwizzleBlock16_c(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock8u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock8u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock8_c(dst, src, pitch/*, WriteMask*/); SwizzleBlock8_c(dst, src, pitch/*, WriteMask*/);
} }
__forceinline void SwizzleBlock4u(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock4u(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
SwizzleBlock4_c(dst, src, pitch/*, WriteMask*/); SwizzleBlock4_c(dst, src, pitch/*, WriteMask*/);
@ -96,16 +109,16 @@ __forceinline void __fastcall SwizzleBlock32_c(u8* dst, u8* src, int srcpitch, u
{ {
u32* d = &g_columnTable32[0][0]; u32* d = &g_columnTable32[0][0];
if(WriteMask == 0xffffffff) if (WriteMask == 0xffffffff)
{ {
for(int j = 0; j < 8; j++, d += 8, src += srcpitch) for (int j = 0; j < 8; j++, d += 8, src += srcpitch)
for(int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
((u32*)dst)[d[i]] = ((u32*)src)[i]; ((u32*)dst)[d[i]] = ((u32*)src)[i];
} }
else else
{ {
for(int j = 0; j < 8; j++, d += 8, src += srcpitch) for (int j = 0; j < 8; j++, d += 8, src += srcpitch)
for(int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
((u32*)dst)[d[i]] = (((u32*)dst)[d[i]] & ~WriteMask) | (((u32*)src)[i] & WriteMask); ((u32*)dst)[d[i]] = (((u32*)dst)[d[i]] & ~WriteMask) | (((u32*)src)[i] & WriteMask);
} }
} }
@ -115,16 +128,16 @@ __forceinline void __fastcall SwizzleBlock24_c(u8* dst, u8* src, int srcpitch, u
{ {
u32* d = &g_columnTable32[0][0]; u32* d = &g_columnTable32[0][0];
if(WriteMask == 0x00ffffff) if (WriteMask == 0x00ffffff)
{ {
for(int j = 0; j < 8; j++, d += 8, src += srcpitch) for (int j = 0; j < 8; j++, d += 8, src += srcpitch)
for(int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
((u32*)dst)[d[i]] = ((u32*)src)[i]; ((u32*)dst)[d[i]] = ((u32*)src)[i];
} }
else else
{ {
for(int j = 0; j < 8; j++, d += 8, src += srcpitch) for (int j = 0; j < 8; j++, d += 8, src += srcpitch)
for(int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
((u32*)dst)[d[i]] = (((u32*)dst)[d[i]] & ~WriteMask) | (((u32*)src)[i] & WriteMask); ((u32*)dst)[d[i]] = (((u32*)dst)[d[i]] & ~WriteMask) | (((u32*)src)[i] & WriteMask);
} }
} }
@ -133,8 +146,8 @@ __forceinline void __fastcall SwizzleBlock16_c(u8* dst, u8* src, int srcpitch, u
{ {
u32* d = &g_columnTable16[0][0]; u32* d = &g_columnTable16[0][0];
for(int j = 0; j < 8; j++, d += 16, src += srcpitch) for (int j = 0; j < 8; j++, d += 16, src += srcpitch)
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
((u16*)dst)[d[i]] = ((u16*)src)[i]; ((u16*)dst)[d[i]] = ((u16*)src)[i];
} }
@ -142,8 +155,8 @@ __forceinline void __fastcall SwizzleBlock8_c(u8* dst, u8* src, int srcpitch, u3
{ {
u32* d = &g_columnTable8[0][0]; u32* d = &g_columnTable8[0][0];
for(int j = 0; j < 16; j++, d += 16, src += srcpitch) for (int j = 0; j < 16; j++, d += 16, src += srcpitch)
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
dst[d[i]] = src[i]; dst[d[i]] = src[i];
} }
@ -151,41 +164,45 @@ __forceinline void __fastcall SwizzleBlock4_c(u8* dst, u8* src, int srcpitch, u3
{ {
u32* d = &g_columnTable4[0][0]; u32* d = &g_columnTable4[0][0];
for(int j = 0; j < 16; j++, d += 32, src += srcpitch) for (int j = 0; j < 16; j++, d += 32, src += srcpitch)
{ {
for(int i = 0; i < 32; i++) for (int i = 0; i < 32; i++)
{ {
u32 addr = d[i]; u32 addr = d[i];
u8 c = (src[i>>1] >> ((i&1) << 2)) & 0x0f; u8 c = (src[i>>1] >> ((i & 1) << 2)) & 0x0f;
u32 shift = (addr&1) << 2; u32 shift = (addr & 1) << 2;
dst[addr >> 1] = (dst[addr >> 1] & (0xf0 >> shift)) | (c << shift); dst[addr >> 1] = (dst[addr >> 1] & (0xf0 >> shift)) | (c << shift);
} }
} }
} }
#endif #endif
__forceinline void SwizzleBlock24(u8 *dst, u8 *src, int pitch, u32 WriteMask) __forceinline void SwizzleBlock24(u8 *dst, u8 *src, int pitch, u32 WriteMask)
{ {
u8* pnewsrc = src; u8* pnewsrc = src;
u32* pblock = tempblock; u32* pblock = tempblock;
for(int by = 0; by < 7; ++by, pblock += 8, pnewsrc += pitch-24) for (int by = 0; by < 7; ++by, pblock += 8, pnewsrc += pitch - 24)
{ {
for(int bx = 0; bx < 8; ++bx, pnewsrc += 3) for (int bx = 0; bx < 8; ++bx, pnewsrc += 3)
{ {
pblock[bx] = *(u32*)pnewsrc; pblock[bx] = *(u32*)pnewsrc;
} }
} }
for(int bx = 0; bx < 7; ++bx, pnewsrc += 3) for (int bx = 0; bx < 7; ++bx, pnewsrc += 3)
{ {
/* might be 1 byte out of bounds of GS memory */ /* might be 1 byte out of bounds of GS memory */
pblock[bx] = *(u32*)pnewsrc; pblock[bx] = *(u32*)pnewsrc;
} }
/* do 3 bytes for the last copy */ /* do 3 bytes for the last copy */
*((u8*)pblock+28) = pnewsrc[0]; *((u8*)pblock + 28) = pnewsrc[0];
*((u8*)pblock+29) = pnewsrc[1];
*((u8*)pblock+30) = pnewsrc[2]; *((u8*)pblock + 29) = pnewsrc[1];
*((u8*)pblock + 30) = pnewsrc[2];
SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0x00ffffff); SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0x00ffffff);
} }
@ -194,19 +211,20 @@ __forceinline void SwizzleBlock8H(u8 *dst, u8 *src, int pitch, u32 WriteMask)
u8* pnewsrc = src; u8* pnewsrc = src;
u32* pblock = tempblock; u32* pblock = tempblock;
for(int by = 0; by < 8; ++by, pblock += 8, pnewsrc += pitch) for (int by = 0; by < 8; ++by, pblock += 8, pnewsrc += pitch)
{ {
u32 u = *(u32*)pnewsrc; u32 u = *(u32*)pnewsrc;
pblock[0] = u<<24; pblock[0] = u << 24;
pblock[1] = u<<16; pblock[1] = u << 16;
pblock[2] = u<<8; pblock[2] = u << 8;
pblock[3] = u; pblock[3] = u;
u = *(u32*)(pnewsrc+4); u = *(u32*)(pnewsrc + 4);
pblock[4] = u<<24; pblock[4] = u << 24;
pblock[5] = u<<16; pblock[5] = u << 16;
pblock[6] = u<<8; pblock[6] = u << 8;
pblock[7] = u; pblock[7] = u;
} }
SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0xff000000); SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0xff000000);
} }
@ -215,18 +233,19 @@ __forceinline void SwizzleBlock4HH(u8 *dst, u8 *src, int pitch, u32 WriteMask)
u8* pnewsrc = src; u8* pnewsrc = src;
u32* pblock = tempblock; u32* pblock = tempblock;
for(int by = 0; by < 8; ++by, pblock += 8, pnewsrc += pitch) for (int by = 0; by < 8; ++by, pblock += 8, pnewsrc += pitch)
{ {
u32 u = *(u32*)pnewsrc; u32 u = *(u32*)pnewsrc;
pblock[0] = u<<28; pblock[0] = u << 28;
pblock[1] = u<<24; pblock[1] = u << 24;
pblock[2] = u<<20; pblock[2] = u << 20;
pblock[3] = u<<16; pblock[3] = u << 16;
pblock[4] = u<<12; pblock[4] = u << 12;
pblock[5] = u<<8; pblock[5] = u << 8;
pblock[6] = u<<4; pblock[6] = u << 4;
pblock[7] = u; pblock[7] = u;
} }
SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0xf0000000); SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0xf0000000);
} }
@ -235,17 +254,18 @@ __forceinline void SwizzleBlock4HL(u8 *dst, u8 *src, int pitch, u32 WriteMask)
u8* pnewsrc = src; u8* pnewsrc = src;
u32* pblock = tempblock; u32* pblock = tempblock;
for(int by = 0; by < 8; ++by, pblock += 8, pnewsrc += pitch) for (int by = 0; by < 8; ++by, pblock += 8, pnewsrc += pitch)
{ {
u32 u = *(u32*)pnewsrc; u32 u = *(u32*)pnewsrc;
pblock[0] = u<<24; pblock[0] = u << 24;
pblock[1] = u<<20; pblock[1] = u << 20;
pblock[2] = u<<16; pblock[2] = u << 16;
pblock[3] = u<<12; pblock[3] = u << 12;
pblock[4] = u<<8; pblock[4] = u << 8;
pblock[5] = u<<4; pblock[5] = u << 4;
pblock[6] = u; pblock[6] = u;
pblock[7] = u>>4; pblock[7] = u >> 4;
} }
SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0x0f000000); SwizzleBlock32((u8*)dst, (u8*)tempblock, 32, 0x0f000000);
} }

364
plugins/zzogl-pg/opengl/Mem_Tables.cpp
View File

@ -18,212 +18,224 @@
#include "GS.h" #include "GS.h"
u32 g_blockTable32[4][8] = { u32 g_blockTable32[4][8] =
{ 0, 1, 4, 5, 16, 17, 20, 21}, {
{ 2, 3, 6, 7, 18, 19, 22, 23}, { 0, 1, 4, 5, 16, 17, 20, 21},
{ 8, 9, 12, 13, 24, 25, 28, 29}, { 2, 3, 6, 7, 18, 19, 22, 23},
{ 10, 11, 14, 15, 26, 27, 30, 31} { 8, 9, 12, 13, 24, 25, 28, 29},
{ 10, 11, 14, 15, 26, 27, 30, 31}
}; };
u32 g_blockTable32Z[4][8] = { u32 g_blockTable32Z[4][8] =
{ 24, 25, 28, 29, 8, 9, 12, 13}, {
{ 26, 27, 30, 31, 10, 11, 14, 15}, { 24, 25, 28, 29, 8, 9, 12, 13},
{ 16, 17, 20, 21, 0, 1, 4, 5}, { 26, 27, 30, 31, 10, 11, 14, 15},
{ 18, 19, 22, 23, 2, 3, 6, 7} { 16, 17, 20, 21, 0, 1, 4, 5},
{ 18, 19, 22, 23, 2, 3, 6, 7}
}; };
u32 g_blockTable16[8][4] = { u32 g_blockTable16[8][4] =
{ 0, 2, 8, 10 }, {
{ 1, 3, 9, 11 }, { 0, 2, 8, 10 },
{ 4, 6, 12, 14 }, { 1, 3, 9, 11 },
{ 5, 7, 13, 15 }, { 4, 6, 12, 14 },
{ 16, 18, 24, 26 }, { 5, 7, 13, 15 },
{ 17, 19, 25, 27 }, { 16, 18, 24, 26 },
{ 20, 22, 28, 30 }, { 17, 19, 25, 27 },
{ 21, 23, 29, 31 } { 20, 22, 28, 30 },
{ 21, 23, 29, 31 }
}; };
u32 g_blockTable16S[8][4] = { u32 g_blockTable16S[8][4] =
{ 0, 2, 16, 18 }, {
{ 1, 3, 17, 19 }, { 0, 2, 16, 18 },
{ 8, 10, 24, 26 }, { 1, 3, 17, 19 },
{ 9, 11, 25, 27 }, { 8, 10, 24, 26 },
{ 4, 6, 20, 22 }, { 9, 11, 25, 27 },
{ 5, 7, 21, 23 }, { 4, 6, 20, 22 },
{ 12, 14, 28, 30 }, { 5, 7, 21, 23 },
{ 13, 15, 29, 31 } { 12, 14, 28, 30 },
{ 13, 15, 29, 31 }
}; };
u32 g_blockTable16Z[8][4] = { u32 g_blockTable16Z[8][4] =
{ 24, 26, 16, 18 }, {
{ 25, 27, 17, 19 }, { 24, 26, 16, 18 },
{ 28, 30, 20, 22 }, { 25, 27, 17, 19 },
{ 29, 31, 21, 23 }, { 28, 30, 20, 22 },
{ 8, 10, 0, 2 }, { 29, 31, 21, 23 },
{ 9, 11, 1, 3 }, { 8, 10, 0, 2 },
{ 12, 14, 4, 6 }, { 9, 11, 1, 3 },
{ 13, 15, 5, 7 } { 12, 14, 4, 6 },
{ 13, 15, 5, 7 }
}; };
u32 g_blockTable16SZ[8][4] = { u32 g_blockTable16SZ[8][4] =
{ 24, 26, 8, 10 }, {
{ 25, 27, 9, 11 }, { 24, 26, 8, 10 },
{ 16, 18, 0, 2 }, { 25, 27, 9, 11 },
{ 17, 19, 1, 3 }, { 16, 18, 0, 2 },
{ 28, 30, 12, 14 }, { 17, 19, 1, 3 },
{ 29, 31, 13, 15 }, { 28, 30, 12, 14 },
{ 20, 22, 4, 6 }, { 29, 31, 13, 15 },
{ 21, 23, 5, 7 } { 20, 22, 4, 6 },
{ 21, 23, 5, 7 }
}; };
u32 g_blockTable8[4][8] = { u32 g_blockTable8[4][8] =
{ 0, 1, 4, 5, 16, 17, 20, 21}, {
{ 2, 3, 6, 7, 18, 19, 22, 23}, { 0, 1, 4, 5, 16, 17, 20, 21},
{ 8, 9, 12, 13, 24, 25, 28, 29}, { 2, 3, 6, 7, 18, 19, 22, 23},
{ 10, 11, 14, 15, 26, 27, 30, 31} { 8, 9, 12, 13, 24, 25, 28, 29},
{ 10, 11, 14, 15, 26, 27, 30, 31}
}; };
u32 g_blockTable4[8][4] = { u32 g_blockTable4[8][4] =
{ 0, 2, 8, 10 }, {
{ 1, 3, 9, 11 }, { 0, 2, 8, 10 },
{ 4, 6, 12, 14 }, { 1, 3, 9, 11 },
{ 5, 7, 13, 15 }, { 4, 6, 12, 14 },
{ 16, 18, 24, 26 }, { 5, 7, 13, 15 },
{ 17, 19, 25, 27 }, { 16, 18, 24, 26 },
{ 20, 22, 28, 30 }, { 17, 19, 25, 27 },
{ 21, 23, 29, 31 } { 20, 22, 28, 30 },
{ 21, 23, 29, 31 }
}; };
u32 g_columnTable32[8][8] = { u32 g_columnTable32[8][8] =
{ 0, 1, 4, 5, 8, 9, 12, 13 }, {
{ 2, 3, 6, 7, 10, 11, 14, 15 }, { 0, 1, 4, 5, 8, 9, 12, 13 },
{ 16, 17, 20, 21, 24, 25, 28, 29 }, { 2, 3, 6, 7, 10, 11, 14, 15 },
{ 18, 19, 22, 23, 26, 27, 30, 31 }, { 16, 17, 20, 21, 24, 25, 28, 29 },
{ 32, 33, 36, 37, 40, 41, 44, 45 }, { 18, 19, 22, 23, 26, 27, 30, 31 },
{ 34, 35, 38, 39, 42, 43, 46, 47 }, { 32, 33, 36, 37, 40, 41, 44, 45 },
{ 48, 49, 52, 53, 56, 57, 60, 61 }, { 34, 35, 38, 39, 42, 43, 46, 47 },
{ 50, 51, 54, 55, 58, 59, 62, 63 }, { 48, 49, 52, 53, 56, 57, 60, 61 },
{ 50, 51, 54, 55, 58, 59, 62, 63 },
}; };
u32 g_columnTable16[8][16] = { u32 g_columnTable16[8][16] =
{ 0, 2, 8, 10, 16, 18, 24, 26, {
1, 3, 9, 11, 17, 19, 25, 27 }, { 0, 2, 8, 10, 16, 18, 24, 26,
{ 4, 6, 12, 14, 20, 22, 28, 30, 1, 3, 9, 11, 17, 19, 25, 27 },
5, 7, 13, 15, 21, 23, 29, 31 }, { 4, 6, 12, 14, 20, 22, 28, 30,
{ 32, 34, 40, 42, 48, 50, 56, 58, 5, 7, 13, 15, 21, 23, 29, 31 },
33, 35, 41, 43, 49, 51, 57, 59 }, { 32, 34, 40, 42, 48, 50, 56, 58,
{ 36, 38, 44, 46, 52, 54, 60, 62, 33, 35, 41, 43, 49, 51, 57, 59 },
37, 39, 45, 47, 53, 55, 61, 63 }, { 36, 38, 44, 46, 52, 54, 60, 62,
{ 64, 66, 72, 74, 80, 82, 88, 90, 37, 39, 45, 47, 53, 55, 61, 63 },
65, 67, 73, 75, 81, 83, 89, 91 }, { 64, 66, 72, 74, 80, 82, 88, 90,
{ 68, 70, 76, 78, 84, 86, 92, 94, 65, 67, 73, 75, 81, 83, 89, 91 },
69, 71, 77, 79, 85, 87, 93, 95 }, { 68, 70, 76, 78, 84, 86, 92, 94,
{ 96, 98, 104, 106, 112, 114, 120, 122, 69, 71, 77, 79, 85, 87, 93, 95 },
97, 99, 105, 107, 113, 115, 121, 123 }, { 96, 98, 104, 106, 112, 114, 120, 122,
{ 100, 102, 108, 110, 116, 118, 124, 126, 97, 99, 105, 107, 113, 115, 121, 123 },
101, 103, 109, 111, 117, 119, 125, 127 }, { 100, 102, 108, 110, 116, 118, 124, 126,
101, 103, 109, 111, 117, 119, 125, 127 },
}; };
u32 g_columnTable8[16][16] = { u32 g_columnTable8[16][16] =
{
{ 0, 4, 16, 20, 32, 36, 48, 52, // column 0 { 0, 4, 16, 20, 32, 36, 48, 52, // column 0
2, 6, 18, 22, 34, 38, 50, 54 }, 2, 6, 18, 22, 34, 38, 50, 54 },
{ 8, 12, 24, 28, 40, 44, 56, 60, { 8, 12, 24, 28, 40, 44, 56, 60,
10, 14, 26, 30, 42, 46, 58, 62 }, 10, 14, 26, 30, 42, 46, 58, 62 },
{ 33, 37, 49, 53, 1, 5, 17, 21, { 33, 37, 49, 53, 1, 5, 17, 21,
35, 39, 51, 55, 3, 7, 19, 23 }, 35, 39, 51, 55, 3, 7, 19, 23 },
{ 41, 45, 57, 61, 9, 13, 25, 29, { 41, 45, 57, 61, 9, 13, 25, 29,
43, 47, 59, 63, 11, 15, 27, 31 }, 43, 47, 59, 63, 11, 15, 27, 31 },
{ 96, 100, 112, 116, 64, 68, 80, 84, // column 1 { 96, 100, 112, 116, 64, 68, 80, 84, // column 1
98, 102, 114, 118, 66, 70, 82, 86 }, 98, 102, 114, 118, 66, 70, 82, 86 },
{ 104, 108, 120, 124, 72, 76, 88, 92, { 104, 108, 120, 124, 72, 76, 88, 92,
106, 110, 122, 126, 74, 78, 90, 94 }, 106, 110, 122, 126, 74, 78, 90, 94 },
{ 65, 69, 81, 85, 97, 101, 113, 117, { 65, 69, 81, 85, 97, 101, 113, 117,
67, 71, 83, 87, 99, 103, 115, 119 }, 67, 71, 83, 87, 99, 103, 115, 119 },
{ 73, 77, 89, 93, 105, 109, 121, 125, { 73, 77, 89, 93, 105, 109, 121, 125,
75, 79, 91, 95, 107, 111, 123, 127 }, 75, 79, 91, 95, 107, 111, 123, 127 },
{ 128, 132, 144, 148, 160, 164, 176, 180, // column 2 { 128, 132, 144, 148, 160, 164, 176, 180, // column 2
130, 134, 146, 150, 162, 166, 178, 182 }, 130, 134, 146, 150, 162, 166, 178, 182 },
{ 136, 140, 152, 156, 168, 172, 184, 188, { 136, 140, 152, 156, 168, 172, 184, 188,
138, 142, 154, 158, 170, 174, 186, 190 }, 138, 142, 154, 158, 170, 174, 186, 190 },
{ 161, 165, 177, 181, 129, 133, 145, 149, { 161, 165, 177, 181, 129, 133, 145, 149,
163, 167, 179, 183, 131, 135, 147, 151 }, 163, 167, 179, 183, 131, 135, 147, 151 },
{ 169, 173, 185, 189, 137, 141, 153, 157, { 169, 173, 185, 189, 137, 141, 153, 157,
171, 175, 187, 191, 139, 143, 155, 159 }, 171, 175, 187, 191, 139, 143, 155, 159 },
{ 224, 228, 240, 244, 192, 196, 208, 212, // column 3 { 224, 228, 240, 244, 192, 196, 208, 212, // column 3
226, 230, 242, 246, 194, 198, 210, 214 }, 226, 230, 242, 246, 194, 198, 210, 214 },
{ 232, 236, 248, 252, 200, 204, 216, 220, { 232, 236, 248, 252, 200, 204, 216, 220,
234, 238, 250, 254, 202, 206, 218, 222 }, 234, 238, 250, 254, 202, 206, 218, 222 },
{ 193, 197, 209, 213, 225, 229, 241, 245, { 193, 197, 209, 213, 225, 229, 241, 245,
195, 199, 211, 215, 227, 231, 243, 247 }, 195, 199, 211, 215, 227, 231, 243, 247 },
{ 201, 205, 217, 221, 233, 237, 249, 253, { 201, 205, 217, 221, 233, 237, 249, 253,
203, 207, 219, 223, 235, 239, 251, 255 }, 203, 207, 219, 223, 235, 239, 251, 255 },
}; };
u32 g_columnTable4[16][32] = { u32 g_columnTable4[16][32] =
{
{ 0, 8, 32, 40, 64, 72, 96, 104, // column 0 { 0, 8, 32, 40, 64, 72, 96, 104, // column 0
2, 10, 34, 42, 66, 74, 98, 106, 2, 10, 34, 42, 66, 74, 98, 106,
4, 12, 36, 44, 68, 76, 100, 108, 4, 12, 36, 44, 68, 76, 100, 108,
6, 14, 38, 46, 70, 78, 102, 110 }, 6, 14, 38, 46, 70, 78, 102, 110 },
{ 16, 24, 48, 56, 80, 88, 112, 120, { 16, 24, 48, 56, 80, 88, 112, 120,
18, 26, 50, 58, 82, 90, 114, 122, 18, 26, 50, 58, 82, 90, 114, 122,
20, 28, 52, 60, 84, 92, 116, 124, 20, 28, 52, 60, 84, 92, 116, 124,
22, 30, 54, 62, 86, 94, 118, 126 }, 22, 30, 54, 62, 86, 94, 118, 126 },
{ 65, 73, 97, 105, 1, 9, 33, 41, { 65, 73, 97, 105, 1, 9, 33, 41,
67, 75, 99, 107, 3, 11, 35, 43, 67, 75, 99, 107, 3, 11, 35, 43,
69, 77, 101, 109, 5, 13, 37, 45, 69, 77, 101, 109, 5, 13, 37, 45,
71, 79, 103, 111, 7, 15, 39, 47 }, 71, 79, 103, 111, 7, 15, 39, 47 },
{ 81, 89, 113, 121, 17, 25, 49, 57, { 81, 89, 113, 121, 17, 25, 49, 57,
83, 91, 115, 123, 19, 27, 51, 59, 83, 91, 115, 123, 19, 27, 51, 59,
85, 93, 117, 125, 21, 29, 53, 61, 85, 93, 117, 125, 21, 29, 53, 61,
87, 95, 119, 127, 23, 31, 55, 63 }, 87, 95, 119, 127, 23, 31, 55, 63 },
{ 192, 200, 224, 232, 128, 136, 160, 168, // column 1 { 192, 200, 224, 232, 128, 136, 160, 168, // column 1
194, 202, 226, 234, 130, 138, 162, 170, 194, 202, 226, 234, 130, 138, 162, 170,
196, 204, 228, 236, 132, 140, 164, 172, 196, 204, 228, 236, 132, 140, 164, 172,
198, 206, 230, 238, 134, 142, 166, 174 }, 198, 206, 230, 238, 134, 142, 166, 174 },
{ 208, 216, 240, 248, 144, 152, 176, 184, { 208, 216, 240, 248, 144, 152, 176, 184,
210, 218, 242, 250, 146, 154, 178, 186, 210, 218, 242, 250, 146, 154, 178, 186,
212, 220, 244, 252, 148, 156, 180, 188, 212, 220, 244, 252, 148, 156, 180, 188,
214, 222, 246, 254, 150, 158, 182, 190 }, 214, 222, 246, 254, 150, 158, 182, 190 },
{ 129, 137, 161, 169, 193, 201, 225, 233, { 129, 137, 161, 169, 193, 201, 225, 233,
131, 139, 163, 171, 195, 203, 227, 235, 131, 139, 163, 171, 195, 203, 227, 235,
133, 141, 165, 173, 197, 205, 229, 237, 133, 141, 165, 173, 197, 205, 229, 237,
135, 143, 167, 175, 199, 207, 231, 239 }, 135, 143, 167, 175, 199, 207, 231, 239 },
{ 145, 153, 177, 185, 209, 217, 241, 249, { 145, 153, 177, 185, 209, 217, 241, 249,
147, 155, 179, 187, 211, 219, 243, 251, 147, 155, 179, 187, 211, 219, 243, 251,
149, 157, 181, 189, 213, 221, 245, 253, 149, 157, 181, 189, 213, 221, 245, 253,
151, 159, 183, 191, 215, 223, 247, 255 }, 151, 159, 183, 191, 215, 223, 247, 255 },
{ 256, 264, 288, 296, 320, 328, 352, 360, // column 2 { 256, 264, 288, 296, 320, 328, 352, 360, // column 2
258, 266, 290, 298, 322, 330, 354, 362, 258, 266, 290, 298, 322, 330, 354, 362,
260, 268, 292, 300, 324, 332, 356, 364, 260, 268, 292, 300, 324, 332, 356, 364,
262, 270, 294, 302, 326, 334, 358, 366 }, 262, 270, 294, 302, 326, 334, 358, 366 },
{ 272, 280, 304, 312, 336, 344, 368, 376, { 272, 280, 304, 312, 336, 344, 368, 376,
274, 282, 306, 314, 338, 346, 370, 378, 274, 282, 306, 314, 338, 346, 370, 378,
276, 284, 308, 316, 340, 348, 372, 380, 276, 284, 308, 316, 340, 348, 372, 380,
278, 286, 310, 318, 342, 350, 374, 382 }, 278, 286, 310, 318, 342, 350, 374, 382 },
{ 321, 329, 353, 361, 257, 265, 289, 297, { 321, 329, 353, 361, 257, 265, 289, 297,
323, 331, 355, 363, 259, 267, 291, 299, 323, 331, 355, 363, 259, 267, 291, 299,
325, 333, 357, 365, 261, 269, 293, 301, 325, 333, 357, 365, 261, 269, 293, 301,
327, 335, 359, 367, 263, 271, 295, 303 }, 327, 335, 359, 367, 263, 271, 295, 303 },
{ 337, 345, 369, 377, 273, 281, 305, 313, { 337, 345, 369, 377, 273, 281, 305, 313,
339, 347, 371, 379, 275, 283, 307, 315, 339, 347, 371, 379, 275, 283, 307, 315,
341, 349, 373, 381, 277, 285, 309, 317, 341, 349, 373, 381, 277, 285, 309, 317,
343, 351, 375, 383, 279, 287, 311, 319 }, 343, 351, 375, 383, 279, 287, 311, 319 },
{ 448, 456, 480, 488, 384, 392, 416, 424, // column 3 { 448, 456, 480, 488, 384, 392, 416, 424, // column 3
450, 458, 482, 490, 386, 394, 418, 426, 450, 458, 482, 490, 386, 394, 418, 426,
452, 460, 484, 492, 388, 396, 420, 428, 452, 460, 484, 492, 388, 396, 420, 428,
454, 462, 486, 494, 390, 398, 422, 430 }, 454, 462, 486, 494, 390, 398, 422, 430 },
{ 464, 472, 496, 504, 400, 408, 432, 440, { 464, 472, 496, 504, 400, 408, 432, 440,
466, 474, 498, 506, 402, 410, 434, 442, 466, 474, 498, 506, 402, 410, 434, 442,
468, 476, 500, 508, 404, 412, 436, 444, 468, 476, 500, 508, 404, 412, 436, 444,
470, 478, 502, 510, 406, 414, 438, 446 }, 470, 478, 502, 510, 406, 414, 438, 446 },
{ 385, 393, 417, 425, 449, 457, 481, 489, { 385, 393, 417, 425, 449, 457, 481, 489,
387, 395, 419, 427, 451, 459, 483, 491, 387, 395, 419, 427, 451, 459, 483, 491,
389, 397, 421, 429, 453, 461, 485, 493, 389, 397, 421, 429, 453, 461, 485, 493,
391, 399, 423, 431, 455, 463, 487, 495 }, 391, 399, 423, 431, 455, 463, 487, 495 },
{ 401, 409, 433, 441, 465, 473, 497, 505, { 401, 409, 433, 441, 465, 473, 497, 505,
403, 411, 435, 443, 467, 475, 499, 507, 403, 411, 435, 443, 467, 475, 499, 507,
405, 413, 437, 445, 469, 477, 501, 509, 405, 413, 437, 445, 469, 477, 501, 509,
407, 415, 439, 447, 471, 479, 503, 511 }, 407, 415, 439, 447, 471, 479, 503, 511 },
}; };
u32 g_pageTable32[32][64]; u32 g_pageTable32[32][64];

389
plugins/zzogl-pg/opengl/Regs.cpp
View File

@ -36,20 +36,23 @@ const u32 g_primsub[8] = { 1, 2, 1, 3, 1, 1, 2, 0 };
#pragma warning(disable:4244) #pragma warning(disable:4244)
#endif #endif
GIFRegHandler g_GIFPackedRegHandlers[16] = { GIFRegHandler g_GIFPackedRegHandlers[16] =
{
GIFRegHandlerPRIM, GIFPackedRegHandlerRGBA, GIFPackedRegHandlerSTQ, GIFPackedRegHandlerUV, GIFRegHandlerPRIM, GIFPackedRegHandlerRGBA, GIFPackedRegHandlerSTQ, GIFPackedRegHandlerUV,
GIFPackedRegHandlerXYZF2, GIFPackedRegHandlerXYZ2, GIFRegHandlerTEX0_1, GIFRegHandlerTEX0_2, GIFPackedRegHandlerXYZF2, GIFPackedRegHandlerXYZ2, GIFRegHandlerTEX0_1, GIFRegHandlerTEX0_2,
GIFRegHandlerCLAMP_1, GIFRegHandlerCLAMP_2, GIFPackedRegHandlerFOG, GIFPackedRegHandlerNull, GIFRegHandlerCLAMP_1, GIFRegHandlerCLAMP_2, GIFPackedRegHandlerFOG, GIFPackedRegHandlerNull,
GIFRegHandlerXYZF3, GIFRegHandlerXYZ3, GIFPackedRegHandlerA_D, GIFPackedRegHandlerNOP }; GIFRegHandlerXYZF3, GIFRegHandlerXYZ3, GIFPackedRegHandlerA_D, GIFPackedRegHandlerNOP
};
GIFRegHandler g_GIFRegHandlers[] = { GIFRegHandler g_GIFRegHandlers[] =
{
GIFRegHandlerPRIM, GIFRegHandlerRGBAQ, GIFRegHandlerST, GIFRegHandlerUV, GIFRegHandlerPRIM, GIFRegHandlerRGBAQ, GIFRegHandlerST, GIFRegHandlerUV,
GIFRegHandlerXYZF2, GIFRegHandlerXYZ2, GIFRegHandlerTEX0_1, GIFRegHandlerTEX0_2, GIFRegHandlerXYZF2, GIFRegHandlerXYZ2, GIFRegHandlerTEX0_1, GIFRegHandlerTEX0_2,
GIFRegHandlerCLAMP_1, GIFRegHandlerCLAMP_2, GIFRegHandlerFOG, GIFRegHandlerNull, GIFRegHandlerCLAMP_1, GIFRegHandlerCLAMP_2, GIFRegHandlerFOG, GIFRegHandlerNull,
GIFRegHandlerXYZF3, GIFRegHandlerXYZ3, GIFRegHandlerNOP, GIFRegHandlerNOP, GIFRegHandlerXYZF3, GIFRegHandlerXYZ3, GIFRegHandlerNOP, GIFRegHandlerNOP,
GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull,
GIFRegHandlerTEX1_1, GIFRegHandlerTEX1_2, GIFRegHandlerTEX2_1, GIFRegHandlerTEX2_2, GIFRegHandlerTEX1_1, GIFRegHandlerTEX1_2, GIFRegHandlerTEX2_1, GIFRegHandlerTEX2_2,
GIFRegHandlerXYOFFSET_1,GIFRegHandlerXYOFFSET_2,GIFRegHandlerPRMODECONT,GIFRegHandlerPRMODE, GIFRegHandlerXYOFFSET_1, GIFRegHandlerXYOFFSET_2, GIFRegHandlerPRMODECONT, GIFRegHandlerPRMODE,
GIFRegHandlerTEXCLUT, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerTEXCLUT, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull,
GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerSCANMSK, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerSCANMSK, GIFRegHandlerNull,
GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull,
@ -67,23 +70,25 @@ GIFRegHandler g_GIFRegHandlers[] = {
GIFRegHandlerHWREG, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerHWREG, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull,
GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull,
GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull, GIFRegHandlerNull,
GIFRegHandlerSIGNAL, GIFRegHandlerFINISH, GIFRegHandlerLABEL, GIFRegHandlerNull }; GIFRegHandlerSIGNAL, GIFRegHandlerFINISH, GIFRegHandlerLABEL, GIFRegHandlerNull
};
C_ASSERT(sizeof(g_GIFRegHandlers)/sizeof(g_GIFRegHandlers[0]) == 100 ); C_ASSERT(sizeof(g_GIFRegHandlers) / sizeof(g_GIFRegHandlers[0]) == 100);
// values for keeping track of changes // values for keeping track of changes
u32 s_uTex1Data[2][2] = {{0,}}; u32 s_uTex1Data[2][2] = {{0, }};
u32 s_uClampData[2] = {0,}; u32 s_uClampData[2] = {0, };
u32 results[65535] = {0,}; u32 results[65535] = {0, };
// return true if triangle SHOULD be painted. // return true if triangle SHOULD be painted.
inline bool NoHighlights(int i) { inline bool NoHighlights(int i)
{
// This is hack-code, I still in search of correct reason, why some triangles should not be drawn. // This is hack-code, I still in search of correct reason, why some triangles should not be drawn.
// I'd have thought we could just test prim->_val and ZeroGS::vb[i].zbuf.psm directly... // I'd have thought we could just test prim->_val and ZeroGS::vb[i].zbuf.psm directly...
int resultA = prim->iip + ((prim->tme) << 1) + ((prim->fge) << 2) + ((prim->abe) << 3) + ((prim->aa1) << 4) + ((prim->fst) << 5) + ((prim->ctxt) << 6) + ((prim->fix)<< 7) + int resultA = prim->iip + ((prim->tme) << 1) + ((prim->fge) << 2) + ((prim->abe) << 3) + ((prim->aa1) << 4) + ((prim->fst) << 5) + ((prim->ctxt) << 6) + ((prim->fix) << 7) +
((ZeroGS::vb[i].zbuf.psm ) << 8); ((ZeroGS::vb[i].zbuf.psm) << 8);
// if ( results[resultA] == 0 ) { // if ( results[resultA] == 0 ) {
// results[resultA] = 1; // results[resultA] = 1;
// ZZLog::Error_Log("%x = %d %d %d %d %d %d %d %d psm: %x", resultA, prim->iip, (prim->tme), (prim->fge), (prim->abe) , (prim->aa1) ,(prim->fst), (prim->ctxt), (prim->fix), ZeroGS::vb[i].zbuf.psm) ; // ZZLog::Error_Log("%x = %d %d %d %d %d %d %d %d psm: %x", resultA, prim->iip, (prim->tme), (prim->fge), (prim->abe) , (prim->aa1) ,(prim->fst), (prim->ctxt), (prim->fix), ZeroGS::vb[i].zbuf.psm) ;
@ -92,7 +97,7 @@ inline bool NoHighlights(int i) {
const pixTest curtest = ZeroGS::vb[i].test; const pixTest curtest = ZeroGS::vb[i].test;
// Again, couldn't we just test curtest._val? // Again, couldn't we just test curtest._val?
int result = curtest.ate + ((curtest.atst) << 1) +((curtest.afail) << 4) + ((curtest.date) << 6) + ((curtest.datm) << 7) + ((curtest.zte) << 8) + ((curtest.ztst)<< 9); int result = curtest.ate + ((curtest.atst) << 1) + ((curtest.afail) << 4) + ((curtest.date) << 6) + ((curtest.datm) << 7) + ((curtest.zte) << 8) + ((curtest.ztst) << 9);
// if (resultA == 0xb) // if (resultA == 0xb)
// if ( results[result] == 0) { // if ( results[result] == 0) {
// results[result] = 1; // results[result] = 1;
@ -102,6 +107,7 @@ inline bool NoHighlights(int i) {
// if (result == 0x50b && ZeroGS::vb[i].zbuf.zmsk ) return false; //ATF // if (result == 0x50b && ZeroGS::vb[i].zbuf.zmsk ) return false; //ATF
// if psm is 16S or 24, tme, abe, & fst are true, the rest are false, result is 0x302 or 0x700, and there is a mask. // if psm is 16S or 24, tme, abe, & fst are true, the rest are false, result is 0x302 or 0x700, and there is a mask.
if ((resultA == 0x3a2a || resultA == 0x312a) && (result == 0x302 || result == 0x700) && (ZeroGS::vb[i].zbuf.zmsk)) return false; // Silent Hill:SM and Front Mission 5, result != 0x300 if ((resultA == 0x3a2a || resultA == 0x312a) && (result == 0x302 || result == 0x700) && (ZeroGS::vb[i].zbuf.zmsk)) return false; // Silent Hill:SM and Front Mission 5, result != 0x300
// if psm is 24, abe is true, tme doesn't matter, the rest are false, result is 0x54c or 0x50c and there is a mask. // if psm is 24, abe is true, tme doesn't matter, the rest are false, result is 0x54c or 0x50c and there is a mask.
@ -109,12 +115,14 @@ inline bool NoHighlights(int i) {
// if psm is 24, abe & tme are true, the rest are false, and no result. // if psm is 24, abe & tme are true, the rest are false, and no result.
if ((resultA == 0x310a) && (result == 0x0)) return false; // Radiata Stories if ((resultA == 0x310a) && (result == 0x0)) return false; // Radiata Stories
// if psm is 16S, tme, abe, fst, and ctxt are true, the rest are false, result is 0x330 or 0x500, and there is a mask. // if psm is 16S, tme, abe, fst, and ctxt are true, the rest are false, result is 0x330 or 0x500, and there is a mask.
if (resultA == 0x3a6a && (result == 0x300 || result == 0x500)&& ZeroGS::vb[i].zbuf.zmsk) return false; // Okami, result != 0x30d if (resultA == 0x3a6a && (result == 0x300 || result == 0x500) && ZeroGS::vb[i].zbuf.zmsk) return false; // Okami, result != 0x30d
// if ((resultA == 0x300b) && (result == 0x300) && ZeroGS::vb[i].zbuf.zmsk) return false; // ATF, but no Melty Blood // if ((resultA == 0x300b) && (result == 0x300) && ZeroGS::vb[i].zbuf.zmsk) return false; // ATF, but no Melty Blood
// Old code // Old code
return (!(g_GameSettings&GAME_XENOSPECHACK) || !ZeroGS::vb[i].zbuf.zmsk || prim->iip ) ; return (!(g_GameSettings&GAME_XENOSPECHACK) || !ZeroGS::vb[i].zbuf.zmsk || prim->iip) ;
} }
void __fastcall GIFPackedRegHandlerNull(u32* data) void __fastcall GIFPackedRegHandlerNull(u32* data)
@ -127,9 +135,9 @@ void __fastcall GIFPackedRegHandlerRGBA(u32* data)
{ {
FUNCLOG FUNCLOG
gs.rgba = (data[0] & 0xff) | gs.rgba = (data[0] & 0xff) |
((data[1] & 0xff) << 8) | ((data[1] & 0xff) << 8) |
((data[2] & 0xff) << 16) | ((data[2] & 0xff) << 16) |
((data[3] & 0xff) << 24); ((data[3] & 0xff) << 24);
gs.vertexregs.rgba = gs.rgba; gs.vertexregs.rgba = gs.rgba;
gs.vertexregs.q = gs.q; gs.vertexregs.q = gs.q;
} }
@ -137,8 +145,8 @@ void __fastcall GIFPackedRegHandlerRGBA(u32* data)
void __fastcall GIFPackedRegHandlerSTQ(u32* data) void __fastcall GIFPackedRegHandlerSTQ(u32* data)
{ {
FUNCLOG FUNCLOG
*(u32*)&gs.vertexregs.s = data[0]&0xffffff00; *(u32*)&gs.vertexregs.s = data[0] & 0xffffff00;
*(u32*)&gs.vertexregs.t = data[1]&0xffffff00; *(u32*)&gs.vertexregs.t = data[1] & 0xffffff00;
*(u32*)&gs.q = data[2]; *(u32*)&gs.q = data[2];
} }
@ -152,10 +160,11 @@ void __fastcall GIFPackedRegHandlerUV(u32* data)
void __forceinline KICK_VERTEX2() void __forceinline KICK_VERTEX2()
{ {
FUNCLOG FUNCLOG
if (++gs.primC >= (int)g_primmult[prim->prim]) if (++gs.primC >= (int)g_primmult[prim->prim])
{ {
if ( NoHighlights(prim->ctxt) ) if (NoHighlights(prim->ctxt)) (*ZeroGS::drawfn[prim->prim])();
(*ZeroGS::drawfn[prim->prim])();
gs.primC -= g_primsub[prim->prim]; gs.primC -= g_primsub[prim->prim];
} }
} }
@ -163,14 +172,16 @@ void __forceinline KICK_VERTEX2()
void __forceinline KICK_VERTEX3() void __forceinline KICK_VERTEX3()
{ {
FUNCLOG FUNCLOG
if (++gs.primC >= (int)g_primmult[prim->prim]) if (++gs.primC >= (int)g_primmult[prim->prim])
{ {
gs.primC -= g_primsub[prim->prim]; gs.primC -= g_primsub[prim->prim];
if (prim->prim == 5) if (prim->prim == 5)
{ {
/* tri fans need special processing */ /* tri fans need special processing */
if (gs.nTriFanVert == gs.primIndex) if (gs.nTriFanVert == gs.primIndex)
gs.primIndex = (gs.primIndex+1)%ArraySize(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ArraySize(gs.gsvertex);
} }
} }
} }
@ -183,12 +194,14 @@ void __fastcall GIFPackedRegHandlerXYZF2(u32* data)
gs.vertexregs.z = (data[2] >> 4) & 0xffffff; gs.vertexregs.z = (data[2] >> 4) & 0xffffff;
gs.vertexregs.f = (data[3] >> 4) & 0xff; gs.vertexregs.f = (data[3] >> 4) & 0xff;
gs.gsvertex[gs.primIndex] = gs.vertexregs; gs.gsvertex[gs.primIndex] = gs.vertexregs;
gs.primIndex = (gs.primIndex+1)%ArraySize(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ArraySize(gs.gsvertex);
if( data[3] & 0x8000 ) { if (data[3] & 0x8000)
{
KICK_VERTEX3(); KICK_VERTEX3();
} }
else { else
{
KICK_VERTEX2(); KICK_VERTEX2();
} }
} }
@ -200,12 +213,14 @@ void __fastcall GIFPackedRegHandlerXYZ2(u32* data)
gs.vertexregs.y = (data[1] >> 0) & 0xffff; gs.vertexregs.y = (data[1] >> 0) & 0xffff;
gs.vertexregs.z = data[2]; gs.vertexregs.z = data[2];
gs.gsvertex[gs.primIndex] = gs.vertexregs; gs.gsvertex[gs.primIndex] = gs.vertexregs;
gs.primIndex = (gs.primIndex+1)%ArraySize(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ArraySize(gs.gsvertex);
if( data[3] & 0x8000 ) { if (data[3] & 0x8000)
{
KICK_VERTEX3(); KICK_VERTEX3();
} }
else { else
{
KICK_VERTEX2(); KICK_VERTEX2();
} }
} }
@ -213,20 +228,22 @@ void __fastcall GIFPackedRegHandlerXYZ2(u32* data)
void __fastcall GIFPackedRegHandlerFOG(u32* data) void __fastcall GIFPackedRegHandlerFOG(u32* data)
{ {
FUNCLOG FUNCLOG
gs.vertexregs.f = (data[3]&0xff0)>>4; gs.vertexregs.f = (data[3] & 0xff0) >> 4;
} }
void __fastcall GIFPackedRegHandlerA_D(u32* data) void __fastcall GIFPackedRegHandlerA_D(u32* data)
{ {
FUNCLOG FUNCLOG
if((data[2] & 0xff) < 100)
if ((data[2] & 0xff) < 100)
g_GIFRegHandlers[data[2] & 0xff](data); g_GIFRegHandlers[data[2] & 0xff](data);
else else
GIFRegHandlerNull(data); GIFRegHandlerNull(data);
} }
void __fastcall GIFPackedRegHandlerNOP(u32* data) void __fastcall GIFPackedRegHandlerNOP(u32* data)
{FUNCLOG {
FUNCLOG
} }
extern int g_PrevBitwiseTexX, g_PrevBitwiseTexY; extern int g_PrevBitwiseTexX, g_PrevBitwiseTexY;
@ -236,17 +253,19 @@ void tex0Write(int i, u32 *data)
FUNCLOG FUNCLOG
u32 psm = ZZOglGet_psm_TexBitsFix(data[0]); u32 psm = ZZOglGet_psm_TexBitsFix(data[0]);
if ( m_Blocks[psm].bpp == 0 ) if (m_Blocks[psm].bpp == 0)
{ {
// kh and others // kh and others
return; return;
} }
ZeroGS::vb[i].uNextTex0Data[0] = data[0]; ZeroGS::vb[i].uNextTex0Data[0] = data[0];
ZeroGS::vb[i].uNextTex0Data[1] = data[1]; ZeroGS::vb[i].uNextTex0Data[1] = data[1];
ZeroGS::vb[i].bNeedTexCheck = 1; ZeroGS::vb[i].bNeedTexCheck = 1;
// don't update unless necessary // don't update unless necessary
if (PSMT_ISCLUT(psm)) if (PSMT_ISCLUT(psm))
{ {
if (ZeroGS::CheckChangeInClut(data[1], psm)) if (ZeroGS::CheckChangeInClut(data[1], psm))
@ -254,6 +273,7 @@ void tex0Write(int i, u32 *data)
// loading clut, so flush whole texture // loading clut, so flush whole texture
ZeroGS::vb[i].FlushTexData(); ZeroGS::vb[i].FlushTexData();
} }
// check if csa is the same!! (ffx bisaid island, grass) // check if csa is the same!! (ffx bisaid island, grass)
else if ((data[1] & 0x1f780000) != (ZeroGS::vb[i].uCurTex0Data[1] & 0x1f780000)) else if ((data[1] & 0x1f780000) != (ZeroGS::vb[i].uCurTex0Data[1] & 0x1f780000))
{ {
@ -262,11 +282,12 @@ void tex0Write(int i, u32 *data)
} }
} }
void tex2Write(int i, u32 *data) { void tex2Write(int i, u32 *data)
{
FUNCLOG FUNCLOG
tex0Info& tex0 = ZeroGS::vb[i].tex0; tex0Info& tex0 = ZeroGS::vb[i].tex0;
if( ZeroGS::vb[i].bNeedTexCheck ) if (ZeroGS::vb[i].bNeedTexCheck)
ZeroGS::vb[i].FlushTexData(); ZeroGS::vb[i].FlushTexData();
u32 psm = ZZOglGet_psm_TexBitsFix(data[0]); u32 psm = ZZOglGet_psm_TexBitsFix(data[0]);
@ -275,43 +296,48 @@ void tex2Write(int i, u32 *data) {
// don't update unless necessary // don't update unless necessary
// if( ZZOglGet_psm_TexBitsFix(*s_uTex0Data) == ZZOglGet_psm_TexBitsFix(data[0]) ) { // psm is the same // if( ZZOglGet_psm_TexBitsFix(*s_uTex0Data) == ZZOglGet_psm_TexBitsFix(data[0]) ) { // psm is the same
if (ZZOglAllExceptClutIsSame(s_uTex0Data, data)) { if (ZZOglAllExceptClutIsSame(s_uTex0Data, data))
if (!PSMT_ISCLUT(psm)) {
return; if (!PSMT_ISCLUT(psm)) return;
// have to write the CLUT again if changed // have to write the CLUT again if changed
if (ZZOglClutMinusCLDunchanged(s_uTex0Data, data)) { if (ZZOglClutMinusCLDunchanged(s_uTex0Data, data))
{
tex0.cld = ZZOglGet_cld_TexBits(data[1]); tex0.cld = ZZOglGet_cld_TexBits(data[1]);
if (tex0.cld != 0) {
if (tex0.cld != 0)
{
ZeroGS::texClutWrite(i); ZeroGS::texClutWrite(i);
// invalidate to make sure target didn't change! // invalidate to make sure target didn't change!
ZeroGS::vb[i].bVarsTexSync = FALSE; ZeroGS::vb[i].bVarsTexSync = FALSE;
} }
return; return;
} }
} }
ZeroGS::Flush(i); ZeroGS::Flush(i);
ZeroGS::vb[i].bVarsTexSync = FALSE; ZeroGS::vb[i].bVarsTexSync = FALSE;
ZeroGS::vb[i].bTexConstsSync = FALSE; ZeroGS::vb[i].bTexConstsSync = FALSE;
s_uTex0Data[0] = (s_uTex0Data[0]&~0x03f00000)|(psm<<20); s_uTex0Data[0] = (s_uTex0Data[0] & ~0x03f00000) | (psm << 20);
s_uTex0Data[1] = (s_uTex0Data[1]&0x1f)|(data[1]&~0x1f); s_uTex0Data[1] = (s_uTex0Data[1] & 0x1f) | (data[1] & ~0x1f);
tex0.psm = ZZOglGet_psm_TexBitsFix(data[0]); tex0.psm = ZZOglGet_psm_TexBitsFix(data[0]);
if( PSMT_ISCLUT(tex0.psm) ) if (PSMT_ISCLUT(tex0.psm)) ZeroGS::CluttingForFlushedTex(&tex0, data[1], i);
ZeroGS::CluttingForFlushedTex(&tex0, data[1], i);
} }
__forceinline void frameWrite(int i, u32 *data) { __forceinline void frameWrite(int i, u32 *data)
{
FUNCLOG FUNCLOG
frameInfo& gsfb = ZeroGS::vb[i].gsfb; frameInfo& gsfb = ZeroGS::vb[i].gsfb;
if ((gsfb.fbp == ZZOglGet_fbp_FrameBitsMult(data[0])) && if ((gsfb.fbp == ZZOglGet_fbp_FrameBitsMult(data[0])) &&
(gsfb.fbw == ZZOglGet_fbw_FrameBitsMult(data[0])) && (gsfb.fbw == ZZOglGet_fbw_FrameBitsMult(data[0])) &&
(gsfb.psm == ZZOglGet_psm_FrameBits(data[0])) && (gsfb.psm == ZZOglGet_psm_FrameBits(data[0])) &&
(gsfb.fbm == ZZOglGet_fbm_FrameBits(data[0])) ) (gsfb.fbm == ZZOglGet_fbm_FrameBits(data[0])))
{ {
return; return;
} }
@ -322,7 +348,7 @@ __forceinline void frameWrite(int i, u32 *data) {
gsfb.fbp = ZZOglGet_fbp_FrameBitsMult(data[0]); gsfb.fbp = ZZOglGet_fbp_FrameBitsMult(data[0]);
gsfb.fbw = ZZOglGet_fbw_FrameBitsMult(data[0]); gsfb.fbw = ZZOglGet_fbw_FrameBitsMult(data[0]);
gsfb.psm = ZZOglGet_psm_FrameBits(data[0]); gsfb.psm = ZZOglGet_psm_FrameBits(data[0]);
gsfb.fbm = ZZOglGet_fbm_FrameBitsFix(data[0],data[1]); gsfb.fbm = ZZOglGet_fbm_FrameBitsFix(data[0], data[1]);
gsfb.fbh = ZZOglGet_fbh_FrameBitsCalc(data[0]); gsfb.fbh = ZZOglGet_fbh_FrameBitsCalc(data[0]);
// gsfb.fbhCalc = gsfb.fbh; // gsfb.fbhCalc = gsfb.fbh;
@ -334,10 +360,10 @@ __forceinline void testWrite(int i, u32 *data)
FUNCLOG FUNCLOG
pixTest* test = &ZeroGS::vb[i].test; pixTest* test = &ZeroGS::vb[i].test;
if( (*(u32*)test & 0x0007ffff) == (data[0] & 0x0007ffff) ) if ((*(u32*)test & 0x0007ffff) == (data[0] & 0x0007ffff)) return;
return;
ZeroGS::Flush(i); ZeroGS::Flush(i);
*(u32*)test = data[0]; *(u32*)test = data[0];
// test.ate = (data[0] ) & 0x1; // test.ate = (data[0] ) & 0x1;
@ -355,16 +381,17 @@ __forceinline void clampWrite(int i, u32 *data)
FUNCLOG FUNCLOG
clampInfo& clamp = ZeroGS::vb[i].clamp; clampInfo& clamp = ZeroGS::vb[i].clamp;
if ((s_uClampData[i] != data[0]) || (((clamp.minv>>8) | (clamp.maxv<<2)) != (data[1]&0x0fff))) { if ((s_uClampData[i] != data[0]) || (((clamp.minv >> 8) | (clamp.maxv << 2)) != (data[1]&0x0fff)))
{
ZeroGS::Flush(i); ZeroGS::Flush(i);
s_uClampData[i] = data[0]; s_uClampData[i] = data[0];
clamp.wms = (data[0] ) & 0x3; clamp.wms = (data[0]) & 0x3;
clamp.wmt = (data[0] >> 2) & 0x3; clamp.wmt = (data[0] >> 2) & 0x3;
clamp.minu = (data[0] >> 4) & 0x3ff; clamp.minu = (data[0] >> 4) & 0x3ff;
clamp.maxu = (data[0] >> 14) & 0x3ff; clamp.maxu = (data[0] >> 14) & 0x3ff;
clamp.minv =((data[0] >> 24) & 0xff) | ((data[1] & 0x3) << 8); clamp.minv = ((data[0] >> 24) & 0xff) | ((data[1] & 0x3) << 8);
clamp.maxv = (data[1] >> 2) & 0x3ff; clamp.maxv = (data[1] >> 2) & 0x3ff;
ZeroGS::vb[i].bTexConstsSync = FALSE; ZeroGS::vb[i].bTexConstsSync = FALSE;
@ -375,30 +402,34 @@ void __fastcall GIFRegHandlerNull(u32* data)
{ {
FUNCLOG FUNCLOG
#ifdef _DEBUG #ifdef _DEBUG
if ((((uptr)&data[2])&0xffff) == 0) return; if ((((uptr)&data[2])&0xffff) == 0) return;
// 0x7f happens on a lot of games // 0x7f happens on a lot of games
if (data[2] != 0x7f && (data[0] || data[1])) if (data[2] != 0x7f && (data[0] || data[1]))
{ {
ZZLog::Debug_Log("Unexpected reg handler %x %x %x.", data[0], data[1], data[2]); ZZLog::Debug_Log("Unexpected reg handler %x %x %x.", data[0], data[1], data[2]);
} }
#endif #endif
} }
void __fastcall GIFRegHandlerPRIM(u32 *data) void __fastcall GIFRegHandlerPRIM(u32 *data)
{ {
FUNCLOG FUNCLOG
if (data[0] & ~0x3ff)
if (data[0] & ~0x3ff)
{ {
//ZZLog::Warn_Log("Warning: unknown bits in prim %8.8lx_%8.8lx", data[1], data[0]); //ZZLog::Warn_Log("Warning: unknown bits in prim %8.8lx_%8.8lx", data[1], data[0]);
} }
gs.nTriFanVert = gs.primIndex; gs.nTriFanVert = gs.primIndex;
gs.primC = 0; gs.primC = 0;
prim->prim = (data[0]) & 0x7; prim->prim = (data[0]) & 0x7;
gs._prim[0].prim = (data[0]) & 0x7; gs._prim[0].prim = (data[0]) & 0x7;
gs._prim[1].prim = (data[0]) & 0x7; gs._prim[1].prim = (data[0]) & 0x7;
gs._prim[1]._val = (data[0]>>3)&0xff; gs._prim[1]._val = (data[0] >> 3) & 0xff;
ZeroGS::Prim(); ZeroGS::Prim();
} }
@ -414,8 +445,8 @@ void __fastcall GIFRegHandlerRGBAQ(u32* data)
void __fastcall GIFRegHandlerST(u32* data) void __fastcall GIFRegHandlerST(u32* data)
{ {
FUNCLOG FUNCLOG
*(u32*)&gs.vertexregs.s = data[0]&0xffffff00; *(u32*)&gs.vertexregs.s = data[0] & 0xffffff00;
*(u32*)&gs.vertexregs.t = data[1]&0xffffff00; *(u32*)&gs.vertexregs.t = data[1] & 0xffffff00;
//*(u32*)&gs.q = data[2]; //*(u32*)&gs.q = data[2];
} }
@ -434,7 +465,7 @@ void __fastcall GIFRegHandlerXYZF2(u32* data)
gs.vertexregs.z = data[1] & 0xffffff; gs.vertexregs.z = data[1] & 0xffffff;
gs.vertexregs.f = data[1] >> 24; gs.vertexregs.f = data[1] >> 24;
gs.gsvertex[gs.primIndex] = gs.vertexregs; gs.gsvertex[gs.primIndex] = gs.vertexregs;
gs.primIndex = (gs.primIndex+1)%ARRAY_SIZE(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ARRAY_SIZE(gs.gsvertex);
KICK_VERTEX2(); KICK_VERTEX2();
} }
@ -446,7 +477,7 @@ void __fastcall GIFRegHandlerXYZ2(u32* data)
gs.vertexregs.y = (data[0] >> (16)) & 0xffff; gs.vertexregs.y = (data[0] >> (16)) & 0xffff;
gs.vertexregs.z = data[1]; gs.vertexregs.z = data[1];
gs.gsvertex[gs.primIndex] = gs.vertexregs; gs.gsvertex[gs.primIndex] = gs.vertexregs;
gs.primIndex = (gs.primIndex+1)%ARRAY_SIZE(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ARRAY_SIZE(gs.gsvertex);
KICK_VERTEX2(); KICK_VERTEX2();
} }
@ -454,36 +485,36 @@ void __fastcall GIFRegHandlerXYZ2(u32* data)
void __fastcall GIFRegHandlerTEX0_1(u32* data) void __fastcall GIFRegHandlerTEX0_1(u32* data)
{ {
FUNCLOG FUNCLOG
if( !NoHighlights(0)) {
return; if (!NoHighlights(0)) return;
}
tex0Write(0, data); tex0Write(0, data);
} }
void __fastcall GIFRegHandlerTEX0_2(u32* data) void __fastcall GIFRegHandlerTEX0_2(u32* data)
{ {
FUNCLOG FUNCLOG
if( !NoHighlights(1) ) {
return; if (!NoHighlights(1)) return;
}
tex0Write(1, data); tex0Write(1, data);
} }
void __fastcall GIFRegHandlerCLAMP_1(u32* data) void __fastcall GIFRegHandlerCLAMP_1(u32* data)
{ {
FUNCLOG FUNCLOG
if( !NoHighlights(0) ) {
return; if (!NoHighlights(0)) return;
}
clampWrite(0, data); clampWrite(0, data);
} }
void __fastcall GIFRegHandlerCLAMP_2(u32* data) void __fastcall GIFRegHandlerCLAMP_2(u32* data)
{ {
FUNCLOG FUNCLOG
if( !NoHighlights(1) ) {
return; if (!NoHighlights(1)) return;
}
clampWrite(1, data); clampWrite(1, data);
} }
@ -491,7 +522,7 @@ void __fastcall GIFRegHandlerFOG(u32* data)
{ {
FUNCLOG FUNCLOG
//gs.gsvertex[gs.primIndex].f = (data[1] >> 24); // shift to upper bits //gs.gsvertex[gs.primIndex].f = (data[1] >> 24); // shift to upper bits
gs.vertexregs.f = data[1]>>24; gs.vertexregs.f = data[1] >> 24;
} }
void __fastcall GIFRegHandlerXYZF3(u32* data) void __fastcall GIFRegHandlerXYZF3(u32* data)
@ -502,7 +533,7 @@ void __fastcall GIFRegHandlerXYZF3(u32* data)
gs.vertexregs.z = data[1] & 0xffffff; gs.vertexregs.z = data[1] & 0xffffff;
gs.vertexregs.f = data[1] >> 24; gs.vertexregs.f = data[1] >> 24;
gs.gsvertex[gs.primIndex] = gs.vertexregs; gs.gsvertex[gs.primIndex] = gs.vertexregs;
gs.primIndex = (gs.primIndex+1)%ARRAY_SIZE(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ARRAY_SIZE(gs.gsvertex);
KICK_VERTEX3(); KICK_VERTEX3();
} }
@ -514,7 +545,7 @@ void __fastcall GIFRegHandlerXYZ3(u32* data)
gs.vertexregs.y = (data[0] >> (16)) & 0xffff; gs.vertexregs.y = (data[0] >> (16)) & 0xffff;
gs.vertexregs.z = data[1]; gs.vertexregs.z = data[1];
gs.gsvertex[gs.primIndex] = gs.vertexregs; gs.gsvertex[gs.primIndex] = gs.vertexregs;
gs.primIndex = (gs.primIndex+1)%ARRAY_SIZE(gs.gsvertex); gs.primIndex = (gs.primIndex + 1) % ARRAY_SIZE(gs.gsvertex);
KICK_VERTEX3(); KICK_VERTEX3();
} }
@ -529,11 +560,14 @@ void tex1Write(int i, u32* data)
FUNCLOG FUNCLOG
tex1Info& tex1 = ZeroGS::vb[i].tex1; tex1Info& tex1 = ZeroGS::vb[i].tex1;
if( conf.bilinear == 1 && (tex1.mmag != ((data[0] >> 5) & 0x1) || tex1.mmin != ((data[0] >> 6) & 0x7)) ) { if (conf.bilinear == 1 && (tex1.mmag != ((data[0] >> 5) & 0x1) || tex1.mmin != ((data[0] >> 6) & 0x7)))
{
ZeroGS::Flush(i); ZeroGS::Flush(i);
ZeroGS::vb[i].bVarsTexSync = FALSE; ZeroGS::vb[i].bVarsTexSync = FALSE;
} }
tex1.lcm = (data[0] ) & 0x1;
tex1.lcm = (data[0]) & 0x1;
tex1.mxl = (data[0] >> 2) & 0x7; tex1.mxl = (data[0] >> 2) & 0x7;
tex1.mmag = (data[0] >> 5) & 0x1; tex1.mmag = (data[0] >> 5) & 0x1;
tex1.mmin = (data[0] >> 6) & 0x7; tex1.mmin = (data[0] >> 6) & 0x7;
@ -546,9 +580,7 @@ void __fastcall GIFRegHandlerTEX1_1(u32* data)
{ {
FUNCLOG FUNCLOG
if( !NoHighlights(0)) { if (!NoHighlights(0)) return;
return;
}
tex1Write(0, data); tex1Write(0, data);
} }
@ -556,8 +588,8 @@ void __fastcall GIFRegHandlerTEX1_1(u32* data)
void __fastcall GIFRegHandlerTEX1_2(u32* data) void __fastcall GIFRegHandlerTEX1_2(u32* data)
{ {
FUNCLOG FUNCLOG
if( !NoHighlights(1) )
return; if (!NoHighlights(1)) return;
tex1Write(1, data); tex1Write(1, data);
} }
@ -611,7 +643,7 @@ void __fastcall GIFRegHandlerPRMODECONT(u32* data)
void __fastcall GIFRegHandlerPRMODE(u32* data) void __fastcall GIFRegHandlerPRMODE(u32* data)
{ {
FUNCLOG FUNCLOG
gs._prim[0]._val = (data[0]>>3)&0xff; gs._prim[0]._val = (data[0] >> 3) & 0xff;
if (gs.prac == 0) if (gs.prac == 0)
ZeroGS::Prim(); ZeroGS::Prim();
@ -620,11 +652,11 @@ void __fastcall GIFRegHandlerPRMODE(u32* data)
void __fastcall GIFRegHandlerTEXCLUT(u32* data) void __fastcall GIFRegHandlerTEXCLUT(u32* data)
{ {
FUNCLOG FUNCLOG
if( ZeroGS::vb[0].bNeedTexCheck )
ZeroGS::vb[0].FlushTexData(); if (ZeroGS::vb[0].bNeedTexCheck) ZeroGS::vb[0].FlushTexData();
if( ZeroGS::vb[1].bNeedTexCheck ) if (ZeroGS::vb[1].bNeedTexCheck) ZeroGS::vb[1].FlushTexData();
ZeroGS::vb[1].FlushTexData();
gs.clut.cbw = ((data[0] ) & 0x3f) * 64; gs.clut.cbw = ((data[0]) & 0x3f) * 64;
gs.clut.cou = ((data[0] >> 6) & 0x3f) * 16; gs.clut.cou = ((data[0] >> 6) & 0x3f) * 16;
gs.clut.cov = (data[0] >> 12) & 0x3ff; gs.clut.cov = (data[0] >> 12) & 0x3ff;
} }
@ -644,7 +676,7 @@ void __fastcall GIFRegHandlerMIPTBP1_1(u32* data)
{ {
FUNCLOG FUNCLOG
miptbpInfo& miptbp0 = ZeroGS::vb[0].miptbp0; miptbpInfo& miptbp0 = ZeroGS::vb[0].miptbp0;
miptbp0.tbp[0] = (data[0] ) & 0x3fff; miptbp0.tbp[0] = (data[0]) & 0x3fff;
miptbp0.tbw[0] = (data[0] >> 14) & 0x3f; miptbp0.tbw[0] = (data[0] >> 14) & 0x3f;
miptbp0.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12); miptbp0.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12);
miptbp0.tbw[1] = (data[1] >> 2) & 0x3f; miptbp0.tbw[1] = (data[1] >> 2) & 0x3f;
@ -656,7 +688,7 @@ void __fastcall GIFRegHandlerMIPTBP1_2(u32* data)
{ {
FUNCLOG FUNCLOG
miptbpInfo& miptbp0 = ZeroGS::vb[1].miptbp0; miptbpInfo& miptbp0 = ZeroGS::vb[1].miptbp0;
miptbp0.tbp[0] = (data[0] ) & 0x3fff; miptbp0.tbp[0] = (data[0]) & 0x3fff;
miptbp0.tbw[0] = (data[0] >> 14) & 0x3f; miptbp0.tbw[0] = (data[0] >> 14) & 0x3f;
miptbp0.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12); miptbp0.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12);
miptbp0.tbw[1] = (data[1] >> 2) & 0x3f; miptbp0.tbw[1] = (data[1] >> 2) & 0x3f;
@ -668,7 +700,7 @@ void __fastcall GIFRegHandlerMIPTBP2_1(u32* data)
{ {
FUNCLOG FUNCLOG
miptbpInfo& miptbp1 = ZeroGS::vb[0].miptbp1; miptbpInfo& miptbp1 = ZeroGS::vb[0].miptbp1;
miptbp1.tbp[0] = (data[0] ) & 0x3fff; miptbp1.tbp[0] = (data[0]) & 0x3fff;
miptbp1.tbw[0] = (data[0] >> 14) & 0x3f; miptbp1.tbw[0] = (data[0] >> 14) & 0x3f;
miptbp1.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12); miptbp1.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12);
miptbp1.tbw[1] = (data[1] >> 2) & 0x3f; miptbp1.tbw[1] = (data[1] >> 2) & 0x3f;
@ -680,7 +712,7 @@ void __fastcall GIFRegHandlerMIPTBP2_2(u32* data)
{ {
FUNCLOG FUNCLOG
miptbpInfo& miptbp1 = ZeroGS::vb[1].miptbp1; miptbpInfo& miptbp1 = ZeroGS::vb[1].miptbp1;
miptbp1.tbp[0] = (data[0] ) & 0x3fff; miptbp1.tbp[0] = (data[0]) & 0x3fff;
miptbp1.tbw[0] = (data[0] >> 14) & 0x3f; miptbp1.tbw[0] = (data[0] >> 14) & 0x3f;
miptbp1.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12); miptbp1.tbp[1] = ((data[0] >> 20) & 0xfff) | ((data[1] & 0x3) << 12);
miptbp1.tbw[1] = (data[1] >> 2) & 0x3f; miptbp1.tbw[1] = (data[1] >> 2) & 0x3f;
@ -696,12 +728,13 @@ void __fastcall GIFRegHandlerTEXA(u32* data)
newinfo.ta[0] = data[0] & 0xff; newinfo.ta[0] = data[0] & 0xff;
newinfo.ta[1] = data[1] & 0xff; newinfo.ta[1] = data[1] & 0xff;
if( *(u32*)&newinfo != *(u32*)&gs.texa ) { if (*(u32*)&newinfo != *(u32*)&gs.texa)
{
ZeroGS::Flush(0); ZeroGS::Flush(0);
ZeroGS::Flush(1); ZeroGS::Flush(1);
*(u32*)&gs.texa = *(u32*)&newinfo; *(u32*)&gs.texa = *(u32*) & newinfo;
gs.texa.fta[0] = newinfo.ta[0]/255.0f; gs.texa.fta[0] = newinfo.ta[0] / 255.0f;
gs.texa.fta[1] = newinfo.ta[1]/255.0f; gs.texa.fta[1] = newinfo.ta[1] / 255.0f;
ZeroGS::vb[0].bTexConstsSync = FALSE; ZeroGS::vb[0].bTexConstsSync = FALSE;
ZeroGS::vb[1].bTexConstsSync = FALSE; ZeroGS::vb[1].bTexConstsSync = FALSE;
@ -727,13 +760,14 @@ void __fastcall GIFRegHandlerSCISSOR_1(u32* data)
Rect2 newscissor; Rect2 newscissor;
newscissor.x0 = ((data[0] ) & 0x7ff) << 3; newscissor.x0 = ((data[0]) & 0x7ff) << 3;
newscissor.x1 = ((data[0] >> 16) & 0x7ff) << 3; newscissor.x1 = ((data[0] >> 16) & 0x7ff) << 3;
newscissor.y0 = ((data[1] ) & 0x7ff) << 3; newscissor.y0 = ((data[1]) & 0x7ff) << 3;
newscissor.y1 = ((data[1] >> 16) & 0x7ff) << 3; newscissor.y1 = ((data[1] >> 16) & 0x7ff) << 3;
if( newscissor.x1 != scissor.x1 || newscissor.y1 != scissor.y1 || if (newscissor.x1 != scissor.x1 || newscissor.y1 != scissor.y1 ||
newscissor.x0 != scissor.x0 || newscissor.y0 != scissor.y0 ) { newscissor.x0 != scissor.x0 || newscissor.y0 != scissor.y0)
{
ZeroGS::Flush(0); ZeroGS::Flush(0);
scissor = newscissor; scissor = newscissor;
@ -749,13 +783,14 @@ void __fastcall GIFRegHandlerSCISSOR_2(u32* data)
Rect2 newscissor; Rect2 newscissor;
newscissor.x0 = ((data[0] ) & 0x7ff) << 3; newscissor.x0 = ((data[0]) & 0x7ff) << 3;
newscissor.x1 = ((data[0] >> 16) & 0x7ff) << 3; newscissor.x1 = ((data[0] >> 16) & 0x7ff) << 3;
newscissor.y0 = ((data[1] ) & 0x7ff) << 3; newscissor.y0 = ((data[1]) & 0x7ff) << 3;
newscissor.y1 = ((data[1] >> 16) & 0x7ff) << 3; newscissor.y1 = ((data[1] >> 16) & 0x7ff) << 3;
if( newscissor.x1 != scissor.x1 || newscissor.y1 != scissor.y1 || if (newscissor.x1 != scissor.x1 || newscissor.y1 != scissor.y1 ||
newscissor.x0 != scissor.x0 || newscissor.y0 != scissor.y0 ) { newscissor.x0 != scissor.x0 || newscissor.y0 != scissor.y0)
{
ZeroGS::Flush(1); ZeroGS::Flush(1);
scissor = newscissor; scissor = newscissor;
@ -770,17 +805,18 @@ void __fastcall GIFRegHandlerALPHA_1(u32* data)
FUNCLOG FUNCLOG
alphaInfo newalpha; alphaInfo newalpha;
newalpha.abcd = *(u8*)data; newalpha.abcd = *(u8*)data;
newalpha.fix = *(u8*)(data+1); newalpha.fix = *(u8*)(data + 1);
if( *(u16*)&newalpha != *(u16*)&ZeroGS::vb[0].alpha ) { if (*(u16*)&newalpha != *(u16*)&ZeroGS::vb[0].alpha)
{
ZeroGS::Flush(0); ZeroGS::Flush(0);
if( newalpha.a == 3 ) newalpha.a = 0; if (newalpha.a == 3) newalpha.a = 0;
if( newalpha.b == 3 ) newalpha.b = 0; if (newalpha.b == 3) newalpha.b = 0;
if( newalpha.c == 3 ) newalpha.c = 0; if (newalpha.c == 3) newalpha.c = 0;
if( newalpha.d == 3 ) newalpha.d = 0; if (newalpha.d == 3) newalpha.d = 0;
*(u16*)&ZeroGS::vb[0].alpha = *(u16*)&newalpha; *(u16*)&ZeroGS::vb[0].alpha = *(u16*) & newalpha;
} }
} }
@ -789,17 +825,18 @@ void __fastcall GIFRegHandlerALPHA_2(u32* data)
FUNCLOG FUNCLOG
alphaInfo newalpha; alphaInfo newalpha;
newalpha.abcd = *(u8*)data; newalpha.abcd = *(u8*)data;
newalpha.fix = *(u8*)(data+1); newalpha.fix = *(u8*)(data + 1);
if( *(u16*)&newalpha != *(u16*)&ZeroGS::vb[1].alpha ) { if (*(u16*)&newalpha != *(u16*)&ZeroGS::vb[1].alpha)
{
ZeroGS::Flush(1); ZeroGS::Flush(1);
if( newalpha.a == 3 ) newalpha.a = 0; if (newalpha.a == 3) newalpha.a = 0;
if( newalpha.b == 3 ) newalpha.b = 0; if (newalpha.b == 3) newalpha.b = 0;
if( newalpha.c == 3 ) newalpha.c = 0; if (newalpha.c == 3) newalpha.c = 0;
if( newalpha.d == 3 ) newalpha.d = 0; if (newalpha.d == 3) newalpha.d = 0;
*(u16*)&ZeroGS::vb[1].alpha = *(u16*)&newalpha; *(u16*)&ZeroGS::vb[1].alpha = *(u16*) & newalpha;
} }
} }
@ -876,26 +913,28 @@ void __fastcall GIFRegHandlerZBUF_1(u32* data)
FUNCLOG FUNCLOG
zbufInfo& zbuf = ZeroGS::vb[0].zbuf; zbufInfo& zbuf = ZeroGS::vb[0].zbuf;
int psm = (0x30|((data[0] >> 24) & 0xf)); int psm = (0x30 | ((data[0] >> 24) & 0xf));
if( zbuf.zbp == (data[0] & 0x1ff) * 32 &&
zbuf.psm == psm && if (zbuf.zbp == (data[0] & 0x1ff) * 32 &&
zbuf.zmsk == (data[1] & 0x1) ) { zbuf.psm == psm &&
zbuf.zmsk == (data[1] & 0x1))
{
return; return;
} }
// error detection // error detection
if( m_Blocks[psm].bpp == 0 ) if (m_Blocks[psm].bpp == 0) return;
return;
ZeroGS::Flush(0); ZeroGS::Flush(0);
ZeroGS::Flush(1); ZeroGS::Flush(1);
zbuf.zbp = (data[0] & 0x1ff) * 32; zbuf.zbp = (data[0] & 0x1ff) * 32;
zbuf.psm = 0x30|((data[0] >> 24) & 0xf); zbuf.psm = 0x30 | ((data[0] >> 24) & 0xf);
zbuf.zmsk = data[1] & 0x1; zbuf.zmsk = data[1] & 0x1;
ZeroGS::vb[0].zprimmask = 0xffffffff; ZeroGS::vb[0].zprimmask = 0xffffffff;
if( zbuf.psm > 0x31 ) ZeroGS::vb[0].zprimmask = 0xffff;
if (zbuf.psm > 0x31) ZeroGS::vb[0].zprimmask = 0xffff;
ZeroGS::vb[0].bNeedZCheck = 1; ZeroGS::vb[0].bNeedZCheck = 1;
} }
@ -905,39 +944,43 @@ void __fastcall GIFRegHandlerZBUF_2(u32* data)
FUNCLOG FUNCLOG
zbufInfo& zbuf = ZeroGS::vb[1].zbuf; zbufInfo& zbuf = ZeroGS::vb[1].zbuf;
int psm = (0x30|((data[0] >> 24) & 0xf)); int psm = (0x30 | ((data[0] >> 24) & 0xf));
if( zbuf.zbp == (data[0] & 0x1ff) * 32 &&
zbuf.psm == psm && if (zbuf.zbp == (data[0] & 0x1ff) * 32 &&
zbuf.zmsk == (data[1] & 0x1) ) { zbuf.psm == psm &&
zbuf.zmsk == (data[1] & 0x1))
{
return; return;
} }
// error detection // error detection
if( m_Blocks[psm].bpp == 0 ) if (m_Blocks[psm].bpp == 0)
return; return;
ZeroGS::Flush(0); ZeroGS::Flush(0);
ZeroGS::Flush(1); ZeroGS::Flush(1);
zbuf.zbp = (data[0] & 0x1ff) * 32; zbuf.zbp = (data[0] & 0x1ff) * 32;
zbuf.psm = 0x30|((data[0] >> 24) & 0xf);
zbuf.psm = 0x30 | ((data[0] >> 24) & 0xf);
zbuf.zmsk = data[1] & 0x1; zbuf.zmsk = data[1] & 0x1;
ZeroGS::vb[1].bNeedZCheck = 1; ZeroGS::vb[1].bNeedZCheck = 1;
ZeroGS::vb[1].zprimmask = 0xffffffff; ZeroGS::vb[1].zprimmask = 0xffffffff;
if( zbuf.psm > 0x31 ) ZeroGS::vb[1].zprimmask = 0xffff;
if (zbuf.psm > 0x31) ZeroGS::vb[1].zprimmask = 0xffff;
} }
void __fastcall GIFRegHandlerBITBLTBUF(u32* data) void __fastcall GIFRegHandlerBITBLTBUF(u32* data)
{ {
FUNCLOG FUNCLOG
gs.srcbufnew.bp = ((data[0] ) & 0x3fff);// * 64; gs.srcbufnew.bp = ((data[0]) & 0x3fff); // * 64;
gs.srcbufnew.bw = ((data[0] >> 16) & 0x3f) * 64; gs.srcbufnew.bw = ((data[0] >> 16) & 0x3f) * 64;
gs.srcbufnew.psm = (data[0] >> 24) & 0x3f; gs.srcbufnew.psm = (data[0] >> 24) & 0x3f;
gs.dstbufnew.bp = ((data[1] ) & 0x3fff);// * 64; gs.dstbufnew.bp = ((data[1]) & 0x3fff); // * 64;
gs.dstbufnew.bw = ((data[1] >> 16) & 0x3f) * 64; gs.dstbufnew.bw = ((data[1] >> 16) & 0x3f) * 64;
gs.dstbufnew.psm = (data[1] >> 24) & 0x3f; gs.dstbufnew.psm = (data[1] >> 24) & 0x3f;
if (gs.dstbufnew.bw == 0) gs.dstbufnew.bw = 64; if (gs.dstbufnew.bw == 0) gs.dstbufnew.bw = 64;
} }
@ -945,9 +988,9 @@ void __fastcall GIFRegHandlerBITBLTBUF(u32* data)
void __fastcall GIFRegHandlerTRXPOS(u32* data) void __fastcall GIFRegHandlerTRXPOS(u32* data)
{ {
FUNCLOG FUNCLOG
gs.trxposnew.sx = (data[0] ) & 0x7ff; gs.trxposnew.sx = (data[0]) & 0x7ff;
gs.trxposnew.sy = (data[0] >> 16) & 0x7ff; gs.trxposnew.sy = (data[0] >> 16) & 0x7ff;
gs.trxposnew.dx = (data[1] ) & 0x7ff; gs.trxposnew.dx = (data[1]) & 0x7ff;
gs.trxposnew.dy = (data[1] >> 16) & 0x7ff; gs.trxposnew.dy = (data[1] >> 16) & 0x7ff;
gs.trxposnew.dir = (data[1] >> 27) & 0x3; gs.trxposnew.dir = (data[1] >> 27) & 0x3;
} }
@ -955,42 +998,48 @@ void __fastcall GIFRegHandlerTRXPOS(u32* data)
void __fastcall GIFRegHandlerTRXREG(u32* data) void __fastcall GIFRegHandlerTRXREG(u32* data)
{ {
FUNCLOG FUNCLOG
gs.imageWtemp = data[0]&0xfff; gs.imageWtemp = data[0] & 0xfff;
gs.imageHtemp = data[1]&0xfff; gs.imageHtemp = data[1] & 0xfff;
} }
void __fastcall GIFRegHandlerTRXDIR(u32* data) void __fastcall GIFRegHandlerTRXDIR(u32* data)
{ {
FUNCLOG FUNCLOG
// terminate any previous transfers // terminate any previous transfers
switch( gs.imageTransfer ) {
switch (gs.imageTransfer)
{
case 0: // host->loc case 0: // host->loc
gs.imageTransfer = -1; gs.imageTransfer = -1;
break; break;
case 1: // loc->host case 1: // loc->host
ZeroGS::TerminateLocalHost(); ZeroGS::TerminateLocalHost();
break; break;
} }
gs.srcbuf = gs.srcbufnew; gs.srcbuf = gs.srcbufnew;
gs.dstbuf = gs.dstbufnew; gs.dstbuf = gs.dstbufnew;
gs.trxpos = gs.trxposnew; gs.trxpos = gs.trxposnew;
gs.imageTransfer = data[0] & 0x3; gs.imageTransfer = data[0] & 0x3;
gs.imageWnew = gs.imageWtemp; gs.imageWnew = gs.imageWtemp;
gs.imageHnew = gs.imageHtemp; gs.imageHnew = gs.imageHtemp;
if( gs.imageWnew > 0 && gs.imageHnew > 0 ) { if (gs.imageWnew > 0 && gs.imageHnew > 0)
switch(gs.imageTransfer) { {
switch (gs.imageTransfer)
{
case 0: // host->loc case 0: // host->loc
ZeroGS::InitTransferHostLocal(); ZeroGS::InitTransferHostLocal();
break; break;
case 1: // loc->host case 1: // loc->host
ZeroGS::InitTransferLocalHost(); ZeroGS::InitTransferLocalHost();
break; break;
case 2:
case 2:
ZeroGS::TransferLocalLocal(); ZeroGS::TransferLocalLocal();
break; break;
@ -998,10 +1047,12 @@ void __fastcall GIFRegHandlerTRXDIR(u32* data)
gs.imageTransfer = -1; gs.imageTransfer = -1;
break; break;
default: assert(0); default:
assert(0);
} }
} }
else { else
{
#if defined(ZEROGS_DEVBUILD) #if defined(ZEROGS_DEVBUILD)
ZZLog::Warn_Log("Dummy transfer."); ZZLog::Warn_Log("Dummy transfer.");
#endif #endif
@ -1012,10 +1063,13 @@ void __fastcall GIFRegHandlerTRXDIR(u32* data)
void __fastcall GIFRegHandlerHWREG(u32* data) void __fastcall GIFRegHandlerHWREG(u32* data)
{ {
FUNCLOG FUNCLOG
if( gs.imageTransfer == 0 ) {
if (gs.imageTransfer == 0)
{
ZeroGS::TransferHostLocal(data, 2); ZeroGS::TransferHostLocal(data, 2);
} }
else { else
{
#if defined(ZEROGS_DEVBUILD) #if defined(ZEROGS_DEVBUILD)
ZZLog::Error_Log("ZeroGS: HWREG!? %8.8x_%8.8x", data[0], data[1]); ZZLog::Error_Log("ZeroGS: HWREG!? %8.8x_%8.8x", data[0], data[1]);
//assert(0); //assert(0);
@ -1028,31 +1082,34 @@ extern int g_GSMultiThreaded;
void __fastcall GIFRegHandlerSIGNAL(u32* data) void __fastcall GIFRegHandlerSIGNAL(u32* data)
{ {
FUNCLOG FUNCLOG
if(!g_GSMultiThreaded) {
SIGLBLID->SIGID = (SIGLBLID->SIGID&~data[1])|(data[0]&data[1]); if (!g_GSMultiThreaded)
{
SIGLBLID->SIGID = (SIGLBLID->SIGID & ~data[1]) | (data[0] & data[1]);
// if (gs.CSRw & 0x1) CSR->SIGNAL = 1; // if (gs.CSRw & 0x1) CSR->SIGNAL = 1;
// if (!IMR->SIGMSK && GSirq) // if (!IMR->SIGMSK && GSirq)
// GSirq(); // GSirq();
if (gs.CSRw & 0x1) { if (gs.CSRw & 0x1)
{
CSR->SIGNAL = 1; CSR->SIGNAL = 1;
//gs.CSRw &= ~1; //gs.CSRw &= ~1;
} }
if (!IMR->SIGMSK && GSirq)
GSirq(); if (!IMR->SIGMSK && GSirq) GSirq();
} }
} }
void __fastcall GIFRegHandlerFINISH(u32* data) void __fastcall GIFRegHandlerFINISH(u32* data)
{ {
FUNCLOG FUNCLOG
if(!g_GSMultiThreaded) {
if (gs.CSRw & 0x2) if (!g_GSMultiThreaded)
CSR->FINISH = 1; {
if (!IMR->FINISHMSK && GSirq) if (gs.CSRw & 0x2) CSR->FINISH = 1;
GSirq();
if (!IMR->FINISHMSK && GSirq) GSirq();
// if( gs.CSRw & 2 ) { // if( gs.CSRw & 2 ) {
// //gs.CSRw &= ~2; // //gs.CSRw &= ~2;
@ -1070,7 +1127,9 @@ void __fastcall GIFRegHandlerFINISH(u32* data)
void __fastcall GIFRegHandlerLABEL(u32* data) void __fastcall GIFRegHandlerLABEL(u32* data)
{ {
FUNCLOG FUNCLOG
if(!g_GSMultiThreaded) {
SIGLBLID->LBLID = (SIGLBLID->LBLID&~data[1])|(data[0]&data[1]); if (!g_GSMultiThreaded)
{
SIGLBLID->LBLID = (SIGLBLID->LBLID & ~data[1]) | (data[0] & data[1]);
} }
} }

494
plugins/zzogl-pg/opengl/ZZoglCRTC.cpp
View File

File diff suppressed because it is too large Load Diff

432
plugins/zzogl-pg/opengl/ZZoglCreate.cpp
View File

@ -79,59 +79,60 @@
#define VB_NUMBUFFERS 512 #define VB_NUMBUFFERS 512
// ----------------- Types // ----------------- Types
typedef void (APIENTRYP _PFNSWAPINTERVAL) (int); typedef void (APIENTRYP _PFNSWAPINTERVAL)(int);
map<string, GLbyte> mapGLExtensions; map<string, GLbyte> mapGLExtensions;
namespace ZeroGS{ namespace ZeroGS
RenderFormatType g_RenderFormatType = RFT_float16; {
RenderFormatType g_RenderFormatType = RFT_float16;
extern void KickPoint(); extern void KickPoint();
extern void KickLine(); extern void KickLine();
extern void KickTriangle(); extern void KickTriangle();
extern void KickTriangleFan(); extern void KickTriangleFan();
extern void KickSprite(); extern void KickSprite();
extern void KickDummy(); extern void KickDummy();
extern bool LoadEffects(); extern bool LoadEffects();
extern bool LoadExtraEffects(); extern bool LoadExtraEffects();
extern FRAGMENTSHADER* LoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed); extern FRAGMENTSHADER* LoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed);
VERTEXSHADER pvsBitBlt; VERTEXSHADER pvsBitBlt;
GLuint vboRect = 0; GLuint vboRect = 0;
vector<GLuint> g_vboBuffers; // VBOs for all drawing commands vector<GLuint> g_vboBuffers; // VBOs for all drawing commands
int g_nCurVBOIndex = 0; int g_nCurVBOIndex = 0;
inline bool CreateImportantCheck(); inline bool CreateImportantCheck();
inline void CreateOtherCheck(); inline void CreateOtherCheck();
inline bool CreateOpenShadersFile(); inline bool CreateOpenShadersFile();
} }
//------------------ Dummies //------------------ Dummies
#ifdef _WIN32 #ifdef _WIN32
void __stdcall glBlendFuncSeparateDummy(GLenum e1, GLenum e2, GLenum e3, GLenum e4) void __stdcall glBlendFuncSeparateDummy(GLenum e1, GLenum e2, GLenum e3, GLenum e4)
#else #else
void APIENTRY glBlendFuncSeparateDummy(GLenum e1, GLenum e2, GLenum e3, GLenum e4) void APIENTRY glBlendFuncSeparateDummy(GLenum e1, GLenum e2, GLenum e3, GLenum e4)
#endif #endif
{ {
glBlendFunc(e1, e2); glBlendFunc(e1, e2);
} }
#ifdef _WIN32 #ifdef _WIN32
void __stdcall glBlendEquationSeparateDummy(GLenum e1, GLenum e2) void __stdcall glBlendEquationSeparateDummy(GLenum e1, GLenum e2)
#else #else
void APIENTRY glBlendEquationSeparateDummy(GLenum e1, GLenum e2) void APIENTRY glBlendEquationSeparateDummy(GLenum e1, GLenum e2)
#endif #endif
{ {
glBlendEquation(e1); glBlendEquation(e1);
} }
#ifdef _WIN32 #ifdef _WIN32
extern HINSTANCE hInst; extern HINSTANCE hInst;
void (__stdcall *zgsBlendEquationSeparateEXT)(GLenum, GLenum) = NULL; void (__stdcall *zgsBlendEquationSeparateEXT)(GLenum, GLenum) = NULL;
void (__stdcall *zgsBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL; void (__stdcall *zgsBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL;
#else #else
void (APIENTRY *zgsBlendEquationSeparateEXT)(GLenum, GLenum) = NULL; void (APIENTRY *zgsBlendEquationSeparateEXT)(GLenum, GLenum) = NULL;
void (APIENTRY *zgsBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL; void (APIENTRY *zgsBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL;
#endif #endif
//------------------ variables //------------------ variables
@ -144,8 +145,8 @@ CGprogram pvs[16] = {NULL};
// String's for shader file in developer mode // String's for shader file in developer mode
#ifdef DEVBUILD #ifdef DEVBUILD
char* EFFECT_NAME=""; char* EFFECT_NAME = "";
char* EFFECT_DIR=""; char* EFFECT_DIR = "";
#endif #endif
///////////////////// /////////////////////
@ -183,52 +184,64 @@ BOOL g_bSaveFlushedFrame = 0;
//------------------ Code //------------------ Code
bool ZeroGS::IsGLExt( const char* szTargetExtension ) bool ZeroGS::IsGLExt(const char* szTargetExtension)
{ {
return mapGLExtensions.find(string(szTargetExtension)) != mapGLExtensions.end(); return mapGLExtensions.find(string(szTargetExtension)) != mapGLExtensions.end();
} }
inline bool inline bool
ZeroGS::Create_Window(int _width, int _height) { ZeroGS::Create_Window(int _width, int _height)
{
nBackbufferWidth = _width; nBackbufferWidth = _width;
nBackbufferHeight = _height; nBackbufferHeight = _height;
fiRendWidth = 1.0f / nBackbufferWidth; fiRendWidth = 1.0f / nBackbufferWidth;
fiRendHeight = 1.0f / nBackbufferHeight; fiRendHeight = 1.0f / nBackbufferHeight;
if (!GLWin.DisplayWindow(_width, _height)) return false; if (!GLWin.DisplayWindow(_width, _height)) return false;
s_nFullscreen = (conf.options & GSOPTION_FULLSCREEN) ? 1 : 0; s_nFullscreen = (conf.options & GSOPTION_FULLSCREEN) ? 1 : 0;
conf.mrtdepth = 0; // for now conf.mrtdepth = 0; // for now
return true; return true;
} }
// Function asks about different OGL extensions, that are required to setup accordingly. Return false if checks failed // Function asks about different OGL extensions, that are required to setup accordingly. Return false if checks failed
inline bool ZeroGS::CreateImportantCheck() { inline bool ZeroGS::CreateImportantCheck()
{
bool bSuccess = true; bool bSuccess = true;
#ifndef _WIN32 #ifndef _WIN32
int const glew_ok = glewInit(); int const glew_ok = glewInit();
if( glew_ok != GLEW_OK ) {
if (glew_ok != GLEW_OK)
{
ZZLog::Error_Log("glewInit() is not ok!"); ZZLog::Error_Log("glewInit() is not ok!");
bSuccess = false; bSuccess = false;
} }
#endif #endif
if( !IsGLExt("GL_EXT_framebuffer_object") ) { if (!IsGLExt("GL_EXT_framebuffer_object"))
{
ZZLog::Error_Log("*********\nZZogl: ERROR: Need GL_EXT_framebufer_object for multiple render targets\nZZogl: *********"); ZZLog::Error_Log("*********\nZZogl: ERROR: Need GL_EXT_framebufer_object for multiple render targets\nZZogl: *********");
bSuccess = false; bSuccess = false;
} }
if( !IsGLExt("GL_EXT_secondary_color") ) { if (!IsGLExt("GL_EXT_secondary_color"))
{
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_secondary_color\nZZogl: *********"); ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_secondary_color\nZZogl: *********");
bSuccess = false; bSuccess = false;
} }
// load the effect & find the best profiles (if any) // load the effect & find the best profiles (if any)
if( cgGLIsProfileSupported(CG_PROFILE_ARBVP1) != CG_TRUE ) { if (cgGLIsProfileSupported(CG_PROFILE_ARBVP1) != CG_TRUE)
{
ZZLog::Error_Log("arbvp1 not supported."); ZZLog::Error_Log("arbvp1 not supported.");
bSuccess = false; bSuccess = false;
} }
if( cgGLIsProfileSupported(CG_PROFILE_ARBFP1) != CG_TRUE ) {
if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1) != CG_TRUE)
{
ZZLog::Error_Log("arbfp1 not supported."); ZZLog::Error_Log("arbfp1 not supported.");
bSuccess = false; bSuccess = false;
} }
@ -237,43 +250,51 @@ inline bool ZeroGS::CreateImportantCheck() {
} }
// This is a check for less important open gl extensions. // This is a check for less important open gl extensions.
inline void ZeroGS::CreateOtherCheck() { inline void ZeroGS::CreateOtherCheck()
if( !IsGLExt("GL_EXT_blend_equation_separate") || glBlendEquationSeparateEXT == NULL ) { {
if (!IsGLExt("GL_EXT_blend_equation_separate") || glBlendEquationSeparateEXT == NULL)
{
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_blend_equation_separate\nZZogl: *********"); ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_blend_equation_separate\nZZogl: *********");
zgsBlendEquationSeparateEXT = glBlendEquationSeparateDummy; zgsBlendEquationSeparateEXT = glBlendEquationSeparateDummy;
} }
else else
zgsBlendEquationSeparateEXT = glBlendEquationSeparateEXT; zgsBlendEquationSeparateEXT = glBlendEquationSeparateEXT;
if( !IsGLExt("GL_EXT_blend_func_separate") || glBlendFuncSeparateEXT == NULL ) { if (!IsGLExt("GL_EXT_blend_func_separate") || glBlendFuncSeparateEXT == NULL)
{
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_blend_func_separate\nZZogl: *********"); ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_blend_func_separate\nZZogl: *********");
zgsBlendFuncSeparateEXT = glBlendFuncSeparateDummy; zgsBlendFuncSeparateEXT = glBlendFuncSeparateDummy;
} }
else else
zgsBlendFuncSeparateEXT = glBlendFuncSeparateEXT; zgsBlendFuncSeparateEXT = glBlendFuncSeparateEXT;
if( !IsGLExt("GL_ARB_draw_buffers") && !IsGLExt("GL_ATI_draw_buffers") ) { if (!IsGLExt("GL_ARB_draw_buffers") && !IsGLExt("GL_ATI_draw_buffers"))
{
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: multiple render targets not supported, some effects might look bad\nZZogl: *********"); ZZLog::Error_Log("*********\nZZogl: OGL WARNING: multiple render targets not supported, some effects might look bad\nZZogl: *********");
conf.mrtdepth = 0; conf.mrtdepth = 0;
} }
if( IsGLExt("GL_ARB_draw_buffers") ) if (IsGLExt("GL_ARB_draw_buffers"))
glDrawBuffers = (PFNGLDRAWBUFFERSPROC)wglGetProcAddress("glDrawBuffers"); glDrawBuffers = (PFNGLDRAWBUFFERSPROC)wglGetProcAddress("glDrawBuffers");
else if( IsGLExt("GL_ATI_draw_buffers") ) else if (IsGLExt("GL_ATI_draw_buffers"))
glDrawBuffers = (PFNGLDRAWBUFFERSPROC)wglGetProcAddress("glDrawBuffersATI"); glDrawBuffers = (PFNGLDRAWBUFFERSPROC)wglGetProcAddress("glDrawBuffersATI");
if (!IsGLExt("GL_ARB_multitexture")) if (!IsGLExt("GL_ARB_multitexture"))
ZZLog::Error_Log("No multitexturing."); ZZLog::Error_Log("No multitexturing.");
else else
ZZLog::Error_Log("Using multitexturing."); ZZLog::Error_Log("Using multitexturing.");
GLint Max_Texture_Size_NV = 0; GLint Max_Texture_Size_NV = 0;
GLint Max_Texture_Size_2d = 0; GLint Max_Texture_Size_2d = 0;
glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, &Max_Texture_Size_NV); glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, &Max_Texture_Size_NV);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &Max_Texture_Size_2d); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &Max_Texture_Size_2d);
ZZLog::Error_Log("Maximum texture size is %d for Tex_2d and %d for Tex_NV.", Max_Texture_Size_2d, Max_Texture_Size_NV); ZZLog::Error_Log("Maximum texture size is %d for Tex_2d and %d for Tex_NV.", Max_Texture_Size_2d, Max_Texture_Size_NV);
if (Max_Texture_Size_NV < 1024) if (Max_Texture_Size_NV < 1024)
ZZLog::Error_Log("Could not properly make bitmasks, so some textures will be missed."); ZZLog::Error_Log("Could not properly make bitmasks, so some textures will be missed.");
@ -291,44 +312,56 @@ inline void ZeroGS::CreateOtherCheck() {
g_RenderFormatType = RFT_byte8; g_RenderFormatType = RFT_byte8;
#ifdef _WIN32 #ifdef _WIN32
if( IsGLExt("WGL_EXT_swap_control") || IsGLExt("EXT_swap_control") ) if (IsGLExt("WGL_EXT_swap_control") || IsGLExt("EXT_swap_control"))
wglSwapIntervalEXT(0); wglSwapIntervalEXT(0);
#else #else
if( IsGLExt("GLX_SGI_swap_control") ) { if (IsGLExt("GLX_SGI_swap_control"))
{
_PFNSWAPINTERVAL swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapInterval"); _PFNSWAPINTERVAL swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapInterval");
if( !swapinterval )
if (!swapinterval)
swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapIntervalSGI"); swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapIntervalSGI");
if( !swapinterval )
if (!swapinterval)
swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapIntervalEXT"); swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapIntervalEXT");
if( swapinterval ) if (swapinterval)
swapinterval(0); swapinterval(0);
else else
ZZLog::Error_Log("No support for SwapInterval (framerate clamped to monitor refresh rate),"); ZZLog::Error_Log("No support for SwapInterval (framerate clamped to monitor refresh rate),");
} }
#endif #endif
} }
// open shader file according to build target // open shader file according to build target
inline bool ZeroGS::CreateOpenShadersFile() { inline bool ZeroGS::CreateOpenShadersFile()
{
#ifndef DEVBUILD #ifndef DEVBUILD
# ifdef _WIN32 # ifdef _WIN32
HRSRC hShaderSrc = FindResource(hInst, MAKEINTRESOURCE(IDR_SHADERS), RT_RCDATA); HRSRC hShaderSrc = FindResource(hInst, MAKEINTRESOURCE(IDR_SHADERS), RT_RCDATA);
assert( hShaderSrc != NULL ); assert(hShaderSrc != NULL);
HGLOBAL hShaderGlob = LoadResource(hInst, hShaderSrc); HGLOBAL hShaderGlob = LoadResource(hInst, hShaderSrc);
assert( hShaderGlob != NULL ); assert(hShaderGlob != NULL);
s_lpShaderResources = (u8*)LockResource(hShaderGlob); s_lpShaderResources = (u8*)LockResource(hShaderGlob);
# else // not _WIN32 # else // not _WIN32
FILE* fres = fopen("ps2hw.dat", "rb"); FILE* fres = fopen("ps2hw.dat", "rb");
if( fres == NULL ) {
if (fres == NULL)
{
fres = fopen("plugins/ps2hw.dat", "rb"); fres = fopen("plugins/ps2hw.dat", "rb");
if( fres == NULL ) {
if (fres == NULL)
{
ZZLog::Error_Log("Cannot find ps2hw.dat in working directory. Exiting."); ZZLog::Error_Log("Cannot find ps2hw.dat in working directory. Exiting.");
return false; return false;
} }
} }
fseek(fres, 0, SEEK_END); fseek(fres, 0, SEEK_END);
size_t s = ftell(fres); size_t s = ftell(fres);
s_lpShaderResources = new u8[s+1]; s_lpShaderResources = new u8[s+1];
fseek(fres, 0, SEEK_SET); fseek(fres, 0, SEEK_SET);
@ -345,42 +378,49 @@ inline bool ZeroGS::CreateOpenShadersFile() {
strcpy(tempstr, "/plugins/"); strcpy(tempstr, "/plugins/");
sprintf(EFFECT_NAME, "%sps2hw.fx", tempstr); sprintf(EFFECT_NAME, "%sps2hw.fx", tempstr);
FILE* f = fopen(EFFECT_NAME, "r"); FILE* f = fopen(EFFECT_NAME, "r");
if( f == NULL ) {
if (f == NULL)
{
strcpy(tempstr, "../../plugins/zzogl-pg/opengl/"); strcpy(tempstr, "../../plugins/zzogl-pg/opengl/");
sprintf(EFFECT_NAME, "%sps2hw.fx", tempstr); sprintf(EFFECT_NAME, "%sps2hw.fx", tempstr);
f = fopen(EFFECT_NAME, "r"); f = fopen(EFFECT_NAME, "r");
if( f == NULL ) { if (f == NULL)
{
ZZLog::Error_Log("Failed to find %s, try compiling a non-devbuild.", EFFECT_NAME); ZZLog::Error_Log("Failed to find %s, try compiling a non-devbuild.", EFFECT_NAME);
return false; return false;
} }
} }
fclose(f); fclose(f);
sprintf(EFFECT_DIR, "%s/%s", curwd, tempstr); sprintf(EFFECT_DIR, "%s/%s", curwd, tempstr);
sprintf(EFFECT_NAME, "%sps2hw.fx", EFFECT_DIR); sprintf(EFFECT_NAME, "%sps2hw.fx", EFFECT_DIR);
#endif #endif
#endif // !defined(ZEROGS_DEVBUILD) #endif // !defined(ZEROGS_DEVBUILD)
return true; return true;
} }
// Read all extensions name and fill mapGLExtensions // Read all extensions name and fill mapGLExtensions
inline bool CreateFillExtensionsMap(){ inline bool CreateFillExtensionsMap()
{
// fill the opengl extension map // fill the opengl extension map
const char* ptoken = (const char*)glGetString( GL_EXTENSIONS ); const char* ptoken = (const char*)glGetString(GL_EXTENSIONS);
if( ptoken == NULL ) return false;
if (ptoken == NULL) return false;
int prevlog = conf.log; int prevlog = conf.log;
conf.log = 1; conf.log = 1;
ZZLog::GS_Log("Supported OpenGL Extensions:\n%s\n", ptoken); // write to the log file ZZLog::GS_Log("Supported OpenGL Extensions:\n%s\n", ptoken); // write to the log file
// Probably a better way to do it, but seems to crash. // Probably a better way to do it, but seems to crash.
/*int n; /*int n;
glGetIntegerv(GL_NUM_EXTENSIONS, &n); glGetIntegerv(GL_NUM_EXTENSIONS, &n);
ZZLog::GS_Log("Supported OpenGL Extensions:\n"); ZZLog::GS_Log("Supported OpenGL Extensions:\n");
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
{ {
ZZLog::GS_Log("%s/n", (const char*)glGetStringi(GL_EXTENSIONS, i)); ZZLog::GS_Log("%s/n", (const char*)glGetStringi(GL_EXTENSIONS, i));
}*/ }*/
@ -391,20 +431,25 @@ inline bool CreateFillExtensionsMap(){
const char* pend = NULL; const char* pend = NULL;
while(ptoken != NULL ) { while (ptoken != NULL)
{
pend = strchr(ptoken, ' '); pend = strchr(ptoken, ' ');
if( pend != NULL ) { if (pend != NULL)
{
mapGLExtensions[string(ptoken, pend-ptoken)]; mapGLExtensions[string(ptoken, pend-ptoken)];
} }
else { else
{
mapGLExtensions[string(ptoken)]; mapGLExtensions[string(ptoken)];
break; break;
} }
ptoken = pend; ptoken = pend;
while(*ptoken == ' ') ++ptoken;
while (*ptoken == ' ') ++ptoken;
} }
return true; return true;
} }
@ -426,20 +471,21 @@ bool ZeroGS::Create(int _width, int _height)
if (!Create_Window(_width, _height)) return false; if (!Create_Window(_width, _height)) return false;
if (!CreateFillExtensionsMap()) return false; if (!CreateFillExtensionsMap()) return false;
if (!CreateImportantCheck()) return false; if (!CreateImportantCheck()) return false;
ZeroGS::CreateOtherCheck(); ZeroGS::CreateOtherCheck();
// check the max texture width and height // check the max texture width and height
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &g_MaxTexWidth); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &g_MaxTexWidth);
g_MaxTexHeight = g_MaxTexWidth/4;
GPU_TEXWIDTH = g_MaxTexWidth/8; g_MaxTexHeight = g_MaxTexWidth / 4;
GPU_TEXWIDTH = g_MaxTexWidth / 8;
g_fiGPU_TEXWIDTH = 1.0f / GPU_TEXWIDTH; g_fiGPU_TEXWIDTH = 1.0f / GPU_TEXWIDTH;
if (!CreateOpenShadersFile()) if (!CreateOpenShadersFile()) return false;
return false;
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
if (err != GL_NO_ERROR) bSuccess = false;
s_srcrgb = s_dstrgb = s_srcalpha = s_dstalpha = GL_ONE; s_srcrgb = s_dstrgb = s_srcalpha = s_dstalpha = GL_ONE;
@ -461,28 +507,31 @@ bool ZeroGS::Create(int _width, int _height)
GL_LOADFN(glGetFramebufferAttachmentParameterivEXT); GL_LOADFN(glGetFramebufferAttachmentParameterivEXT);
GL_LOADFN(glGenerateMipmapEXT); GL_LOADFN(glGenerateMipmapEXT);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
glGenFramebuffersEXT( 1, &s_uFramebuffer); if (err != GL_NO_ERROR) bSuccess = false;
if( s_uFramebuffer == 0 ) {
glGenFramebuffersEXT(1, &s_uFramebuffer);
if (s_uFramebuffer == 0)
{
ZZLog::Error_Log("Failed to create the renderbuffer."); ZZLog::Error_Log("Failed to create the renderbuffer.");
} }
assert( glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT ); assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT);
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, s_uFramebuffer );
if( glDrawBuffers != NULL ) glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, s_uFramebuffer);
glDrawBuffers(1, s_drawbuffers);
if (glDrawBuffers != NULL) glDrawBuffers(1, s_drawbuffers);
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
if (err != GL_NO_ERROR) bSuccess = false;
font_p = new RasterFont(); font_p = new RasterFont();
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
if (err != GL_NO_ERROR) bSuccess = false;
// init draw fns // init draw fns
drawfn[0] = KickPoint; drawfn[0] = KickPoint;
@ -495,64 +544,76 @@ bool ZeroGS::Create(int _width, int _height)
drawfn[7] = KickDummy; drawfn[7] = KickDummy;
SetAA(conf.aa); SetAA(conf.aa);
GSsetGameCRC(g_LastCRC, g_GameSettings); GSsetGameCRC(g_LastCRC, g_GameSettings);
GL_STENCILFUNC(GL_ALWAYS, 0, 0); GL_STENCILFUNC(GL_ALWAYS, 0, 0);
//g_GameSettings |= 0;//GAME_VSSHACK|GAME_FULL16BITRES|GAME_NODEPTHRESOLVE|GAME_FASTUPDATE; //g_GameSettings |= 0;//GAME_VSSHACK|GAME_FULL16BITRES|GAME_NODEPTHRESOLVE|GAME_FASTUPDATE;
//s_bWriteDepth = TRUE; //s_bWriteDepth = TRUE;
GL_BLEND_ALL(GL_ONE, GL_ONE, GL_ONE, GL_ONE); GL_BLEND_ALL(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
glViewport(0, 0, nBackbufferWidth, nBackbufferHeight); // Reset The Current Viewport
glViewport(0,0,nBackbufferWidth,nBackbufferHeight); // Reset The Current Viewport
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
glShadeModel(GL_SMOOTH); glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f); glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
glDepthFunc(GL_LEQUAL); glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
glGenTextures(1, &ptexLogo); glGenTextures(1, &ptexLogo);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, ptexLogo); glBindTexture(GL_TEXTURE_RECTANGLE_NV, ptexLogo);
#ifdef _WIN32 #ifdef _WIN32
HRSRC hBitmapSrc = FindResource(hInst, MAKEINTRESOURCE(IDB_ZEROGSLOGO), RT_BITMAP); HRSRC hBitmapSrc = FindResource(hInst, MAKEINTRESOURCE(IDB_ZEROGSLOGO), RT_BITMAP);
assert( hBitmapSrc != NULL ); assert(hBitmapSrc != NULL);
HGLOBAL hBitmapGlob = LoadResource(hInst, hBitmapSrc); HGLOBAL hBitmapGlob = LoadResource(hInst, hBitmapSrc);
assert( hBitmapGlob != NULL ); assert(hBitmapGlob != NULL);
PBITMAPINFO pinfo = (PBITMAPINFO)LockResource(hBitmapGlob); PBITMAPINFO pinfo = (PBITMAPINFO)LockResource(hBitmapGlob);
glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 4, pinfo->bmiHeader.biWidth, pinfo->bmiHeader.biHeight, 0, pinfo->bmiHeader.biBitCount==32?GL_RGBA:GL_RGB, GL_UNSIGNED_BYTE, (u8*)pinfo+pinfo->bmiHeader.biSize); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 4, pinfo->bmiHeader.biWidth, pinfo->bmiHeader.biHeight, 0, pinfo->bmiHeader.biBitCount == 32 ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, (u8*)pinfo + pinfo->bmiHeader.biSize);
nLogoWidth = pinfo->bmiHeader.biWidth; nLogoWidth = pinfo->bmiHeader.biWidth;
nLogoHeight = pinfo->bmiHeader.biHeight; nLogoHeight = pinfo->bmiHeader.biHeight;
glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#else #else
#endif #endif
GL_REPORT_ERROR(); GL_REPORT_ERROR();
g_nCurVBOIndex = 0; g_nCurVBOIndex = 0;
g_vboBuffers.resize(VB_NUMBUFFERS); g_vboBuffers.resize(VB_NUMBUFFERS);
glGenBuffers((GLsizei)g_vboBuffers.size(), &g_vboBuffers[0]); glGenBuffers((GLsizei)g_vboBuffers.size(), &g_vboBuffers[0]);
for(i = 0; i < (int)g_vboBuffers.size(); ++i) {
for (i = 0; i < (int)g_vboBuffers.size(); ++i)
{
glBindBuffer(GL_ARRAY_BUFFER, g_vboBuffers[i]); glBindBuffer(GL_ARRAY_BUFFER, g_vboBuffers[i]);
glBufferData(GL_ARRAY_BUFFER, 0x100*sizeof(VertexGPU), NULL, GL_STREAM_DRAW); glBufferData(GL_ARRAY_BUFFER, 0x100*sizeof(VertexGPU), NULL, GL_STREAM_DRAW);
} }
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false; if (err != GL_NO_ERROR) bSuccess = false;
// create the blocks texture // create the blocks texture
g_fBlockMult = 1; g_fBlockMult = 1;
vector<char> vBlockData, vBilinearData; vector<char> vBlockData, vBilinearData;
BLOCK::FillBlocks(vBlockData, vBilinearData, 1); BLOCK::FillBlocks(vBlockData, vBilinearData, 1);
glGenTextures(1, &ptexBlocks); glGenTextures(1, &ptexBlocks);
@ -564,7 +625,8 @@ bool ZeroGS::Create(int _width, int _height)
glTexImage2D(GL_TEXTURE_2D, 0, g_internalFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_ALPHA, GL_FLOAT, &vBlockData[0]); glTexImage2D(GL_TEXTURE_2D, 0, g_internalFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_ALPHA, GL_FLOAT, &vBlockData[0]);
if( glGetError() != GL_NO_ERROR ) { if (glGetError() != GL_NO_ERROR)
{
// try different internal format // try different internal format
g_internalFloatFmt = GL_FLOAT_R32_NV; g_internalFloatFmt = GL_FLOAT_R32_NV;
glTexImage2D(GL_TEXTURE_2D, 0, g_internalFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RED, GL_FLOAT, &vBlockData[0]); glTexImage2D(GL_TEXTURE_2D, 0, g_internalFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RED, GL_FLOAT, &vBlockData[0]);
@ -575,26 +637,31 @@ bool ZeroGS::Create(int _width, int _height)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
if( glGetError() != GL_NO_ERROR ) { if (glGetError() != GL_NO_ERROR)
{
// error, resort to 16bit // error, resort to 16bit
g_fBlockMult = 65535.0f*(float)g_fiGPU_TEXWIDTH / 32.0f; g_fBlockMult = 65535.0f * (float)g_fiGPU_TEXWIDTH / 32.0f;
BLOCK::FillBlocks(vBlockData, vBilinearData, 0); BLOCK::FillBlocks(vBlockData, vBilinearData, 0);
glTexImage2D(GL_TEXTURE_2D, 0, 2, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_R, GL_UNSIGNED_SHORT, &vBlockData[0]); glTexImage2D(GL_TEXTURE_2D, 0, 2, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_R, GL_UNSIGNED_SHORT, &vBlockData[0]);
if( glGetError() != GL_NO_ERROR ) {
if (glGetError() != GL_NO_ERROR)
{
ZZLog::Error_Log("Could not fill blocks."); ZZLog::Error_Log("Could not fill blocks.");
return false; return false;
} }
ZZLog::Error_Log("Using non-bilinear fill."); ZZLog::Error_Log("Using non-bilinear fill.");
} }
else { else
{
// fill in the bilinear blocks // fill in the bilinear blocks
glGenTextures(1, &ptexBilinearBlocks); glGenTextures(1, &ptexBilinearBlocks);
glBindTexture(GL_TEXTURE_2D, ptexBilinearBlocks); glBindTexture(GL_TEXTURE_2D, ptexBilinearBlocks);
glTexImage2D(GL_TEXTURE_2D, 0, g_internalRGBAFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RGBA, GL_FLOAT, &vBilinearData[0]); glTexImage2D(GL_TEXTURE_2D, 0, g_internalRGBAFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RGBA, GL_FLOAT, &vBilinearData[0]);
if( glGetError() != GL_NO_ERROR ) { if (glGetError() != GL_NO_ERROR)
{
g_internalRGBAFloatFmt = GL_FLOAT_RGBA32_NV; g_internalRGBAFloatFmt = GL_FLOAT_RGBA32_NV;
g_internalRGBAFloat16Fmt = GL_FLOAT_RGBA16_NV; g_internalRGBAFloat16Fmt = GL_FLOAT_RGBA16_NV;
glTexImage2D(GL_TEXTURE_2D, 0, g_internalRGBAFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RGBA, GL_FLOAT, &vBilinearData[0]); glTexImage2D(GL_TEXTURE_2D, 0, g_internalRGBAFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RGBA, GL_FLOAT, &vBilinearData[0]);
@ -603,7 +670,8 @@ bool ZeroGS::Create(int _width, int _height)
} }
else else
{ {
ZZLog::Error_Log("Fill bilinear blocks failed!"); // No, they failed on the first clause of the if statement, not the second.
//ZZLog::Error_Log("Fill bilinear blocks failed!");
} }
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@ -613,9 +681,10 @@ bool ZeroGS::Create(int _width, int _height)
} }
float fpri = 1; float fpri = 1;
glPrioritizeTextures(1, &ptexBlocks, &fpri); glPrioritizeTextures(1, &ptexBlocks, &fpri);
if( ptexBilinearBlocks != 0 )
glPrioritizeTextures(1, &ptexBilinearBlocks, &fpri); if (ptexBilinearBlocks != 0) glPrioritizeTextures(1, &ptexBilinearBlocks, &fpri);
GL_REPORT_ERROR(); GL_REPORT_ERROR();
@ -624,11 +693,37 @@ bool ZeroGS::Create(int _width, int _height)
glBindBuffer(GL_ARRAY_BUFFER, vboRect); glBindBuffer(GL_ARRAY_BUFFER, vboRect);
vector<VertexGPU> verts(4); vector<VertexGPU> verts(4);
VertexGPU* pvert = &verts[0]; VertexGPU* pvert = &verts[0];
pvert->x = -0x7fff; pvert->y = 0x7fff; pvert->z = 0; pvert->s = 0; pvert->t = 0; pvert++;
pvert->x = 0x7fff; pvert->y = 0x7fff; pvert->z = 0; pvert->s = 1; pvert->t = 0; pvert++; pvert->x = -0x7fff;
pvert->x = -0x7fff; pvert->y = -0x7fff; pvert->z = 0; pvert->s = 0; pvert->t = 1; pvert++; pvert->y = 0x7fff;
pvert->x = 0x7fff; pvert->y = -0x7fff; pvert->z = 0; pvert->s = 1; pvert->t = 1; pvert++; pvert->z = 0;
pvert->s = 0;
pvert->t = 0;
pvert++;
pvert->x = 0x7fff;
pvert->y = 0x7fff;
pvert->z = 0;
pvert->s = 1;
pvert->t = 0;
pvert++;
pvert->x = -0x7fff;
pvert->y = -0x7fff;
pvert->z = 0;
pvert->s = 0;
pvert->t = 1;
pvert++;
pvert->x = 0x7fff;
pvert->y = -0x7fff;
pvert->z = 0;
pvert->s = 1;
pvert->t = 1;
pvert++;
glBufferDataARB(GL_ARRAY_BUFFER, 4*sizeof(VertexGPU), &verts[0], GL_STATIC_DRAW); glBufferDataARB(GL_ARRAY_BUFFER, 4*sizeof(VertexGPU), &verts[0], GL_STATIC_DRAW);
// setup the default vertex declaration // setup the default vertex declaration
@ -649,33 +744,45 @@ bool ZeroGS::Create(int _width, int _height)
glBindTexture(GL_TEXTURE_2D, ptexConv16to32); glBindTexture(GL_TEXTURE_2D, ptexConv16to32);
vector<u32> conv16to32data(256*256); vector<u32> conv16to32data(256*256);
for(i = 0; i < 256*256; ++i) {
for (i = 0; i < 256*256; ++i)
{
u32 tempcol = RGBA16to32(i); u32 tempcol = RGBA16to32(i);
// have to flip r and b // have to flip r and b
conv16to32data[i] = (tempcol&0xff00ff00)|((tempcol&0xff)<<16)|((tempcol&0xff0000)>>16); conv16to32data[i] = (tempcol & 0xff00ff00) | ((tempcol & 0xff) << 16) | ((tempcol & 0xff0000) >> 16);
} }
glTexImage2D(GL_TEXTURE_2D, 0, 4, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, &conv16to32data[0]); glTexImage2D(GL_TEXTURE_2D, 0, 4, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, &conv16to32data[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
if (err != GL_NO_ERROR) bSuccess = false;
vector<u32> conv32to16data(32*32*32); vector<u32> conv32to16data(32*32*32);
glGenTextures(1, &ptexConv32to16); glGenTextures(1, &ptexConv32to16);
glBindTexture(GL_TEXTURE_3D, ptexConv32to16); glBindTexture(GL_TEXTURE_3D, ptexConv32to16);
u32* dst = &conv32to16data[0]; u32* dst = &conv32to16data[0];
for(i = 0; i < 32; ++i) {
for(int j = 0; j < 32; ++j) { for (i = 0; i < 32; ++i)
for(int k = 0; k < 32; ++k) { {
u32 col = (i<<10)|(j<<5)|k; for (int j = 0; j < 32; ++j)
*dst++ = ((col&0xff)<<16)|(col&0xff00); {
for (int k = 0; k < 32; ++k)
{
u32 col = (i << 10) | (j << 5) | k;
*dst++ = ((col & 0xff) << 16) | (col & 0xff00);
} }
} }
} }
glTexImage3D(GL_TEXTURE_3D, 0, 4, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, &conv32to16data[0]); glTexImage3D(GL_TEXTURE_3D, 0, 4, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, &conv32to16data[0]);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@ -683,18 +790,22 @@ bool ZeroGS::Create(int _width, int _height)
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP);
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
if (err != GL_NO_ERROR) bSuccess = false;
g_cgcontext = cgCreateContext(); g_cgcontext = cgCreateContext();
cgvProf = CG_PROFILE_ARBVP1; cgvProf = CG_PROFILE_ARBVP1;
cgfProf = CG_PROFILE_ARBFP1; cgfProf = CG_PROFILE_ARBFP1;
cgGLEnableProfile(cgvProf); cgGLEnableProfile(cgvProf);
cgGLEnableProfile(cgfProf); cgGLEnableProfile(cgfProf);
cgGLSetOptimalOptions(cgvProf); cgGLSetOptimalOptions(cgvProf);
cgGLSetOptimalOptions(cgfProf); cgGLSetOptimalOptions(cgfProf);
cgGLSetManageTextureParameters(g_cgcontext, CG_FALSE); cgGLSetManageTextureParameters(g_cgcontext, CG_FALSE);
//cgSetAutoCompile(g_cgcontext, CG_COMPILE_IMMEDIATE); //cgSetAutoCompile(g_cgcontext, CG_COMPILE_IMMEDIATE);
g_fparamFogColor = cgCreateParameter(g_cgcontext, CG_FLOAT4); g_fparamFogColor = cgCreateParameter(g_cgcontext, CG_FLOAT4);
@ -702,6 +813,7 @@ bool ZeroGS::Create(int _width, int _height)
g_vparamPosXY[1] = cgCreateParameter(g_cgcontext, CG_FLOAT4); g_vparamPosXY[1] = cgCreateParameter(g_cgcontext, CG_FLOAT4);
ZZLog::Error_Log("Creating effects."); ZZLog::Error_Log("Creating effects.");
B_G(LoadEffects(), return false); B_G(LoadEffects(), return false);
g_bDisplayMsg = 0; g_bDisplayMsg = 0;
@ -709,41 +821,54 @@ bool ZeroGS::Create(int _width, int _height)
// create a sample shader // create a sample shader
clampInfo temp; clampInfo temp;
memset(&temp, 0, sizeof(temp)); memset(&temp, 0, sizeof(temp));
temp.wms = 3; temp.wmt = 3;
temp.wms = 3;
temp.wmt = 3;
g_nPixelShaderVer = 0;//SHADER_ACCURATE; g_nPixelShaderVer = 0;//SHADER_ACCURATE;
// test // test
bool bFailed; bool bFailed;
FRAGMENTSHADER* pfrag = LoadShadeEffect(0, 1, 1, 1, 1, temp, 0, &bFailed); FRAGMENTSHADER* pfrag = LoadShadeEffect(0, 1, 1, 1, 1, temp, 0, &bFailed);
if( bFailed || pfrag == NULL ) {
g_nPixelShaderVer = SHADER_ACCURATE|SHADER_REDUCED; if (bFailed || pfrag == NULL)
{
g_nPixelShaderVer = SHADER_ACCURATE | SHADER_REDUCED;
pfrag = LoadShadeEffect(0, 0, 1, 1, 0, temp, 0, &bFailed); pfrag = LoadShadeEffect(0, 0, 1, 1, 0, temp, 0, &bFailed);
if( pfrag != NULL )
if (pfrag != NULL)
cgGLLoadProgram(pfrag->prog); cgGLLoadProgram(pfrag->prog);
if( bFailed || pfrag == NULL || cgGetError() != CG_NO_ERROR ) {
if (bFailed || pfrag == NULL || cgGetError() != CG_NO_ERROR)
{
g_nPixelShaderVer = SHADER_REDUCED; g_nPixelShaderVer = SHADER_REDUCED;
ZZLog::Error_Log("Basic shader test failed."); ZZLog::Error_Log("Basic shader test failed.");
} }
} }
g_bDisplayMsg = 1; g_bDisplayMsg = 1;
if( g_nPixelShaderVer & SHADER_REDUCED )
conf.bilinear = 0; if (g_nPixelShaderVer & SHADER_REDUCED) conf.bilinear = 0;
ZZLog::Error_Log("Creating extra effects."); ZZLog::Error_Log("Creating extra effects.");
B_G(LoadExtraEffects(), return false); B_G(LoadExtraEffects(), return false);
ZZLog::Error_Log("Using %s shaders.", g_pShaders[g_nPixelShaderVer]); ZZLog::Error_Log("Using %s shaders.", g_pShaders[g_nPixelShaderVer]);
GL_REPORT_ERROR(); GL_REPORT_ERROR();
if( err != GL_NO_ERROR ) bSuccess = false;
if (err != GL_NO_ERROR) bSuccess = false;
glDisable(GL_STENCIL_TEST); glDisable(GL_STENCIL_TEST);
glEnable(GL_SCISSOR_TEST); glEnable(GL_SCISSOR_TEST);
GL_BLEND_ALPHA(GL_ONE, GL_ZERO); GL_BLEND_ALPHA(GL_ONE, GL_ZERO);
glBlendColorEXT(0, 0, 0, 0.5f); glBlendColorEXT(0, 0, 0, 0.5f);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
@ -751,20 +876,27 @@ bool ZeroGS::Create(int _width, int _height)
// points // points
// This was changed in SetAA - should we be changing it back? // This was changed in SetAA - should we be changing it back?
glPointSize(1.0f); glPointSize(1.0f);
g_nDepthBias = 0; g_nDepthBias = 0;
glEnable(GL_POLYGON_OFFSET_FILL); glEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_POLYGON_OFFSET_LINE); glEnable(GL_POLYGON_OFFSET_LINE);
glPolygonOffset(0, 1); glPolygonOffset(0, 1);
vb[0].Init(VB_BUFFERSIZE); vb[0].Init(VB_BUFFERSIZE);
vb[1].Init(VB_BUFFERSIZE); vb[1].Init(VB_BUFFERSIZE);
g_bSaveFlushedFrame = 1; g_bSaveFlushedFrame = 1;
g_vsprog = g_psprog = 0; g_vsprog = g_psprog = 0;
if (glGetError() == GL_NO_ERROR) if (glGetError() == GL_NO_ERROR)
{
return bSuccess; return bSuccess;
else { }
else
{
ZZLog::Error_Log("In final init!"); ZZLog::Error_Log("In final init!");
return false; return false;
} }
@ -772,7 +904,8 @@ bool ZeroGS::Create(int _width, int _height)
void ZeroGS::Destroy(BOOL bD3D) void ZeroGS::Destroy(BOOL bD3D)
{ {
if( s_aviinit ) { if (s_aviinit)
{
StopCapture(); StopCapture();
Stop_Avi(); Stop_Avi();
ZZLog::Error_Log("zerogs.avi stopped."); ZZLog::Error_Log("zerogs.avi stopped.");
@ -780,6 +913,7 @@ void ZeroGS::Destroy(BOOL bD3D)
} }
g_MemTargs.Destroy(); g_MemTargs.Destroy();
s_RTs.Destroy(); s_RTs.Destroy();
s_DepthRTs.Destroy(); s_DepthRTs.Destroy();
s_BitwiseTextures.Destroy(); s_BitwiseTextures.Destroy();
@ -793,28 +927,40 @@ void ZeroGS::Destroy(BOOL bD3D)
vb[0].Destroy(); vb[0].Destroy();
vb[1].Destroy(); vb[1].Destroy();
if( g_vboBuffers.size() > 0 ) { if (g_vboBuffers.size() > 0)
{
glDeleteBuffers((GLsizei)g_vboBuffers.size(), &g_vboBuffers[0]); glDeleteBuffers((GLsizei)g_vboBuffers.size(), &g_vboBuffers[0]);
g_vboBuffers.clear(); g_vboBuffers.clear();
} }
g_nCurVBOIndex = 0; g_nCurVBOIndex = 0;
for(int i = 0; i < ARRAY_SIZE(pvs); ++i) { for (int i = 0; i < ARRAY_SIZE(pvs); ++i)
{
SAFE_RELEASE_PROG(pvs[i]); SAFE_RELEASE_PROG(pvs[i]);
} }
for(int i = 0; i < ARRAY_SIZE(ppsRegular); ++i) {
for (int i = 0; i < ARRAY_SIZE(ppsRegular); ++i)
{
SAFE_RELEASE_PROG(ppsRegular[i].prog); SAFE_RELEASE_PROG(ppsRegular[i].prog);
} }
for(int i = 0; i < ARRAY_SIZE(ppsTexture); ++i) {
for (int i = 0; i < ARRAY_SIZE(ppsTexture); ++i)
{
SAFE_RELEASE_PROG(ppsTexture[i].prog); SAFE_RELEASE_PROG(ppsTexture[i].prog);
} }
SAFE_RELEASE_PROG(pvsBitBlt.prog); SAFE_RELEASE_PROG(pvsBitBlt.prog);
SAFE_RELEASE_PROG(ppsBitBlt[0].prog); SAFE_RELEASE_PROG(ppsBitBlt[1].prog);
SAFE_RELEASE_PROG(ppsBitBlt[0].prog);
SAFE_RELEASE_PROG(ppsBitBlt[1].prog);
SAFE_RELEASE_PROG(ppsBitBltDepth.prog); SAFE_RELEASE_PROG(ppsBitBltDepth.prog);
SAFE_RELEASE_PROG(ppsCRTCTarg[0].prog); SAFE_RELEASE_PROG(ppsCRTCTarg[1].prog); SAFE_RELEASE_PROG(ppsCRTCTarg[0].prog);
SAFE_RELEASE_PROG(ppsCRTC[0].prog); SAFE_RELEASE_PROG(ppsCRTC[1].prog); SAFE_RELEASE_PROG(ppsCRTCTarg[1].prog);
SAFE_RELEASE_PROG(ppsCRTC24[0].prog); SAFE_RELEASE_PROG(ppsCRTC24[1].prog); SAFE_RELEASE_PROG(ppsCRTC[0].prog);
SAFE_RELEASE_PROG(ppsCRTC[1].prog);
SAFE_RELEASE_PROG(ppsCRTC24[0].prog);
SAFE_RELEASE_PROG(ppsCRTC24[1].prog);
SAFE_RELEASE_PROG(ppsOne.prog); SAFE_RELEASE_PROG(ppsOne.prog);
SAFE_DELETE(font_p); SAFE_DELETE(font_p);

2196
plugins/zzogl-pg/opengl/ZZoglFlush.cpp
View File

File diff suppressed because it is too large Load Diff

49
plugins/zzogl-pg/opengl/ZZoglSave.cpp
View File

@ -46,31 +46,38 @@ extern u32 s_uTex1Data[2][2], s_uClampData[2];
int ZeroGS::Save(s8* pbydata) int ZeroGS::Save(s8* pbydata)
{ {
if( pbydata == NULL ) if (pbydata == NULL)
return 40 + 0x00400000 + sizeof(gs) + 2*VBSAVELIMIT + 2*sizeof(frameInfo) + 4 + 256*4; return 40 + 0x00400000 + sizeof(gs) + 2*VBSAVELIMIT + 2*sizeof(frameInfo) + 4 + 256*4;
s_RTs.ResolveAll(); s_RTs.ResolveAll();
s_DepthRTs.ResolveAll(); s_DepthRTs.ResolveAll();
strcpy((char*)pbydata, libraryNameX); strcpy((char*)pbydata, libraryNameX);
*(u32*)(pbydata+16) = ZEROGS_SAVEVER;
pbydata += 32;
*(int*)pbydata = icurctx; pbydata += 4; *(u32*)(pbydata + 16) = ZEROGS_SAVEVER;
*(int*)pbydata = VBSAVELIMIT; pbydata += 4;
pbydata += 32;
*(int*)pbydata = icurctx;
pbydata += 4;
*(int*)pbydata = VBSAVELIMIT;
pbydata += 4;
memcpy(pbydata, g_pbyGSMemory, 0x00400000); memcpy(pbydata, g_pbyGSMemory, 0x00400000);
pbydata += 0x00400000; pbydata += 0x00400000;
memcpy(pbydata, g_pbyGSClut, 256*4); memcpy(pbydata, g_pbyGSClut, 256*4);
pbydata += 256*4; pbydata += 256 * 4;
*(int*)pbydata = sizeof(gs); *(int*)pbydata = sizeof(gs);
pbydata += 4; pbydata += 4;
memcpy(pbydata, &gs, sizeof(gs)); memcpy(pbydata, &gs, sizeof(gs));
pbydata += sizeof(gs); pbydata += sizeof(gs);
for(int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i)
{
memcpy(pbydata, &vb[i], VBSAVELIMIT); memcpy(pbydata, &vb[i], VBSAVELIMIT);
pbydata += VBSAVELIMIT; pbydata += VBSAVELIMIT;
} }
@ -86,10 +93,10 @@ bool ZeroGS::Load(s8* pbydata)
g_nCurVBOIndex = 0; g_nCurVBOIndex = 0;
// first 32 bytes are the id // first 32 bytes are the id
u32 savever = *(u32*)(pbydata+16); u32 savever = *(u32*)(pbydata + 16);
if( strncmp((char*)pbydata, libraryNameX, 6) == 0 && (savever == ZEROGS_SAVEVER || savever == 0xaa000004) ) {
if (strncmp((char*)pbydata, libraryNameX, 6) == 0 && (savever == ZEROGS_SAVEVER || savever == 0xaa000004))
{
g_MemTargs.Destroy(); g_MemTargs.Destroy();
GSStateReset(); GSStateReset();
@ -99,25 +106,31 @@ bool ZeroGS::Load(s8* pbydata)
pbydata += 4; pbydata += 4;
u32 savelimit = VBSAVELIMIT; u32 savelimit = VBSAVELIMIT;
savelimit = *(u32*)pbydata; pbydata += 4; savelimit = *(u32*)pbydata;
pbydata += 4;
memcpy(g_pbyGSMemory, pbydata, 0x00400000); memcpy(g_pbyGSMemory, pbydata, 0x00400000);
pbydata += 0x00400000; pbydata += 0x00400000;
memcpy(g_pbyGSClut, pbydata, 256*4); memcpy(g_pbyGSClut, pbydata, 256*4);
pbydata += 256*4; pbydata += 256 * 4;
memset(&gs, 0, sizeof(gs)); memset(&gs, 0, sizeof(gs));
int savedgssize; int savedgssize;
if( savever == 0xaa000004 )
if (savever == 0xaa000004)
{
savedgssize = 0x1d0; savedgssize = 0x1d0;
else { }
else
{
savedgssize = *(int*)pbydata; savedgssize = *(int*)pbydata;
pbydata += 4; pbydata += 4;
} }
memcpy(&gs, pbydata, savedgssize); memcpy(&gs, pbydata, savedgssize);
pbydata += savedgssize; pbydata += savedgssize;
prim = &gs._prim[gs.prac]; prim = &gs._prim[gs.prac];
@ -131,17 +144,19 @@ bool ZeroGS::Load(s8* pbydata)
pbydata += savelimit; pbydata += savelimit;
vb[1].pBufferData = NULL; vb[1].pBufferData = NULL;
for(int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i)
{
vb[i].Init(VB_BUFFERSIZE); vb[i].Init(VB_BUFFERSIZE);
vb[i].bNeedZCheck = vb[i].bNeedFrameCheck = 1; vb[i].bNeedZCheck = vb[i].bNeedFrameCheck = 1;
vb[i].bSyncVars = 0; vb[i].bNeedTexCheck = 1; vb[i].bSyncVars = 0;
vb[i].bNeedTexCheck = 1;
memset(vb[i].uCurTex0Data, 0, sizeof(vb[i].uCurTex0Data)); memset(vb[i].uCurTex0Data, 0, sizeof(vb[i].uCurTex0Data));
} }
icurctx = -1; icurctx = -1;
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, s_uFramebuffer ); // switch to the backbuffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, s_uFramebuffer); // switch to the backbuffer
SetFogColor(gs.fogcol); SetFogColor(gs.fogcol);
GL_REPORT_ERRORD(); GL_REPORT_ERRORD();

330
plugins/zzogl-pg/opengl/ZZoglShaders.cpp
View File

@ -30,9 +30,11 @@ using namespace ZeroGS;
//------------------ Constants //------------------ Constants
// ----------------- Global Variables // ----------------- Global Variables
namespace ZeroGS {
FRAGMENTSHADER ppsBitBlt[2], ppsBitBltDepth, ppsOne; namespace ZeroGS
FRAGMENTSHADER ppsBaseTexture, ppsConvert16to32, ppsConvert32to16; {
FRAGMENTSHADER ppsBitBlt[2], ppsBitBltDepth, ppsOne;
FRAGMENTSHADER ppsBaseTexture, ppsConvert16to32, ppsConvert32to16;
} }
// Debug variable, store name of the function that call the shader. // Debug variable, store name of the function that call the shader.
@ -46,8 +48,8 @@ void HandleCgError(CGcontext ctx, CGerror err, void* appdata)
{ {
ZZLog::Error_Log("%s->%s: %s", ShaderCallerName, ShaderHandleName, cgGetErrorString(err)); ZZLog::Error_Log("%s->%s: %s", ShaderCallerName, ShaderHandleName, cgGetErrorString(err));
const char* listing = cgGetLastListing(g_cgcontext); const char* listing = cgGetLastListing(g_cgcontext);
if (listing != NULL)
ZZLog::Debug_Log(" Last listing: %s", listing); if (listing != NULL) ZZLog::Debug_Log(" Last listing: %s", listing);
} }
// This is a helper of cgGLSetParameter4fv, made for debugging purposes. // This is a helper of cgGLSetParameter4fv, made for debugging purposes.
@ -82,14 +84,24 @@ void SetupFragmentProgramParameters(FRAGMENTSHADER* pf, int context, int type)
pf->set_texture(ptexBlocks, "g_sBlocks"); pf->set_texture(ptexBlocks, "g_sBlocks");
// cg parameter usage is wrong, so do it manually // cg parameter usage is wrong, so do it manually
switch(type)
switch (type)
{ {
case 3: pf->set_texture(ptexConv16to32, "g_sConv16to32"); break; case 3:
case 4: pf->set_texture(ptexConv32to16, "g_sConv32to16"); break; pf->set_texture(ptexConv16to32, "g_sConv16to32");
default: pf->set_texture(ptexBilinearBlocks, "g_sBilinearBlocks"); break; break;
case 4:
pf->set_texture(ptexConv32to16, "g_sConv32to16");
break;
default:
pf->set_texture(ptexBilinearBlocks, "g_sBilinearBlocks");
break;
} }
pf->set_texture(pf->sMemory, "g_sMemory"); pf->set_texture(pf->sMemory, "g_sMemory");
pf->set_texture(pf->sFinal, "g_sSrcFinal"); pf->set_texture(pf->sFinal, "g_sSrcFinal");
pf->set_texture(pf->sBitwiseANDX, "g_sBitwiseANDX"); pf->set_texture(pf->sBitwiseANDX, "g_sBitwiseANDX");
pf->set_texture(pf->sBitwiseANDY, "g_sBitwiseANDY"); pf->set_texture(pf->sBitwiseANDY, "g_sBitwiseANDY");
@ -97,11 +109,11 @@ void SetupFragmentProgramParameters(FRAGMENTSHADER* pf, int context, int type)
pf->set_texture(pf->sInterlace, "g_sInterlace"); pf->set_texture(pf->sInterlace, "g_sInterlace");
// set global shader constants // set global shader constants
pf->set_shader_const(Vector(0.5f, (g_GameSettings&GAME_EXACTCOLOR)?0.9f/256.0f:0.5f/256.0f, 0,1/255.0f), "g_fExactColor"); pf->set_shader_const(Vector(0.5f, (g_GameSettings&GAME_EXACTCOLOR) ? 0.9f / 256.0f : 0.5f / 256.0f, 0, 1 / 255.0f), "g_fExactColor");
pf->set_shader_const(Vector(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f ), "g_fBilinear"); pf->set_shader_const(Vector(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f), "g_fBilinear");
pf->set_shader_const(Vector(1.0f/256.0f, 1.0004f, 1, 0.5f), "g_fZBias"); pf->set_shader_const(Vector(1.0f / 256.0f, 1.0004f, 1, 0.5f), "g_fZBias");
pf->set_shader_const(Vector(0,1, 0.001f, 0.5f), "g_fc0"); pf->set_shader_const(Vector(0, 1, 0.001f, 0.5f), "g_fc0");
pf->set_shader_const(Vector(1/1024.0f, 0.2f/1024.0f, 1/128.0f, 1/512.0f), "g_fMult"); pf->set_shader_const(Vector(1 / 1024.0f, 0.2f / 1024.0f, 1 / 128.0f, 1 / 512.0f), "g_fMult");
} }
void SetupVertexProgramParameters(CGprogram prog, int context) void SetupVertexProgramParameters(CGprogram prog, int context)
@ -109,50 +121,62 @@ void SetupVertexProgramParameters(CGprogram prog, int context)
CGparameter p; CGparameter p;
p = cgGetNamedParameter(prog, "g_fPosXY"); p = cgGetNamedParameter(prog, "g_fPosXY");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
cgConnectParameter(g_vparamPosXY[context], p); cgConnectParameter(g_vparamPosXY[context], p);
// Set Z-test, log or no log; // Set Z-test, log or no log;
if (g_GameSettings&GAME_NOLOGZ) if (g_GameSettings&GAME_NOLOGZ)
{ {
g_vdepth = Vector( 255.0 /256.0f, 255.0/65536.0f, 255.0f/(65535.0f*256.0f), 1.0f/(65536.0f*65536.0f)); g_vdepth = Vector(255.0 / 256.0f, 255.0 / 65536.0f, 255.0f / (65535.0f * 256.0f), 1.0f / (65536.0f * 65536.0f));
vlogz = Vector( 1.0f, 0.0f, 0.0f, 0.0f); vlogz = Vector(1.0f, 0.0f, 0.0f, 0.0f);
} }
else else
{ {
g_vdepth = Vector( 256.0f*65536.0f, 65536.0f, 256.0f, 65536.0f*65536.0f); g_vdepth = Vector(256.0f * 65536.0f, 65536.0f, 256.0f, 65536.0f * 65536.0f);
vlogz = Vector( 0.0f, 1.0f, 0.0f, 0.0f); vlogz = Vector(0.0f, 1.0f, 0.0f, 0.0f);
} }
p = cgGetNamedParameter(prog, "g_fZ"); p = cgGetNamedParameter(prog, "g_fZ");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE ) {
if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
{
cgGLSetParameter4fv(p, g_vdepth); cgGLSetParameter4fv(p, g_vdepth);
p = cgGetNamedParameter(prog, "g_fZMin"); // Switch to flat-z when needed p = cgGetNamedParameter(prog, "g_fZMin"); // Switch to flat-z when needed
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE ) {
if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
{
//ZZLog::Error_Log("Use flat-z"); //ZZLog::Error_Log("Use flat-z");
cgGLSetParameter4fv(p, vlogz); cgGLSetParameter4fv(p, vlogz);
} }
else else
{
ZZLog::Error_Log("Shader file version is outdated! Only log-Z is possible."); ZZLog::Error_Log("Shader file version is outdated! Only log-Z is possible.");
}
} }
Vector vnorm = Vector(g_filog32, 0, 0,0); Vector vnorm = Vector(g_filog32, 0, 0, 0);
p = cgGetNamedParameter(prog, "g_fZNorm"); p = cgGetNamedParameter(prog, "g_fZNorm");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
cgGLSetParameter4fv(p, vnorm); cgGLSetParameter4fv(p, vnorm);
p = cgGetNamedParameter(prog, "g_fBilinear"); p = cgGetNamedParameter(prog, "g_fBilinear");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, Vector(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f )); if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
cgGLSetParameter4fv(p, Vector(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f));
p = cgGetNamedParameter(prog, "g_fZBias"); p = cgGetNamedParameter(prog, "g_fZBias");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, Vector(1.0f/256.0f, 1.0004f, 1, 0.5f)); if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
cgGLSetParameter4fv(p, Vector(1.0f / 256.0f, 1.0004f, 1, 0.5f));
p = cgGetNamedParameter(prog, "g_fc0"); p = cgGetNamedParameter(prog, "g_fc0");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, Vector(0,1, 0.001f, 0.5f)); if (p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE)
cgGLSetParameter4fv(p, Vector(0, 1, 0.001f, 0.5f));
} }
#ifndef DEVBUILD #ifndef DEVBUILD
@ -170,7 +194,7 @@ void SetupVertexProgramParameters(CGprogram prog, int context)
if( cgGetError() != CG_NO_ERROR ) ZZLog::Error_Log("failed to load program %d.", Index); \ if( cgGetError() != CG_NO_ERROR ) ZZLog::Error_Log("failed to load program %d.", Index); \
SetupVertexProgramParameters(prog, !!(Index&SH_CONTEXT1)); \ SetupVertexProgramParameters(prog, !!(Index&SH_CONTEXT1)); \
} \ } \
#define LOAD_PS(Index, fragment) { \ #define LOAD_PS(Index, fragment) { \
bLoadSuccess = true; \ bLoadSuccess = true; \
assert( mapShaderResources.find(Index) != mapShaderResources.end() ); \ assert( mapShaderResources.find(Index) != mapShaderResources.end() ); \
@ -187,37 +211,42 @@ void SetupVertexProgramParameters(CGprogram prog, int context)
} \ } \
SetupFragmentProgramParameters(&fragment, !!(Index&SH_CONTEXT1), 0); \ SetupFragmentProgramParameters(&fragment, !!(Index&SH_CONTEXT1), 0); \
} \ } \
bool ZeroGS::LoadEffects() bool ZeroGS::LoadEffects()
{ {
assert( s_lpShaderResources != NULL ); assert(s_lpShaderResources != NULL);
// process the header // process the header
u32 num = *(u32*)s_lpShaderResources; u32 num = *(u32*)s_lpShaderResources;
int compressed_size = *(int*)(s_lpShaderResources+4); int compressed_size = *(int*)(s_lpShaderResources + 4);
int real_size = *(int*)(s_lpShaderResources+8); int real_size = *(int*)(s_lpShaderResources + 8);
int out; int out;
char* pbuffer = (char*)malloc(real_size); char* pbuffer = (char*)malloc(real_size);
inf((char*)s_lpShaderResources+12, &pbuffer[0], compressed_size, real_size, &out); inf((char*)s_lpShaderResources + 12, &pbuffer[0], compressed_size, real_size, &out);
assert(out == real_size); assert(out == real_size);
s_lpShaderResources = (u8*)pbuffer; s_lpShaderResources = (u8*)pbuffer;
SHADERHEADER* header = (SHADERHEADER*)s_lpShaderResources; SHADERHEADER* header = (SHADERHEADER*)s_lpShaderResources;
mapShaderResources.clear(); mapShaderResources.clear();
while(num-- > 0 ) {
while (num-- > 0)
{
mapShaderResources[header->index] = header; mapShaderResources[header->index] = header;
++header; ++header;
} }
// clear the textures // clear the textures
for(int i = 0; i < ARRAY_SIZE(ppsTexture); ++i) { for (int i = 0; i < ARRAY_SIZE(ppsTexture); ++i)
{
SAFE_RELEASE_PROG(ppsTexture[i].prog); SAFE_RELEASE_PROG(ppsTexture[i].prog);
ppsTexture[i].prog = NULL; ppsTexture[i].prog = NULL;
} }
#ifndef _DEBUG #ifndef _DEBUG
memset(ppsTexture, 0, sizeof(ppsTexture)); memset(ppsTexture, 0, sizeof(ppsTexture));
#endif #endif
return true; return true;
@ -231,12 +260,13 @@ bool ZeroGS::LoadExtraEffects()
const int vsshaders[4] = { SH_REGULARVS, SH_TEXTUREVS, SH_REGULARFOGVS, SH_TEXTUREFOGVS }; const int vsshaders[4] = { SH_REGULARVS, SH_TEXTUREVS, SH_REGULARFOGVS, SH_TEXTUREFOGVS };
for(int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i)
{
LOAD_VS(vsshaders[i], pvs[2*i]); LOAD_VS(vsshaders[i], pvs[2*i]);
LOAD_VS((vsshaders[i] | SH_CONTEXT1), pvs[2*i+1]); LOAD_VS((vsshaders[i] | SH_CONTEXT1), pvs[2*i+1]);
//if( conf.mrtdepth ) { //if( conf.mrtdepth ) {
LOAD_VS((vsshaders[i] | SH_WRITEDEPTH), pvs[2*i+8]); LOAD_VS((vsshaders[i] | SH_WRITEDEPTH), pvs[2*i+8]);
LOAD_VS((vsshaders[i] | SH_WRITEDEPTH | SH_CONTEXT1), pvs[2*i+8+1]); LOAD_VS((vsshaders[i] | SH_WRITEDEPTH | SH_CONTEXT1), pvs[2*i+8+1]);
// } // }
// else { // else {
// pvs[2*i+8] = pvs[2*i+8+1] = NULL; // pvs[2*i+8] = pvs[2*i+8+1] = NULL;
@ -244,6 +274,7 @@ bool ZeroGS::LoadExtraEffects()
} }
LOAD_VS(SH_BITBLTVS, pvsBitBlt.prog); LOAD_VS(SH_BITBLTVS, pvsBitBlt.prog);
pvsBitBlt.sBitBltPos = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltPos"); pvsBitBlt.sBitBltPos = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltPos");
pvsBitBlt.sBitBltTex = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltTex"); pvsBitBlt.sBitBltTex = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltTex");
pvsBitBlt.fBitBltTrans = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltTrans"); pvsBitBlt.fBitBltTrans = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltTrans");
@ -251,38 +282,50 @@ bool ZeroGS::LoadExtraEffects()
LOAD_PS(SH_REGULARPS, ppsRegular[0]); LOAD_PS(SH_REGULARPS, ppsRegular[0]);
LOAD_PS(SH_REGULARFOGPS, ppsRegular[1]); LOAD_PS(SH_REGULARFOGPS, ppsRegular[1]);
if( conf.mrtdepth ) { if (conf.mrtdepth)
{
LOAD_PS(SH_REGULARPS, ppsRegular[2]); LOAD_PS(SH_REGULARPS, ppsRegular[2]);
if( !bLoadSuccess )
if (!bLoadSuccess)
conf.mrtdepth = 0; conf.mrtdepth = 0;
LOAD_PS(SH_REGULARFOGPS, ppsRegular[3]); LOAD_PS(SH_REGULARFOGPS, ppsRegular[3]);
if( !bLoadSuccess )
if (!bLoadSuccess)
conf.mrtdepth = 0; conf.mrtdepth = 0;
} }
LOAD_PS(SH_BITBLTPS, ppsBitBlt[0]); LOAD_PS(SH_BITBLTPS, ppsBitBlt[0]);
LOAD_PS(SH_BITBLTAAPS, ppsBitBlt[1]); LOAD_PS(SH_BITBLTAAPS, ppsBitBlt[1]);
if( !bLoadSuccess ) {
if (!bLoadSuccess)
{
ZZLog::Error_Log("Failed to load BitBltAAPS, using BitBltPS."); ZZLog::Error_Log("Failed to load BitBltAAPS, using BitBltPS.");
LOAD_PS(SH_BITBLTPS, ppsBitBlt[1]); LOAD_PS(SH_BITBLTPS, ppsBitBlt[1]);
} }
LOAD_PS(SH_BITBLTDEPTHPS, ppsBitBltDepth); LOAD_PS(SH_BITBLTDEPTHPS, ppsBitBltDepth);
LOAD_PS(SH_CRTCTARGPS, ppsCRTCTarg[0]); LOAD_PS(SH_CRTCTARGPS, ppsCRTCTarg[0]);
LOAD_PS(SH_CRTCTARGINTERPS, ppsCRTCTarg[1]); LOAD_PS(SH_CRTCTARGINTERPS, ppsCRTCTarg[1]);
g_bCRTCBilinear = TRUE; g_bCRTCBilinear = TRUE;
LOAD_PS(SH_CRTCPS, ppsCRTC[0]); LOAD_PS(SH_CRTCPS, ppsCRTC[0]);
if( !bLoadSuccess ) {
if (!bLoadSuccess)
{
// switch to simpler // switch to simpler
g_bCRTCBilinear = FALSE; g_bCRTCBilinear = FALSE;
LOAD_PS(SH_CRTC_NEARESTPS, ppsCRTC[0]); LOAD_PS(SH_CRTC_NEARESTPS, ppsCRTC[0]);
LOAD_PS(SH_CRTCINTER_NEARESTPS, ppsCRTC[0]); LOAD_PS(SH_CRTCINTER_NEARESTPS, ppsCRTC[0]);
} }
else { else
{
LOAD_PS(SH_CRTCINTERPS, ppsCRTC[1]); LOAD_PS(SH_CRTCINTERPS, ppsCRTC[1]);
} }
if( !bLoadSuccess ) if (!bLoadSuccess)
ZZLog::Error_Log("Failed to create CRTC shaders."); ZZLog::Error_Log("Failed to create CRTC shaders.");
LOAD_PS(SH_CRTC24PS, ppsCRTC24[0]); LOAD_PS(SH_CRTC24PS, ppsCRTC24[0]);
@ -298,62 +341,85 @@ bool ZeroGS::LoadExtraEffects()
FRAGMENTSHADER* ZeroGS::LoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed) FRAGMENTSHADER* ZeroGS::LoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed)
{ {
int texwrap; int texwrap;
assert( texfilter < NUM_FILTERS ); assert(texfilter < NUM_FILTERS);
if(g_nPixelShaderVer&SHADER_REDUCED) if (g_nPixelShaderVer & SHADER_REDUCED) texfilter = 0;
texfilter = 0;
assert(!(g_nPixelShaderVer&SHADER_REDUCED) || !exactcolor);
if( clamp.wms == clamp.wmt ) { assert(!(g_nPixelShaderVer & SHADER_REDUCED) || !exactcolor);
switch( clamp.wms ) {
case 0: texwrap = TEXWRAP_REPEAT; break; if (clamp.wms == clamp.wmt)
case 1: texwrap = TEXWRAP_CLAMP; break; {
case 2: texwrap = TEXWRAP_CLAMP; break; switch (clamp.wms)
default: texwrap = TEXWRAP_REGION_REPEAT; break; {
case 0:
texwrap = TEXWRAP_REPEAT;
break;
case 1:
texwrap = TEXWRAP_CLAMP;
break;
case 2:
texwrap = TEXWRAP_CLAMP;
break;
default:
texwrap = TEXWRAP_REGION_REPEAT;
break;
} }
} }
else if( clamp.wms==3||clamp.wmt==3) else if (clamp.wms == 3 || clamp.wmt == 3)
texwrap = TEXWRAP_REGION_REPEAT; texwrap = TEXWRAP_REGION_REPEAT;
else else
texwrap = TEXWRAP_REPEAT_CLAMP; texwrap = TEXWRAP_REPEAT_CLAMP;
int index = GET_SHADER_INDEX(type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, context, 0); int index = GET_SHADER_INDEX(type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, context, 0);
assert( index < ARRAY_SIZE(ppsTexture) ); assert(index < ARRAY_SIZE(ppsTexture));
FRAGMENTSHADER* pf = ppsTexture+index;
if( pbFailed != NULL ) *pbFailed = false; FRAGMENTSHADER* pf = ppsTexture + index;
if( pf->prog != NULL ) if (pbFailed != NULL) *pbFailed = false;
return pf;
if( (g_nPixelShaderVer & SHADER_ACCURATE) && mapShaderResources.find(index+NUM_SHADERS*SHADER_ACCURATE) != mapShaderResources.end() ) if (pf->prog != NULL) return pf;
index += NUM_SHADERS*SHADER_ACCURATE;
if ((g_nPixelShaderVer & SHADER_ACCURATE) && mapShaderResources.find(index + NUM_SHADERS*SHADER_ACCURATE) != mapShaderResources.end())
index += NUM_SHADERS * SHADER_ACCURATE;
assert(mapShaderResources.find(index) != mapShaderResources.end());
assert( mapShaderResources.find(index) != mapShaderResources.end() );
SHADERHEADER* header = mapShaderResources[index]; SHADERHEADER* header = mapShaderResources[index];
if( header == NULL )
ZZLog::Error_Log("%d %d", index, g_nPixelShaderVer); if (header == NULL) ZZLog::Error_Log("%d %d", index, g_nPixelShaderVer);
assert( header != NULL );
assert(header != NULL);
//ZZLog::Debug_Log("Shader:\n%s.", (char*)(s_lpShaderResources + (header)->offset)); //ZZLog::Debug_Log("Shader:\n%s.", (char*)(s_lpShaderResources + (header)->offset));
pf->prog = cgCreateProgram(g_cgcontext, CG_OBJECT, (char*)(s_lpShaderResources + (header)->offset), cgfProf, NULL, NULL); pf->prog = cgCreateProgram(g_cgcontext, CG_OBJECT, (char*)(s_lpShaderResources + (header)->offset), cgfProf, NULL, NULL);
if( pf->prog != NULL && cgIsProgram(pf->prog) && cgGetError() == CG_NO_ERROR ) {
if (pf->prog != NULL && cgIsProgram(pf->prog) && cgGetError() == CG_NO_ERROR)
{
SetupFragmentProgramParameters(pf, context, type); SetupFragmentProgramParameters(pf, context, type);
cgGLLoadProgram(pf->prog); cgGLLoadProgram(pf->prog);
if( cgGetError() != CG_NO_ERROR ) {
if (cgGetError() != CG_NO_ERROR)
{
// cgGLLoadProgram(pf->prog); // cgGLLoadProgram(pf->prog);
// if( cgGetError() != CG_NO_ERROR ) { // if( cgGetError() != CG_NO_ERROR ) {
ZZLog::Error_Log("Failed to load shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms+clamp.wmt); ZZLog::Error_Log("Failed to load shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms + clamp.wmt);
if( pbFailed != NULL ) *pbFailed = true;
return pf; if (pbFailed != NULL) *pbFailed = true;
return pf;
// } // }
} }
return pf; return pf;
} }
ZZLog::Error_Log("Failed to create shader %d,%d,%d,%d", type, fog, texfilter, 4*clamp.wms+clamp.wmt); ZZLog::Error_Log("Failed to create shader %d,%d,%d,%d", type, fog, texfilter, 4*clamp.wms + clamp.wmt);
if( pbFailed != NULL ) *pbFailed = true;
if (pbFailed != NULL) *pbFailed = true;
return NULL; return NULL;
} }
@ -370,7 +436,7 @@ FRAGMENTSHADER* ZeroGS::LoadShadeEffect(int type, int texfilter, int fog, int te
if( cgGetError() != CG_NO_ERROR ) ZZLog::Error_Log("failed to load program %s.", name); \ if( cgGetError() != CG_NO_ERROR ) ZZLog::Error_Log("failed to load program %s.", name); \
SetupVertexProgramParameters(prog, args[0]==context1); \ SetupVertexProgramParameters(prog, args[0]==context1); \
} \ } \
#ifdef _DEBUG #ifdef _DEBUG
#define SET_PSFILENAME(frag, name) frag.filename = name #define SET_PSFILENAME(frag, name) frag.filename = name
#else #else
@ -392,16 +458,18 @@ FRAGMENTSHADER* ZeroGS::LoadShadeEffect(int type, int texfilter, int fog, int te
SetupFragmentProgramParameters(&fragment, args[0]==context1, 0); \ SetupFragmentProgramParameters(&fragment, args[0]==context1, 0); \
SET_PSFILENAME(fragment, name); \ SET_PSFILENAME(fragment, name); \
} \ } \
bool ZeroGS::LoadEffects() bool ZeroGS::LoadEffects()
{ {
// clear the textures // clear the textures
for(int i = 0; i < ARRAY_SIZE(ppsTexture); ++i) { for (int i = 0; i < ARRAY_SIZE(ppsTexture); ++i)
{
SAFE_RELEASE_PROG(ppsTexture[i].prog); SAFE_RELEASE_PROG(ppsTexture[i].prog);
} }
#ifndef _DEBUG #ifndef _DEBUG
memset(ppsTexture, 0, sizeof(ppsTexture)); memset(ppsTexture, 0, sizeof(ppsTexture));
#endif #endif
return true; return true;
@ -418,7 +486,8 @@ bool ZeroGS::LoadExtraEffects()
const char* pvsshaders[4] = { "RegularVS", "TextureVS", "RegularFogVS", "TextureFogVS" }; const char* pvsshaders[4] = { "RegularVS", "TextureVS", "RegularFogVS", "TextureFogVS" };
for(int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i)
{
args[0] = context0; args[0] = context0;
args[1] = NULL; args[1] = NULL;
LOAD_VS(pvsshaders[i], pvs[2*i], cgvProf); LOAD_VS(pvsshaders[i], pvs[2*i], cgvProf);
@ -426,11 +495,11 @@ bool ZeroGS::LoadExtraEffects()
LOAD_VS(pvsshaders[i], pvs[2*i+1], cgvProf); LOAD_VS(pvsshaders[i], pvs[2*i+1], cgvProf);
//if( conf.mrtdepth ) { //if( conf.mrtdepth ) {
args[0] = context0; args[0] = context0;
args[1] = write_depth; args[1] = write_depth;
LOAD_VS(pvsshaders[i], pvs[2*i+8], cgvProf); LOAD_VS(pvsshaders[i], pvs[2*i+8], cgvProf);
args[0] = context1; args[0] = context1;
LOAD_VS(pvsshaders[i], pvs[2*i+8+1], cgvProf); LOAD_VS(pvsshaders[i], pvs[2*i+8+1], cgvProf);
// } // }
// else { // else {
// pvs[2*i+8] = pvs[2*i+8+1] = NULL; // pvs[2*i+8] = pvs[2*i+8+1] = NULL;
@ -438,6 +507,7 @@ bool ZeroGS::LoadExtraEffects()
} }
args[0] = context0; args[0] = context0;
args[1] = NULL; args[1] = NULL;
LOAD_VS("BitBltVS", pvsBitBlt.prog, cgvProf); LOAD_VS("BitBltVS", pvsBitBlt.prog, cgvProf);
pvsBitBlt.sBitBltPos = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltPos"); pvsBitBlt.sBitBltPos = cgGetNamedParameter(pvsBitBlt.prog, "g_fBitBltPos");
@ -447,20 +517,24 @@ bool ZeroGS::LoadExtraEffects()
LOAD_PS("RegularPS", ppsRegular[0], cgfProf); LOAD_PS("RegularPS", ppsRegular[0], cgfProf);
LOAD_PS("RegularFogPS", ppsRegular[1], cgfProf); LOAD_PS("RegularFogPS", ppsRegular[1], cgfProf);
if( conf.mrtdepth ) { if (conf.mrtdepth)
{
args[0] = context0; args[0] = context0;
args[1] = write_depth; args[1] = write_depth;
LOAD_PS("RegularPS", ppsRegular[2], cgfProf); LOAD_PS("RegularPS", ppsRegular[2], cgfProf);
if( !bLoadSuccess )
conf.mrtdepth = 0; if (!bLoadSuccess) conf.mrtdepth = 0;
LOAD_PS("RegularFogPS", ppsRegular[3], cgfProf); LOAD_PS("RegularFogPS", ppsRegular[3], cgfProf);
if( !bLoadSuccess )
conf.mrtdepth = 0; if (!bLoadSuccess) conf.mrtdepth = 0;
} }
LOAD_PS("BitBltPS", ppsBitBlt[0], cgfProf); LOAD_PS("BitBltPS", ppsBitBlt[0], cgfProf);
LOAD_PS("BitBltAAPS", ppsBitBlt[1], cgfProf); LOAD_PS("BitBltAAPS", ppsBitBlt[1], cgfProf);
if( !bLoadSuccess ) {
if (!bLoadSuccess)
{
ZZLog::Error_Log("Failed to load BitBltAAPS, using BitBltPS."); ZZLog::Error_Log("Failed to load BitBltAAPS, using BitBltPS.");
LOAD_PS("BitBltPS", ppsBitBlt[1], cgfProf); LOAD_PS("BitBltPS", ppsBitBlt[1], cgfProf);
} }
@ -471,19 +545,23 @@ bool ZeroGS::LoadExtraEffects()
g_bCRTCBilinear = TRUE; g_bCRTCBilinear = TRUE;
LOAD_PS("CRTCPS", ppsCRTC[0], cgfProf); LOAD_PS("CRTCPS", ppsCRTC[0], cgfProf);
if( !bLoadSuccess ) {
if (!bLoadSuccess)
{
// switch to simpler // switch to simpler
g_bCRTCBilinear = FALSE; g_bCRTCBilinear = FALSE;
LOAD_PS("CRTCPS_Nearest", ppsCRTC[0], cgfProf); LOAD_PS("CRTCPS_Nearest", ppsCRTC[0], cgfProf);
LOAD_PS("CRTCInterPS_Nearest", ppsCRTC[0], cgfProf); LOAD_PS("CRTCInterPS_Nearest", ppsCRTC[0], cgfProf);
} }
else { else
{
LOAD_PS("CRTCInterPS", ppsCRTC[1], cgfProf); LOAD_PS("CRTCInterPS", ppsCRTC[1], cgfProf);
} }
if (!bLoadSuccess) ZZLog::Error_Log("Failed to create CRTC shaders."); if (!bLoadSuccess) ZZLog::Error_Log("Failed to create CRTC shaders.");
LOAD_PS("CRTC24PS", ppsCRTC24[0], cgfProf); LOAD_PS("CRTC24InterPS", ppsCRTC24[1], cgfProf); LOAD_PS("CRTC24PS", ppsCRTC24[0], cgfProf);
LOAD_PS("CRTC24InterPS", ppsCRTC24[1], cgfProf);
LOAD_PS("ZeroPS", ppsOne, cgfProf); LOAD_PS("ZeroPS", ppsOne, cgfProf);
LOAD_PS("BaseTexturePS", ppsBaseTexture, cgfProf); LOAD_PS("BaseTexturePS", ppsBaseTexture, cgfProf);
LOAD_PS("Convert16to32PS", ppsConvert16to32, cgfProf); LOAD_PS("Convert16to32PS", ppsConvert16to32, cgfProf);
@ -501,57 +579,77 @@ FRAGMENTSHADER* ZeroGS::LoadShadeEffect(int type, int texfilter, int fog, int te
{ {
int texwrap; int texwrap;
assert( texfilter < NUM_FILTERS ); assert(texfilter < NUM_FILTERS);
//assert( g_nPixelShaderVer == SHADER_30 ); //assert( g_nPixelShaderVer == SHADER_30 );
if( clamp.wms == clamp.wmt ) {
switch( clamp.wms ) { if (clamp.wms == clamp.wmt)
case 0: texwrap = TEXWRAP_REPEAT; break; {
case 1: texwrap = TEXWRAP_CLAMP; break; switch (clamp.wms)
case 2: texwrap = TEXWRAP_CLAMP; break; {
case 0:
texwrap = TEXWRAP_REPEAT;
break;
case 1:
texwrap = TEXWRAP_CLAMP;
break;
case 2:
texwrap = TEXWRAP_CLAMP;
break;
default: default:
texwrap = TEXWRAP_REGION_REPEAT; break; texwrap = TEXWRAP_REGION_REPEAT;
break;
} }
} }
else if( clamp.wms==3||clamp.wmt==3) else if (clamp.wms == 3 || clamp.wmt == 3)
texwrap = TEXWRAP_REGION_REPEAT; texwrap = TEXWRAP_REGION_REPEAT;
else else
texwrap = TEXWRAP_REPEAT_CLAMP; texwrap = TEXWRAP_REPEAT_CLAMP;
int index = GET_SHADER_INDEX(type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, context, 0); int index = GET_SHADER_INDEX(type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, context, 0);
if( pbFailed != NULL ) *pbFailed = false; if (pbFailed != NULL) *pbFailed = false;
FRAGMENTSHADER* pf = ppsTexture+index; FRAGMENTSHADER* pf = ppsTexture + index;
if( pf->prog != NULL ) if (pf->prog != NULL) return pf;
return pf;
pf->prog = LoadShaderFromType(EFFECT_DIR, EFFECT_NAME, type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, g_nPixelShaderVer, context); pf->prog = LoadShaderFromType(EFFECT_DIR, EFFECT_NAME, type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, g_nPixelShaderVer, context);
if( pf->prog != NULL ) { if (pf->prog != NULL)
{
#ifdef _DEBUG #ifdef _DEBUG
char str[255]; char str[255];
sprintf(str, "Texture%s%d_%sPS", fog?"Fog":"", texfilter, g_pTexTypes[type]); sprintf(str, "Texture%s%d_%sPS", fog ? "Fog" : "", texfilter, g_pTexTypes[type]);
pf->filename = str; pf->filename = str;
#endif #endif
SetupFragmentProgramParameters(pf, context, type); SetupFragmentProgramParameters(pf, context, type);
cgGLLoadProgram(pf->prog); cgGLLoadProgram(pf->prog);
if( cgGetError() != CG_NO_ERROR ) {
if (cgGetError() != CG_NO_ERROR)
{
// try again // try again
// cgGLLoadProgram(pf->prog); // cgGLLoadProgram(pf->prog);
// if( cgGetError() != CG_NO_ERROR ) { // if( cgGetError() != CG_NO_ERROR ) {
ZZLog::Error_Log("Failed to load shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms+clamp.wmt); ZZLog::Error_Log("Failed to load shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms + clamp.wmt);
if( pbFailed != NULL ) *pbFailed = true;
//assert(0); if (pbFailed != NULL) *pbFailed = true;
// NULL makes things crash
return pf; //assert(0);
// NULL makes things crash
return pf;
// } // }
} }
return pf; return pf;
} }
ZZLog::Error_Log("Failed to create shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms+clamp.wmt); ZZLog::Error_Log("Failed to create shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms + clamp.wmt);
if( pbFailed != NULL ) *pbFailed = true;
if (pbFailed != NULL) *pbFailed = true;
return NULL; return NULL;
} }

259
plugins/zzogl-pg/opengl/ZZoglShoots.cpp
View File

@ -32,7 +32,8 @@
#include "Mem.h" #include "Mem.h"
extern "C" { extern "C"
{
#ifdef _WIN32 #ifdef _WIN32
# define XMD_H # define XMD_H
# undef FAR # undef FAR
@ -59,64 +60,65 @@ int s_aviinit = 0;
//------------------ Code //------------------ Code
// Set variables need to made a snapshoot when it's possible // Set variables need to made a snapshoot when it's possible
void void ZeroGS::SaveSnapshot(const char* filename)
ZeroGS::SaveSnapshot(const char* filename)
{ {
g_bMakeSnapshot = 1; g_bMakeSnapshot = 1;
strSnapshot = filename; strSnapshot = filename;
} }
// Save curent renderer in jpeg or TGA format // Save curent renderer in jpeg or TGA format
bool bool ZeroGS::SaveRenderTarget(const char* filename, int width, int height, int jpeg)
ZeroGS::SaveRenderTarget(const char* filename, int width, int height, int jpeg)
{ {
bool bflip = height < 0; bool bflip = height < 0;
height = abs(height); height = abs(height);
vector<u32> data(width*height); vector<u32> data(width*height);
glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]); glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
if (glGetError() != GL_NO_ERROR)
return false;
if (bflip) { if (glGetError() != GL_NO_ERROR) return false;
if (bflip)
{
// swap scanlines // swap scanlines
vector<u32> scanline(width); vector<u32> scanline(width);
for (int i = 0; i < height/2; ++i) {
for (int i = 0; i < height / 2; ++i)
{
memcpy(&scanline[0], &data[i * width], width * 4); memcpy(&scanline[0], &data[i * width], width * 4);
memcpy(&data[i * width], &data[(height - i - 1) * width], width * 4); memcpy(&data[i * width], &data[(height - i - 1) * width], width * 4);
memcpy(&data[(height - i - 1) * width], &scanline[0], width * 4); memcpy(&data[(height - i - 1) * width], &scanline[0], width * 4);
} }
} }
if (jpeg) if (jpeg) return SaveJPEG(filename, width, height, &data[0], 70);
return SaveJPEG(filename, width, height, &data[0], 70);
return SaveTGA(filename, width, height, &data[0]); return SaveTGA(filename, width, height, &data[0]);
} }
// Save selected texture as TGA // Save selected texture as TGA
bool bool ZeroGS::SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height)
ZeroGS::SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height)
{ {
vector<u32> data(width*height); vector<u32> data(width*height);
glBindTexture(textarget, tex); glBindTexture(textarget, tex);
glGetTexImage(textarget, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]); glGetTexImage(textarget, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
if (glGetError() != GL_NO_ERROR)
return false; if (glGetError() != GL_NO_ERROR) return false;
return SaveTGA(filename, width, height, &data[0]); return SaveTGA(filename, width, height, &data[0]);
} }
// save image as JPEG // save image as JPEG
bool bool ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const void* pdata, int quality)
ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const void* pdata, int quality)
{ {
u8* image_buffer = new u8[image_width * image_height * 3]; u8* image_buffer = new u8[image_width * image_height * 3];
u8* psrc = (u8*)pdata; u8* psrc = (u8*)pdata;
// input data is rgba format, so convert to rgb // input data is rgba format, so convert to rgb
u8* p = image_buffer; u8* p = image_buffer;
for(int i = 0; i < image_height; ++i) {
for(int j = 0; j < image_width; ++j) { for (int i = 0; i < image_height; ++i)
{
for (int j = 0; j < image_width; ++j)
{
p[0] = psrc[0]; p[0] = psrc[0];
p[1] = psrc[1]; p[1] = psrc[1];
p[2] = psrc[2]; p[2] = psrc[2];
@ -131,7 +133,9 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
* compression/decompression processes, in existence at once. We refer * compression/decompression processes, in existence at once. We refer
* to any one struct (and its associated working data) as a "JPEG object". * to any one struct (and its associated working data) as a "JPEG object".
*/ */
struct jpeg_compress_struct cinfo; struct jpeg_compress_struct cinfo;
/* This struct represents a JPEG error handler. It is declared separately /* This struct represents a JPEG error handler. It is declared separately
* because applications often want to supply a specialized error handler * because applications often want to supply a specialized error handler
* (see the second half of this file for an example). But here we just * (see the second half of this file for an example). But here we just
@ -140,10 +144,14 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
* Note that this struct must live as long as the main JPEG parameter * Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems. * struct, to avoid dangling-pointer problems.
*/ */
struct jpeg_error_mgr jerr; struct jpeg_error_mgr jerr;
/* More stuff */ /* More stuff */
FILE * outfile; /* target file */ FILE * outfile; /* target file */
JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
int row_stride; /* physical row width in image buffer */ int row_stride; /* physical row width in image buffer */
/* Step 1: allocate and initialize JPEG compression object */ /* Step 1: allocate and initialize JPEG compression object */
@ -154,6 +162,7 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
* address which we place into the link field in cinfo. * address which we place into the link field in cinfo.
*/ */
cinfo.err = jpeg_std_error(&jerr); cinfo.err = jpeg_std_error(&jerr);
/* Now we can initialize the JPEG compression object. */ /* Now we can initialize the JPEG compression object. */
jpeg_create_compress(&cinfo); jpeg_create_compress(&cinfo);
@ -165,10 +174,12 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to write binary files. * requires it in order to write binary files.
*/ */
if ((outfile = fopen(filename, "wb")) == NULL) { if ((outfile = fopen(filename, "wb")) == NULL)
{
fprintf(stderr, "can't open %s\n", filename); fprintf(stderr, "can't open %s\n", filename);
exit(1); exit(1);
} }
jpeg_stdio_dest(&cinfo, outfile); jpeg_stdio_dest(&cinfo, outfile);
/* Step 3: set parameters for compression */ /* Step 3: set parameters for compression */
@ -207,8 +218,9 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
*/ */
row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */ row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */
while (cinfo.next_scanline < cinfo.image_height) { while (cinfo.next_scanline < cinfo.image_height)
/* jpeg_write_scanlines expects an array of pointers to scanlines. {
/* jpeg_write_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could pass * Here the array is only one element long, but you could pass
* more than one scanline at a time if that's more convenient. * more than one scanline at a time if that's more convenient.
*/ */
@ -219,6 +231,7 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
/* Step 6: Finish compression */ /* Step 6: Finish compression */
jpeg_finish_compress(&cinfo); jpeg_finish_compress(&cinfo);
/* After finish_compress, we can close the output file. */ /* After finish_compress, we can close the output file. */
fclose(outfile); fclose(outfile);
@ -228,6 +241,7 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
jpeg_destroy_compress(&cinfo); jpeg_destroy_compress(&cinfo);
delete image_buffer; delete image_buffer;
/* And we're done! */ /* And we're done! */
return true; return true;
} }
@ -237,6 +251,7 @@ ZeroGS::SaveJPEG(const char* filename, int image_width, int image_height, const
#endif #endif
// This is the defenition of TGA header. We need it to function bellow // This is the defenition of TGA header. We need it to function bellow
struct TGA_HEADER struct TGA_HEADER
{ {
u8 identsize; // size of ID field that follows 18 u8 header (0 usually) u8 identsize; // size of ID field that follows 18 u8 header (0 usually)
@ -254,36 +269,41 @@ struct TGA_HEADER
u8 bits; // image bits per pixel 8,16,24,32 u8 bits; // image bits per pixel 8,16,24,32
u8 descriptor; // image descriptor bits (vh flip bits) u8 descriptor; // image descriptor bits (vh flip bits)
// pixel data follows header // pixel data follows header
#if defined(_MSC_VER) #if defined(_MSC_VER)
}; };
# pragma pack(pop) # pragma pack(pop)
# else # else
} __attribute__((packed)); }
__attribute__((packed));
#endif #endif
// Save image as TGA // Save image as TGA
bool bool ZeroGS::SaveTGA(const char* filename, int width, int height, void* pdata)
ZeroGS::SaveTGA(const char* filename, int width, int height, void* pdata)
{ {
int err = 0; int err = 0;
TGA_HEADER hdr; TGA_HEADER hdr;
FILE* f = fopen(filename, "wb"); FILE* f = fopen(filename, "wb");
if (f == NULL)
return false;
assert( sizeof(TGA_HEADER) == 18 && sizeof(hdr) == 18 ); if (f == NULL) return false;
assert(sizeof(TGA_HEADER) == 18 && sizeof(hdr) == 18);
memset(&hdr, 0, sizeof(hdr)); memset(&hdr, 0, sizeof(hdr));
hdr.imagetype = 2; hdr.imagetype = 2;
hdr.bits = 32; hdr.bits = 32;
hdr.width = width; hdr.width = width;
hdr.height = height; hdr.height = height;
hdr.descriptor |= 8|(1<<5); // 8bit alpha, flip vertical hdr.descriptor |= 8 | (1 << 5); // 8bit alpha, flip vertical
err = fwrite(&hdr, sizeof(hdr), 1, f); err = fwrite(&hdr, sizeof(hdr), 1, f);
err = fwrite(pdata, width * height * 4, 1, f); err = fwrite(pdata, width * height * 4, 1, f);
fclose(f); fclose(f);
return true; return true;
} }
@ -291,8 +311,8 @@ ZeroGS::SaveTGA(const char* filename, int width, int height, void* pdata)
// AVI start -- set needed glabal variables // AVI start -- set needed glabal variables
void ZeroGS::StartCapture() void ZeroGS::StartCapture()
{ {
if( !s_aviinit ) { if (!s_aviinit)
{
#ifdef _WIN32 #ifdef _WIN32
START_AVI("zerogs.avi"); START_AVI("zerogs.avi");
#else // linux #else // linux
@ -300,7 +320,8 @@ void ZeroGS::StartCapture()
#endif #endif
s_aviinit = 1; s_aviinit = 1;
} }
else { else
{
ZZLog::Error_Log("Continuing from previous capture."); ZZLog::Error_Log("Continuing from previous capture.");
} }
@ -317,10 +338,11 @@ void ZeroGS::StopCapture()
// Does not work on linux // Does not work on linux
void ZeroGS::CaptureFrame() void ZeroGS::CaptureFrame()
{ {
assert( s_avicapturing && s_aviinit ); assert(s_avicapturing && s_aviinit);
vector<u32> data(nBackbufferWidth*nBackbufferHeight); vector<u32> data(nBackbufferWidth*nBackbufferHeight);
glReadPixels(0, 0, nBackbufferWidth, nBackbufferHeight, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]); glReadPixels(0, 0, nBackbufferWidth, nBackbufferHeight, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
if (glGetError() != GL_NO_ERROR) return; if (glGetError() != GL_NO_ERROR) return;
#ifdef _WIN32 #ifdef _WIN32
@ -328,12 +350,14 @@ void ZeroGS::CaptureFrame()
bool bSuccess = ADD_FRAME_FROM_DIB_TO_AVI("AAAA", fps, nBackbufferWidth, nBackbufferHeight, 32, &data[0]); bool bSuccess = ADD_FRAME_FROM_DIB_TO_AVI("AAAA", fps, nBackbufferWidth, nBackbufferHeight, 32, &data[0]);
if( !bSuccess ) { if (!bSuccess)
{
s_avicapturing = 0; s_avicapturing = 0;
STOP_AVI(); STOP_AVI();
ZeroGS::AddMessage("Failed to create avi"); ZeroGS::AddMessage("Failed to create avi");
return; return;
} }
#else // linux #else // linux
//TODO //TODO
#endif // _WIN32 #endif // _WIN32
@ -351,10 +375,10 @@ ZeroGS::SaveTex(tex0Info* ptex, int usevid)
CMemoryTarget* pmemtarg = NULL; CMemoryTarget* pmemtarg = NULL;
if (usevid) { if (usevid)
{
pmemtarg = g_MemTargs.GetMemoryTarget(*ptex, 0); pmemtarg = g_MemTargs.GetMemoryTarget(*ptex, 0);
assert( pmemtarg != NULL ); assert(pmemtarg != NULL);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, pmemtarg->ptex->tex); glBindTexture(GL_TEXTURE_RECTANGLE_NV, pmemtarg->ptex->tex);
srcdata.resize(pmemtarg->realheight * GPU_TEXWIDTH * pmemtarg->widthmult * 4 * 8); // max of 8 cannels srcdata.resize(pmemtarg->realheight * GPU_TEXWIDTH * pmemtarg->widthmult * 4 * 8); // max of 8 cannels
@ -371,11 +395,15 @@ ZeroGS::SaveTex(tex0Info* ptex, int usevid)
psrc = &srcdata[0] - offset; psrc = &srcdata[0] - offset;
} }
for (int i = 0; i < ptex->th; ++i) { for (int i = 0; i < ptex->th; ++i)
for (int j = 0; j < ptex->tw; ++j) { {
for (int j = 0; j < ptex->tw; ++j)
{
u32 u = 0; u32 u = 0;
u32 addr; u32 addr;
switch (ptex->psm) {
switch (ptex->psm)
{
case PSMCT32: case PSMCT32:
addr = getPixelAddress32(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress32(j, i, ptex->tbp0, ptex->tbw);
if (addr * 4 < 0x00400000) if (addr * 4 < 0x00400000)
@ -383,6 +411,7 @@ ZeroGS::SaveTex(tex0Info* ptex, int usevid)
else else
u = 0; u = 0;
break; break;
case PSMCT24: case PSMCT24:
addr = getPixelAddress24(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress24(j, i, ptex->tbp0, ptex->tbw);
if (addr * 4 < 0x00400000) if (addr * 4 < 0x00400000)
@ -390,135 +419,174 @@ ZeroGS::SaveTex(tex0Info* ptex, int usevid)
else else
u = 0; u = 0;
break; break;
case PSMCT16: case PSMCT16:
addr = getPixelAddress16(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress16(j, i, ptex->tbp0, ptex->tbw);
if (addr * 2 < 0x00400000) { if (addr * 2 < 0x00400000)
{
u = readPixel16(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel16(psrc, j, i, ptex->tbp0, ptex->tbw);
u = RGBA16to32(u); u = RGBA16to32(u);
} }
else else
{
u = 0; u = 0;
}
break; break;
case PSMCT16S: case PSMCT16S:
addr = getPixelAddress16(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress16(j, i, ptex->tbp0, ptex->tbw);
if (addr * 2 < 0x00400000) { if (addr * 2 < 0x00400000)
{
u = readPixel16S(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel16S(psrc, j, i, ptex->tbp0, ptex->tbw);
u = RGBA16to32(u); u = RGBA16to32(u);
} }
else u = 0; else
{
u = 0;
}
break; break;
case PSMT8: case PSMT8:
addr = getPixelAddress8(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress8(j, i, ptex->tbp0, ptex->tbw);
if (addr < 0x00400000) { if (addr < 0x00400000)
if (usevid) { {
if (usevid)
{
if (PSMT_IS32BIT(ptex->cpsm)) if (PSMT_IS32BIT(ptex->cpsm))
u = *(u32*)(psrc+4*addr); u = *(u32*)(psrc + 4 * addr);
else else
u = RGBA16to32(*(u16*)(psrc+2*addr)); u = RGBA16to32(*(u16*)(psrc + 2 * addr));
} }
else else
{
u = readPixel8(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel8(psrc, j, i, ptex->tbp0, ptex->tbw);
}
} }
else else
{
u = 0; u = 0;
}
break; break;
case PSMT4: case PSMT4:
addr = getPixelAddress4(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress4(j, i, ptex->tbp0, ptex->tbw);
if (addr < 2*0x00400000)
if( addr < 2*0x00400000 ) { {
if( usevid ) { if (usevid)
{
if (PSMT_IS32BIT(ptex->cpsm)) if (PSMT_IS32BIT(ptex->cpsm))
u = *(u32*)(psrc+4*addr); u = *(u32*)(psrc + 4 * addr);
else else
u = RGBA16to32(*(u16*)(psrc+2*addr)); u = RGBA16to32(*(u16*)(psrc + 2 * addr));
} }
else else
{
u = readPixel4(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel4(psrc, j, i, ptex->tbp0, ptex->tbw);
}
} }
else u = 0; else
{
u = 0;
}
break; break;
case PSMT8H: case PSMT8H:
addr = getPixelAddress8H(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress8H(j, i, ptex->tbp0, ptex->tbw);
if (4*addr < 0x00400000)
if( 4*addr < 0x00400000 ) { {
if( usevid ) { if (usevid)
{
if (PSMT_IS32BIT(ptex->cpsm)) if (PSMT_IS32BIT(ptex->cpsm))
u = *(u32*)(psrc+4*addr); u = *(u32*)(psrc + 4 * addr);
else else
u = RGBA16to32(*(u16*)(psrc+2*addr)); u = RGBA16to32(*(u16*)(psrc + 2 * addr));
} }
else else
{
u = readPixel8H(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel8H(psrc, j, i, ptex->tbp0, ptex->tbw);
}
}
else
{
u = 0;
} }
else u = 0;
break; break;
case PSMT4HL: case PSMT4HL:
addr = getPixelAddress4HL(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress4HL(j, i, ptex->tbp0, ptex->tbw);
if (4*addr < 0x00400000)
if( 4*addr < 0x00400000 ) { {
if( usevid ) { if (usevid)
{
if (PSMT_IS32BIT(ptex->cpsm)) if (PSMT_IS32BIT(ptex->cpsm))
u = *(u32*)(psrc+4*addr); u = *(u32*)(psrc + 4 * addr);
else else
u = RGBA16to32(*(u16*)(psrc+2*addr)); u = RGBA16to32(*(u16*)(psrc + 2 * addr));
} }
else else
{
u = readPixel4HL(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel4HL(psrc, j, i, ptex->tbp0, ptex->tbw);
}
}
else
{
u = 0;
} }
else u = 0;
break; break;
case PSMT4HH: case PSMT4HH:
addr = getPixelAddress4HH(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress4HH(j, i, ptex->tbp0, ptex->tbw);
if (4*addr < 0x00400000)
if( 4*addr < 0x00400000 ) { {
if( usevid ) { if (usevid)
{
if (PSMT_IS32BIT(ptex->cpsm)) if (PSMT_IS32BIT(ptex->cpsm))
u = *(u32*)(psrc+4*addr); u = *(u32*)(psrc + 4 * addr);
else else
u = RGBA16to32(*(u16*)(psrc+2*addr)); u = RGBA16to32(*(u16*)(psrc + 2 * addr));
} }
else else
{
u = readPixel4HH(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel4HH(psrc, j, i, ptex->tbp0, ptex->tbw);
}
}
else
{
u = 0;
} }
else u = 0;
break; break;
case PSMT32Z: case PSMT32Z:
addr = getPixelAddress32Z(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress32Z(j, i, ptex->tbp0, ptex->tbw);
if (4*addr < 0x00400000)
if( 4*addr < 0x00400000 )
u = readPixel32Z(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel32Z(psrc, j, i, ptex->tbp0, ptex->tbw);
else u = 0; else
u = 0;
break; break;
case PSMT24Z: case PSMT24Z:
addr = getPixelAddress24Z(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress24Z(j, i, ptex->tbp0, ptex->tbw);
if (4*addr < 0x00400000)
if( 4*addr < 0x00400000 )
u = readPixel24Z(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel24Z(psrc, j, i, ptex->tbp0, ptex->tbw);
else u = 0; else
u = 0;
break; break;
case PSMT16Z: case PSMT16Z:
addr = getPixelAddress16Z(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress16Z(j, i, ptex->tbp0, ptex->tbw);
if (2*addr < 0x00400000)
if( 2*addr < 0x00400000 )
u = readPixel16Z(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel16Z(psrc, j, i, ptex->tbp0, ptex->tbw);
else u = 0; else
u = 0;
break; break;
case PSMT16SZ: case PSMT16SZ:
addr = getPixelAddress16SZ(j, i, ptex->tbp0, ptex->tbw); addr = getPixelAddress16SZ(j, i, ptex->tbp0, ptex->tbw);
if (2*addr < 0x00400000)
if( 2*addr < 0x00400000 )
u = readPixel16SZ(psrc, j, i, ptex->tbp0, ptex->tbw); u = readPixel16SZ(psrc, j, i, ptex->tbp0, ptex->tbw);
else u = 0; else
u = 0;
break; break;
default: default:
@ -530,29 +598,30 @@ ZeroGS::SaveTex(tex0Info* ptex, int usevid)
} }
char Name[TGA_FILE_NAME_MAX_LENGTH]; char Name[TGA_FILE_NAME_MAX_LENGTH];
snprintf( Name, TGA_FILE_NAME_MAX_LENGTH, "Tex.%d.tga", TexNumber );
snprintf(Name, TGA_FILE_NAME_MAX_LENGTH, "Tex.%d.tga", TexNumber);
SaveTGA(Name, ptex->tw, ptex->th, &data[0]); SaveTGA(Name, ptex->tw, ptex->th, &data[0]);
} }
// Do the save texture and return file name of it // Do the save texture and return file name of it
// Do not forget to call free(), other wise there would be memory leak! // Do not forget to call free(), other wise there would be memory leak!
char* char* ZeroGS::NamedSaveTex(tex0Info* ptex, int usevid)
ZeroGS::NamedSaveTex(tex0Info* ptex, int usevid){ {
SaveTex(ptex, usevid); SaveTex(ptex, usevid);
char* Name = (char*)malloc(TGA_FILE_NAME_MAX_LENGTH); char* Name = (char*)malloc(TGA_FILE_NAME_MAX_LENGTH);
snprintf( Name, TGA_FILE_NAME_MAX_LENGTH, "Tex.%d.tga", TexNumber ); snprintf(Name, TGA_FILE_NAME_MAX_LENGTH, "Tex.%d.tga", TexNumber);
TexNumber++; TexNumber++;
if (TexNumber > MAX_NUMBER_SAVED_TGA)
TexNumber = 0; if (TexNumber > MAX_NUMBER_SAVED_TGA) TexNumber = 0;
return Name; return Name;
} }
// Special function, wich is safe to call from any other file, without aviutils problems. // Special function, which is safe to call from any other file, without aviutils problems.
void void ZeroGS::Stop_Avi()
ZeroGS::Stop_Avi(){ {
#ifdef _WIN32 #ifdef _WIN32
STOP_AVI(); STOP_AVI();
#else #else

272
plugins/zzogl-pg/opengl/ZZoglVB.cpp
View File

@ -52,104 +52,123 @@ ZeroGS::VB::~VB()
void ZeroGS::VB::Destroy() void ZeroGS::VB::Destroy()
{ {
_aligned_free(pBufferData); pBufferData = NULL; nNumVertices = 0; _aligned_free(pBufferData);
pBufferData = NULL;
nNumVertices = 0;
prndr = NULL; prndr = NULL;
pdepth = NULL; pdepth = NULL;
} }
int ConstraintReson; int ConstraintReason;
// Return number of 64-pixels block, that guaranted could be hold in memory // Return number of 64-pixels block, that guaranted could be hold in memory
// from gsfb.fbp and tbp (textrure pase), zbuf.zbp (Z-buffer), frame.fbp // from gsfb.fbp and tbp (textrure pase), zbuf.zbp (Z-buffer), frame.fbp
// (previous frame). // (previous frame).
inline int inline int ZeroGS::VB::FindMinimalMemoryConstrain(int tbp, int maxpos)
ZeroGS::VB::FindMinimalMemoryConstrain(int tbp, int maxpos) { {
int MinConstraint = maxpos; int MinConstraint = maxpos;
// make sure texture is far away from tbp // make sure texture is far away from tbp
{ {
int Constraint = tbp - gsfb.fbp; int Constraint = tbp - gsfb.fbp;
if ((0 < Constraint) && (Constraint < MinConstraint)) {
if ((0 < Constraint) && (Constraint < MinConstraint))
{
MinConstraint = Constraint; MinConstraint = Constraint;
ConstraintReson = 1; ConstraintReason = 1;
} }
} }
// offroad uses 0x80 fbp which messes up targets // offroad uses 0x80 fbp which messes up targets
// special case when double buffering (hamsterball) // special case when double buffering (hamsterball)
// Suikoden 3 require e00 have this issue too. P3 - 0x1000. // Suikoden 3 require e00 have this issue too. P3 - 0x1000.
if (prndr != NULL) {
if (prndr != NULL)
{
int Constraint = frame.fbp - gsfb.fbp; int Constraint = frame.fbp - gsfb.fbp;
if ((0x0 < Constraint) && (Constraint < MinConstraint)) {
if ((0x0 < Constraint) && (Constraint < MinConstraint))
{
MinConstraint = Constraint; MinConstraint = Constraint;
ConstraintReson = 2; ConstraintReason = 2;
} }
} }
// old caching method // old caching method
// zmsk necessary for KH movie // zmsk necessary for KH movie
if (!zbuf.zmsk){ if (!zbuf.zmsk)
{
int Constraint = zbuf.zbp - gsfb.fbp; int Constraint = zbuf.zbp - gsfb.fbp;
if ((0 < Constraint) && (Constraint < MinConstraint)) {
if ((0 < Constraint) && (Constraint < MinConstraint))
{
MinConstraint = Constraint; MinConstraint = Constraint;
ConstraintReson = 3; ConstraintReason = 3;
} }
} }
// In 16Bit mode in one Word freame stored 2 pixels // In 16Bit mode in one Word frame stored 2 pixels
if (PSMT_ISHALF(gsfb.psm)) if (PSMT_ISHALF(gsfb.psm)) MinConstraint *= 2;
MinConstraint *= 2;
return MinConstraint ; return MinConstraint ;
} }
// Return number of 64 pizel words that could be placed in Z-Buffer // Return number of 64 pizel words that could be placed in Z-Buffer
// If no Z-buffer present return old constraint // If no Z-buffer present return old constraint
inline int inline int ZeroGS::VB::FindZbufferMemoryConstrain(int tbp, int maxpos)
ZeroGS::VB::FindZbufferMemoryConstrain(int tbp, int maxpos) { {
int MinConstraint = maxpos; int MinConstraint = maxpos;
// Check tbp / zbuffer constraint // Check tbp / zbuffer constraint
if (!zbuf.zmsk) { if (!zbuf.zmsk)
int Constraint = (tbp - zbuf.zbp) * (PSMT_ISHALF(zbuf.psm) ? 2 : 1 ); {
if ((0 < Constraint) && (Constraint < MinConstraint)) { int Constraint = (tbp - zbuf.zbp) * (PSMT_ISHALF(zbuf.psm) ? 2 : 1);
if ((0 < Constraint) && (Constraint < MinConstraint))
{
MinConstraint = Constraint; MinConstraint = Constraint;
ConstraintReson = 4; ConstraintReason = 4;
} }
} }
return MinConstraint; return MinConstraint;
} }
// Return heights limiter form scissor. . // Return heights limiter from scissor...
inline int inline int GetScissorY(int y)
GetScissorY(int y) { {
int fbh = (y >> MINMAX_SHIFT) + 1; int fbh = (y >> MINMAX_SHIFT) + 1;
if ( fbh > 2 && ( fbh & 1 ) ) fbh -= 1;
if (fbh > 2 && (fbh & 1)) fbh -= 1;
return fbh; return fbh;
} }
//There is several reason to limit a height of frame: maximum buffer size, calculated size //There is several reasons to limit a height of frame: maximum buffer size, calculated size
//from fbw and fbh and scissoring. //from fbw and fbh and scissoring.
inline int inline int ZeroGS::VB::FindMinimalHeightConstrain(int maxpos)
ZeroGS::VB::FindMinimalHeightConstrain(int maxpos) { {
int MinConstraint = maxpos; int MinConstraint = maxpos;
if (maxmin < MinConstraint) { if (maxmin < MinConstraint)
{
MinConstraint = maxmin; MinConstraint = maxmin;
ConstraintReson = 5; ConstraintReason = 5;
} }
if (gsfb.fbh < MinConstraint) { if (gsfb.fbh < MinConstraint)
{
MinConstraint = gsfb.fbh; MinConstraint = gsfb.fbh;
ConstraintReson = 6; ConstraintReason = 6;
} }
int ScissorConstraint = GetScissorY(scissor.y1) ; int ScissorConstraint = GetScissorY(scissor.y1) ;
if (ScissorConstraint < MinConstraint) {
if (ScissorConstraint < MinConstraint)
{
MinConstraint = ScissorConstraint; MinConstraint = ScissorConstraint;
ConstraintReson = 7; ConstraintReason = 7;
} }
return MinConstraint; return MinConstraint;
@ -157,32 +176,36 @@ ZeroGS::VB::FindMinimalHeightConstrain(int maxpos) {
// 32 bit frames have additional constraints to frame // 32 bit frames have additional constraints to frame
// maxpos was maximum length of frame at normal constraints // maxpos was maximum length of frame at normal constraints
inline void inline void ZeroGS::VB::CheckFrame32bitRes(int maxpos)
ZeroGS::VB::CheckFrame32bitRes(int maxpos)
{ {
int fbh = frame.fbh; int fbh = frame.fbh;
if ( frame.fbh >= 512 ) { if (frame.fbh >= 512)
{
// neopets hack // neopets hack
maxmin = min(maxmin, frame.fbh); maxmin = min(maxmin, frame.fbh);
frame.fbh = maxmin; frame.fbh = maxmin;
ConstraintReson = 8; ConstraintReason = 8;
} }
// ffxii hack to stop resolving // ffxii hack to stop resolving
if( frame.fbp >= 0x3000 && fbh >= 0x1a0 ) { if (frame.fbp >= 0x3000 && fbh >= 0x1a0)
{
int endfbp = frame.fbp + frame.fbw * fbh / (PSMT_ISHALF(gsfb.psm) ? 128 : 64); int endfbp = frame.fbp + frame.fbw * fbh / (PSMT_ISHALF(gsfb.psm) ? 128 : 64);
// see if there is a previous render target in the way, reduce // see if there is a previous render target in the way, reduce
for (CRenderTargetMngr::MAPTARGETS::iterator itnew = s_RTs.mapTargets.begin(); itnew != s_RTs.mapTargets.end(); ++itnew) {
if ( itnew->second->fbp > frame.fbp && endfbp > itnew->second->fbp ) { for (CRenderTargetMngr::MAPTARGETS::iterator itnew = s_RTs.mapTargets.begin(); itnew != s_RTs.mapTargets.end(); ++itnew)
{
if (itnew->second->fbp > frame.fbp && endfbp > itnew->second->fbp)
{
endfbp = itnew->second->fbp; endfbp = itnew->second->fbp;
} }
} }
frame.fbh = (endfbp - frame.fbp) * ( PSMT_ISHALF(gsfb.psm) ? 128: 64 ) / frame.fbw; frame.fbh = (endfbp - frame.fbp) * (PSMT_ISHALF(gsfb.psm) ? 128 : 64) / frame.fbw;
if (frame.fbh < fbh)
ConstraintReson = 9; if (frame.fbh < fbh) ConstraintReason = 9;
} }
} }
@ -192,30 +215,33 @@ ZeroGS::VB::CheckFrame32bitRes(int maxpos)
// 4Mb memory in 64 bit (4 bytes) words. // 4Mb memory in 64 bit (4 bytes) words.
// |------------------------|---------------------|----------|----------|---------------------| // |------------------------|---------------------|----------|----------|---------------------|
// 0 gsfb.fbp zbuff.zpb tbp frame.fbp 2^20/64 // 0 gsfb.fbp zbuff.zpb tbp frame.fbp 2^20/64
inline int inline int ZeroGS::VB::CheckFrameAddConstraints(int tbp)
ZeroGS::VB::CheckFrameAddConstraints(int tbp)
{ {
if ( gsfb.fbw <= 0 ) { if (gsfb.fbw <= 0)
{
ERROR_LOG_SPAM("render target null, no constraints. Ignoring\n"); ERROR_LOG_SPAM("render target null, no constraints. Ignoring\n");
return -1; return -1;
} }
// Memory region after fbp // Memory region after fbp
int maxmemorypos = 0x4000 - gsfb.fbp; int maxmemorypos = 0x4000 - gsfb.fbp;
ConstraintReson = 0;
ConstraintReason = 0;
maxmemorypos = FindMinimalMemoryConstrain(tbp, maxmemorypos); maxmemorypos = FindMinimalMemoryConstrain(tbp, maxmemorypos);
maxmemorypos = FindZbufferMemoryConstrain(tbp, maxmemorypos); maxmemorypos = FindZbufferMemoryConstrain(tbp, maxmemorypos);
int maxpos = 64 * maxmemorypos ; int maxpos = 64 * maxmemorypos ;
maxpos /= gsfb.fbw; maxpos /= gsfb.fbw;
//? atelier iris crashes without it //? atelier iris crashes without it
if( maxpos > 256 ) if (maxpos > 256) maxpos &= ~0x1f;
maxpos &= ~0x1f;
#ifdef DEVBUILD #ifdef DEVBUILD
int noscissorpos = maxpos; int noscissorpos = maxpos;
int ConstrainR1 = ConstraintReson;
int ConstrainR1 = ConstraintReason;
#endif #endif
maxpos = FindMinimalHeightConstrain(maxpos); maxpos = FindMinimalHeightConstrain(maxpos);
@ -223,12 +249,13 @@ ZeroGS::VB::CheckFrameAddConstraints(int tbp)
frame = gsfb; frame = gsfb;
frame.fbh = maxpos; frame.fbh = maxpos;
if( !PSMT_ISHALF(frame.psm) || !(g_GameSettings&GAME_FULL16BITRES) ) if (!PSMT_ISHALF(frame.psm) || !(g_GameSettings&GAME_FULL16BITRES))
CheckFrame32bitRes( maxpos ) ; CheckFrame32bitRes(maxpos);
#ifdef DEVBUILD #ifdef DEVBUILD
if (frame.fbh == 0xe2) if (frame.fbh == 0xe2)
ZZLog::Error_Log ("Const: %x %x %d| %x %d %x %x", frame.fbh, frame.fbw, ConstraintReson, noscissorpos, ConstrainR1, tbp, frame.fbp); ZZLog::Error_Log("Const: %x %x %d| %x %d %x %x", frame.fbh, frame.fbw, ConstraintReason, noscissorpos, ConstrainR1, tbp, frame.fbp);
#endif #endif
// Fixme: Reserved psm for framebuffers // Fixme: Reserved psm for framebuffers
@ -237,11 +264,9 @@ ZeroGS::VB::CheckFrameAddConstraints(int tbp)
return 0 ; return 0 ;
} }
// Check if after resising new depth target is need to be used. // Check if after resizing new depth target is needed to be used.
// it return 2 if new deapth target used. bool Chose is used to proprely check // it returns 2 if a new depth target is used.
// renderer target status inline int ZeroGS::VB::CheckFrameResolveDepth(int tbp)
inline int
ZeroGS::VB::CheckFrameResolveDepth(int tbp)
{ {
int result = 0 ; int result = 0 ;
CDepthTarget* pprevdepth = pdepth; CDepthTarget* pprevdepth = pdepth;
@ -250,13 +275,13 @@ ZeroGS::VB::CheckFrameResolveDepth(int tbp)
// just z changed // just z changed
frameInfo f = CreateFrame(zbuf.zbp, prndr->fbw, prndr->fbh, zbuf.psm, (zbuf.psm == 0x31) ? 0xff000000 : 0); frameInfo f = CreateFrame(zbuf.zbp, prndr->fbw, prndr->fbh, zbuf.psm, (zbuf.psm == 0x31) ? 0xff000000 : 0);
CDepthTarget* pnewdepth = (CDepthTarget*)s_DepthRTs.GetTarg(f, CRenderTargetMngr::TO_DepthBuffer|CRenderTargetMngr::TO_StrictHeight| CDepthTarget* pnewdepth = (CDepthTarget*)s_DepthRTs.GetTarg(f, CRenderTargetMngr::TO_DepthBuffer | CRenderTargetMngr::TO_StrictHeight |
(zbuf.zmsk?CRenderTargetMngr::TO_Virtual:0), get_maxheight(zbuf.zbp, gsfb.fbw, 0)); (zbuf.zmsk ? CRenderTargetMngr::TO_Virtual : 0), get_maxheight(zbuf.zbp, gsfb.fbw, 0));
assert( pnewdepth != NULL && prndr != NULL ); assert(pnewdepth != NULL && prndr != NULL);
assert( pnewdepth->fbh == prndr->fbh ); assert(pnewdepth->fbh == prndr->fbh);
if( (pprevdepth != pnewdepth) || (pprevdepth != NULL && (pprevdepth->status & CRenderTarget::TS_NeedUpdate)) ) if ((pprevdepth != pnewdepth) || (pprevdepth != NULL && (pprevdepth->status & CRenderTarget::TS_NeedUpdate)))
result = 2; result = 2;
pdepth = pnewdepth; pdepth = pnewdepth;
@ -264,11 +289,11 @@ ZeroGS::VB::CheckFrameResolveDepth(int tbp)
return result ; return result ;
} }
// Check if after resings new render target is need to be used. Also perform deptaget check // Check if after resizing, a new render target is needed to be used. Also perform deptarget check.
// Return 1 if only render target is changed and 3 -- if both. // Returns 1 if only 1 render target is changed and 3 -- if both.
inline int inline int ZeroGS::VB::CheckFrameResolveRender(int tbp)
ZeroGS::VB::CheckFrameResolveRender(int tbp) { {
int result = 0 ; int result = 0;
CRenderTarget* pprevrndr = prndr; CRenderTarget* pprevrndr = prndr;
prndr = NULL; prndr = NULL;
@ -277,98 +302,115 @@ ZeroGS::VB::CheckFrameResolveRender(int tbp) {
// Set renderes to NULL to prevent Flushing. // Set renderes to NULL to prevent Flushing.
CRenderTarget* pnewtarg = s_RTs.GetTarg(frame, 0, maxmin); CRenderTarget* pnewtarg = s_RTs.GetTarg(frame, 0, maxmin);
assert( pnewtarg != NULL ); assert(pnewtarg != NULL);
// pnewtarg->fbh >= 0x1c0 needed for ffx // pnewtarg->fbh >= 0x1c0 needed for ffx
if( (pnewtarg->fbh >= 0x1c0) && pnewtarg->fbh > frame.fbh && zbuf.zbp < tbp && !zbuf.zmsk ) {
if ((pnewtarg->fbh >= 0x1c0) && pnewtarg->fbh > frame.fbh && zbuf.zbp < tbp && !zbuf.zmsk)
{
// check if zbuf is in the way of the texture (suikoden5) // check if zbuf is in the way of the texture (suikoden5)
int maxallowedfbh = (tbp-zbuf.zbp)*(PSMT_ISHALF(zbuf.psm)?128:64) / gsfb.fbw; int maxallowedfbh = (tbp - zbuf.zbp) * (PSMT_ISHALF(zbuf.psm) ? 128 : 64) / gsfb.fbw;
if (PSMT_ISHALF(gsfb.psm)) maxallowedfbh *= 2; if (PSMT_ISHALF(gsfb.psm)) maxallowedfbh *= 2;
if (pnewtarg->fbh > maxallowedfbh + 32) { // +32 needed for ffx2 if (pnewtarg->fbh > maxallowedfbh + 32) // +32 needed for ffx2
{
// destroy and recreate // destroy and recreate
s_RTs.DestroyAllTargs(0, 0x100, pnewtarg->fbw); s_RTs.DestroyAllTargs(0, 0x100, pnewtarg->fbw);
pnewtarg = s_RTs.GetTarg(frame, 0, maxmin); pnewtarg = s_RTs.GetTarg(frame, 0, maxmin);
assert( pnewtarg != NULL ); assert(pnewtarg != NULL);
} }
} }
ZZLog::Prim_Log("frame_%d: fbp=0x%x fbw=%d fbh=%d(%d) psm=0x%x fbm=0x%x\n", ictx, gsfb.fbp, gsfb.fbw, gsfb.fbh, pnewtarg->fbh, gsfb.psm, gsfb.fbm); ZZLog::Prim_Log("frame_%d: fbp=0x%x fbw=%d fbh=%d(%d) psm=0x%x fbm=0x%x\n", ictx, gsfb.fbp, gsfb.fbw, gsfb.fbh, pnewtarg->fbh, gsfb.psm, gsfb.fbm);
if( (pprevrndr != pnewtarg) || (pprevrndr != NULL && (pprevrndr->status & CRenderTarget::TS_NeedUpdate)) ) if ((pprevrndr != pnewtarg) || (pprevrndr != NULL && (pprevrndr->status & CRenderTarget::TS_NeedUpdate)))
result = 1; result = 1;
prndr = pnewtarg; prndr = pnewtarg;
pdepth = pprevdepth ; pdepth = pprevdepth ;
result |= CheckFrameResolveDepth(tbp) ; result |= CheckFrameResolveDepth(tbp) ;
return result ; return result ;
} }
// After frame resetting it is possible that 16 to 32 or 32 to 16 (color bits) conversion should be made. // After frame resetting, it is possible that 16 to 32 or 32 to 16 (color bits) conversion should be made.
inline void inline void ZeroGS::VB::CheckFrame16vs32Convesion()
ZeroGS::VB::CheckFrame16vs32Convesion()
{ {
if( prndr->status & CRenderTarget::TS_NeedConvert32) { if (prndr->status & CRenderTarget::TS_NeedConvert32)
if( pdepth->pdepth != 0 ) {
pdepth->SetDepthStencilSurface(); if (pdepth->pdepth != 0) pdepth->SetDepthStencilSurface();
prndr->fbh *= 2; prndr->fbh *= 2;
prndr->ConvertTo32(); prndr->ConvertTo32();
prndr->status &= ~CRenderTarget::TS_NeedConvert32; prndr->status &= ~CRenderTarget::TS_NeedConvert32;
} }
else if( prndr->status & CRenderTarget::TS_NeedConvert16 ) { else if (prndr->status & CRenderTarget::TS_NeedConvert16)
if( pdepth->pdepth != 0 ) {
pdepth->SetDepthStencilSurface(); if (pdepth->pdepth != 0) pdepth->SetDepthStencilSurface();
prndr->fbh /= 2; prndr->fbh /= 2;
prndr->ConvertTo16(); prndr->ConvertTo16();
prndr->status &= ~CRenderTarget::TS_NeedConvert16; prndr->status &= ~CRenderTarget::TS_NeedConvert16;
} }
} }
// a lot of times, target is too big and overwrites the texture using, // A lot of times, the target is too big and overwrites the texture.
// if tbp != 0, use it to bound // If tbp != 0, use it to bound.
void ZeroGS::VB::CheckFrame(int tbp) void ZeroGS::VB::CheckFrame(int tbp)
{ {
static int bChanged; static int bChanged;
if( bNeedZCheck ) {
if (bNeedZCheck)
{
ZZLog::Prim_Log("zbuf_%d: zbp=0x%x psm=0x%x, zmsk=%d\n", ictx, zbuf.zbp, zbuf.psm, zbuf.zmsk); ZZLog::Prim_Log("zbuf_%d: zbp=0x%x psm=0x%x, zmsk=%d\n", ictx, zbuf.zbp, zbuf.psm, zbuf.zmsk);
//zbuf = *zb; //zbuf = *zb;
} }
if( m_Blocks[gsfb.psm].bpp == 0 ) { if (m_Blocks[gsfb.psm].bpp == 0)
{
ZZLog::Error_Log("CheckFrame invalid bpp %d.", gsfb.psm); ZZLog::Error_Log("CheckFrame invalid bpp %d.", gsfb.psm);
return; return;
} }
bChanged = 0; bChanged = 0;
if( bNeedFrameCheck ) { if (bNeedFrameCheck)
{
// important to set before calling GetTarg // important to set before calling GetTarg
bNeedFrameCheck = 0; bNeedFrameCheck = 0;
bNeedZCheck = 0; bNeedZCheck = 0;
if ( CheckFrameAddConstraints(tbp) == -1 ) return ;
if ( ( prndr != NULL ) && ( prndr->psm != gsfb.psm ) ) { if (CheckFrameAddConstraints(tbp) == -1) return ;
if ((prndr != NULL) && (prndr->psm != gsfb.psm))
{
// behavior for dest alpha varies // behavior for dest alpha varies
ResetAlphaVariables(); ResetAlphaVariables();
} }
bChanged = CheckFrameResolveRender(tbp);
bChanged = CheckFrameResolveRender(tbp) ;
CheckFrame16vs32Convesion(); CheckFrame16vs32Convesion();
} }
else if (bNeedZCheck) { else if (bNeedZCheck)
{
bNeedZCheck = 0; bNeedZCheck = 0;
if (prndr != NULL && gsfb.fbw > 0 )
if (prndr != NULL && gsfb.fbw > 0)
CheckFrameResolveDepth(tbp); CheckFrameResolveDepth(tbp);
} }
if( prndr != NULL ) SetContextTarget(ictx); if (prndr != NULL) SetContextTarget(ictx);
} }
// This is the case, most easy to perform, when nothinh was changed // This is the case, most easy to perform, when nothinh was changed
inline void ZeroGS::VB::FlushTexUnchangedClutDontUpdate() { inline void ZeroGS::VB::FlushTexUnchangedClutDontUpdate()
if (ZZOglGet_cld_TexBits(uNextTex0Data[1])) { {
if (ZZOglGet_cld_TexBits(uNextTex0Data[1]))
{
ZeroGS::texClutWrite(ictx); ZeroGS::texClutWrite(ictx);
// invalidate to make sure target didn't change! // invalidate to make sure target didn't change!
bVarsTexSync = FALSE; bVarsTexSync = FALSE;
@ -377,7 +419,8 @@ inline void ZeroGS::VB::FlushTexUnchangedClutDontUpdate() {
// The second of easy branch. We does not change storage model, so we don't need to // The second of easy branch. We does not change storage model, so we don't need to
// update anything except texture itself // update anything except texture itself
inline void ZeroGS::VB::FlushTexClutDontUpdate() { inline void ZeroGS::VB::FlushTexClutDontUpdate()
{
if (!ZZOglClutStorageUnchanged(uCurTex0Data, uNextTex0Data)) if (!ZZOglClutStorageUnchanged(uCurTex0Data, uNextTex0Data))
ZeroGS::Flush(ictx); ZeroGS::Flush(ictx);
@ -388,12 +431,14 @@ inline void ZeroGS::VB::FlushTexClutDontUpdate() {
tex0.cpsm = ZZOglGet_cpsm_TexBits(uNextTex0Data[1]); tex0.cpsm = ZZOglGet_cpsm_TexBits(uNextTex0Data[1]);
ZeroGS::texClutWrite(ictx); ZeroGS::texClutWrite(ictx);
bVarsTexSync = FALSE; bVarsTexSync = FALSE;
} }
// Set texture variables after big change // Set texture variables after big change
inline void ZeroGS::VB::FlushTexSetNewVars(u32 psm) { inline void ZeroGS::VB::FlushTexSetNewVars(u32 psm)
{
tex0.tbp0 = ZZOglGet_tbp0_TexBits(uNextTex0Data[0]); tex0.tbp0 = ZZOglGet_tbp0_TexBits(uNextTex0Data[0]);
tex0.tbw = ZZOglGet_tbw_TexBitsMult(uNextTex0Data[0]); tex0.tbw = ZZOglGet_tbw_TexBitsMult(uNextTex0Data[0]);
tex0.psm = psm; tex0.psm = psm;
@ -403,34 +448,37 @@ inline void ZeroGS::VB::FlushTexSetNewVars(u32 psm) {
tex0.tcc = ZZOglGet_tcc_TexBits(uNextTex0Data[1]); tex0.tcc = ZZOglGet_tcc_TexBits(uNextTex0Data[1]);
tex0.tfx = ZZOglGet_tfx_TexBits(uNextTex0Data[1]); tex0.tfx = ZZOglGet_tfx_TexBits(uNextTex0Data[1]);
ZeroGS::fiTexWidth[ictx] = (1/16.0f)/ tex0.tw; ZeroGS::fiTexWidth[ictx] = (1 / 16.0f) / tex0.tw;
ZeroGS::fiTexHeight[ictx] = (1/16.0f) / tex0.th; ZeroGS::fiTexHeight[ictx] = (1 / 16.0f) / tex0.th;
} }
// Flush == draw on screen // Flush == draw on screen
// This function made VB state consistant before real Flush. // This function made VB state consistant before real Flush.
void ZeroGS::VB::FlushTexData() void ZeroGS::VB::FlushTexData()
{ {
assert( bNeedTexCheck ); assert(bNeedTexCheck);
bNeedTexCheck = 0; bNeedTexCheck = 0;
u32 psm = ZZOglGet_psm_TexBitsFix(uNextTex0Data[0]); u32 psm = ZZOglGet_psm_TexBitsFix(uNextTex0Data[0]);
// don't update unless necessary // don't update unless necessary
if (ZZOglAllExceptClutIsSame(uCurTex0Data, uNextTex0Data)) {
if (ZZOglAllExceptClutIsSame(uCurTex0Data, uNextTex0Data))
{
// Don't need to do anything if there is no clutting and VB tex data was not changed // Don't need to do anything if there is no clutting and VB tex data was not changed
if( !PSMT_ISCLUT(psm) ) if (!PSMT_ISCLUT(psm)) return ;
return ;
// have to write the CLUT again if only CLD was changed // have to write the CLUT again if only CLD was changed
if( ZZOglClutMinusCLDunchanged(uCurTex0Data, uNextTex0Data) ) { if (ZZOglClutMinusCLDunchanged(uCurTex0Data, uNextTex0Data))
{
FlushTexUnchangedClutDontUpdate(); FlushTexUnchangedClutDontUpdate();
return; return;
} }
// Cld bit is 0 means that clut buffer stay unchanged // Cld bit is 0 means that clut buffer stay unchanged
if( ZZOglGet_cld_TexBits(uNextTex0Data[1]) == 0 ) { if (ZZOglGet_cld_TexBits(uNextTex0Data[1]) == 0)
{
FlushTexClutDontUpdate(); FlushTexClutDontUpdate();
return; return;
} }
@ -438,6 +486,7 @@ void ZeroGS::VB::FlushTexData()
// Made the full update // Made the full update
ZeroGS::Flush(ictx); ZeroGS::Flush(ictx);
bVarsTexSync = FALSE; bVarsTexSync = FALSE;
bTexConstsSync = FALSE; bTexConstsSync = FALSE;
@ -446,8 +495,5 @@ void ZeroGS::VB::FlushTexData()
FlushTexSetNewVars(psm); FlushTexSetNewVars(psm);
if( PSMT_ISCLUT(psm) ) if (PSMT_ISCLUT(psm)) ZeroGS::CluttingForFlushedTex(&tex0, uNextTex0Data[1], ictx) ;
ZeroGS::CluttingForFlushedTex(&tex0, uNextTex0Data[1], ictx ) ;
} }

18
plugins/zzogl-pg/opengl/rasterfont.cpp
View File

@ -1,4 +1,3 @@
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
#endif #endif
@ -9,7 +8,8 @@
#include "rasterfont.h" #include "rasterfont.h"
// globals // globals
GLubyte rasters[][13] = { GLubyte rasters[][13] =
{
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, {0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36},
@ -113,9 +113,11 @@ RasterFont::RasterFont()
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// create the raster font // create the raster font
fontOffset = glGenLists (128); fontOffset = glGenLists(128);
for (int i = 32; i < 127; i++) {
glNewList(i+fontOffset, GL_COMPILE); for (int i = 32; i < 127; i++)
{
glNewList(i + fontOffset, GL_COMPILE);
glBitmap(8, 13, 0.0f, 2.0f, 10.0f, 0.0f, rasters[i-32]); glBitmap(8, 13, 0.0f, 2.0f, 10.0f, 0.0f, rasters[i-32]);
glEndList(); glEndList();
} }
@ -131,16 +133,16 @@ void RasterFont::printString(const char *s, double x, double y, double z)
// go to the right spot // go to the right spot
glRasterPos3d(x, y, z); glRasterPos3d(x, y, z);
glPushAttrib (GL_LIST_BIT); glPushAttrib(GL_LIST_BIT);
glListBase(fontOffset); glListBase(fontOffset);
glCallLists(strlen(s), GL_UNSIGNED_BYTE, (GLubyte *) s); glCallLists(strlen(s), GL_UNSIGNED_BYTE, (GLubyte *) s);
glPopAttrib (); glPopAttrib();
} }
void RasterFont::printCenteredString(const char *s, double y, int screen_width, double z) void RasterFont::printCenteredString(const char *s, double y, int screen_width, double z)
{ {
int length = strlen(s); int length = strlen(s);
int x = int(screen_width/2.0 - (length/2.0)*char_width); int x = int(screen_width / 2.0 - (length / 2.0) * char_width);
printString(s, x, y, z); printString(s, x, y, z);
} }

2055
plugins/zzogl-pg/opengl/targets.cpp
View File

File diff suppressed because it is too large Load Diff

320
plugins/zzogl-pg/opengl/x86.cpp
View File

@ -191,10 +191,10 @@ void __fastcall Frame16SwizzleBlock16Z##type##c(u16* dst, Vector_16F* src, int s
src += srcpitch << incsrc; \ src += srcpitch << incsrc; \
} \ } \
} \ } \
_FrameSwizzleBlock(_, src[j], src[j], 0); _FrameSwizzleBlock(_, src[j], src[j], 0);
_FrameSwizzleBlock(A2_, (src[2*j]+src[2*j+1])>>1, src[2*j], 0); _FrameSwizzleBlock(A2_, (src[2*j] + src[2*j+1]) >> 1, src[2*j], 0);
_FrameSwizzleBlock(A4_, (src[2*j]+src[2*j+1]+src[2*j+srcpitch]+src[2*j+srcpitch+1])>>2, src[2*j], 1); _FrameSwizzleBlock(A4_, (src[2*j] + src[2*j+1] + src[2*j+srcpitch] + src[2*j+srcpitch+1]) >> 2, src[2*j], 1);
#ifdef ZEROGS_SSE2 #ifdef ZEROGS_SSE2
@ -266,9 +266,9 @@ extern "C" void __fastcall WriteCLUT_T32_I8_CSM1_sse2(u32* vm, u32* clut)
__m128i* src = (__m128i*)vm; __m128i* src = (__m128i*)vm;
__m128i* dst = (__m128i*)clut; __m128i* dst = (__m128i*)clut;
for(int j = 0; j < 64; j += 32, src += 32, dst += 32) for (int j = 0; j < 64; j += 32, src += 32, dst += 32)
{ {
for(int i = 0; i < 16; i += 4) for (int i = 0; i < 16; i += 4)
{ {
__m128i r0 = _mm_load_si128(&src[i+0]); __m128i r0 = _mm_load_si128(&src[i+0]);
__m128i r1 = _mm_load_si128(&src[i+1]); __m128i r1 = _mm_load_si128(&src[i+1]);
@ -310,16 +310,19 @@ extern "C" void __fastcall WriteCLUT_T32_I4_CSM1_sse2(u32* vm, u32* clut)
} }
extern "C" { extern "C"
PCSX2_ALIGNED16(int s_clut16mask2[4]) = { 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff }; {
PCSX2_ALIGNED16(int s_clut16mask[8]) = { 0xffff0000, 0xffff0000, 0xffff0000, 0xffff0000, PCSX2_ALIGNED16(int s_clut16mask2[4]) = { 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff };
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff}; PCSX2_ALIGNED16(int s_clut16mask[8]) = { 0xffff0000, 0xffff0000, 0xffff0000, 0xffff0000,
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff
};
} }
extern "C" void __fastcall WriteCLUT_T16_I4_CSM1_sse2(u32* vm, u32* clut) extern "C" void __fastcall WriteCLUT_T16_I4_CSM1_sse2(u32* vm, u32* clut)
{ {
#if defined(_MSC_VER) #if defined(_MSC_VER)
__asm { __asm
{
mov eax, vm mov eax, vm
mov ecx, clut mov ecx, clut
movdqa xmm0, qword ptr [eax] movdqa xmm0, qword ptr [eax]
@ -428,122 +431,125 @@ WriteUnaligned:
movdqa [ecx+16], xmm2 movdqa [ecx+16], xmm2
movdqa [ecx+48], xmm3 movdqa [ecx+48], xmm3
End: End:
} }
#else #else
__asm__(".intel_syntax noprefix\n" __asm__(".intel_syntax noprefix\n"
"movdqa xmm0, xmmword ptr [ecx]\n" "movdqa xmm0, xmmword ptr [ecx]\n"
"movdqa xmm1, xmmword ptr [ecx+16]\n" "movdqa xmm1, xmmword ptr [ecx+16]\n"
"movdqa xmm2, xmmword ptr [ecx+32]\n" "movdqa xmm2, xmmword ptr [ecx+32]\n"
"movdqa xmm3, xmmword ptr [ecx+48]\n" "movdqa xmm3, xmmword ptr [ecx+48]\n"
// rearrange // rearrange
"pshuflw xmm0, xmm0, 0x88\n" "pshuflw xmm0, xmm0, 0x88\n"
"pshufhw xmm0, xmm0, 0x88\n" "pshufhw xmm0, xmm0, 0x88\n"
"pshuflw xmm1, xmm1, 0x88\n" "pshuflw xmm1, xmm1, 0x88\n"
"pshufhw xmm1, xmm1, 0x88\n" "pshufhw xmm1, xmm1, 0x88\n"
"pshuflw xmm2, xmm2, 0x88\n" "pshuflw xmm2, xmm2, 0x88\n"
"pshufhw xmm2, xmm2, 0x88\n" "pshufhw xmm2, xmm2, 0x88\n"
"pshuflw xmm3, xmm3, 0x88\n" "pshuflw xmm3, xmm3, 0x88\n"
"pshufhw xmm3, xmm3, 0x88\n" "pshufhw xmm3, xmm3, 0x88\n"
"shufps xmm0, xmm1, 0x88\n" "shufps xmm0, xmm1, 0x88\n"
"shufps xmm2, xmm3, 0x88\n" "shufps xmm2, xmm3, 0x88\n"
"pshufd xmm0, xmm0, 0xd8\n" "pshufd xmm0, xmm0, 0xd8\n"
"pshufd xmm2, xmm2, 0xd8\n" "pshufd xmm2, xmm2, 0xd8\n"
"pxor xmm6, xmm6\n" "pxor xmm6, xmm6\n"
"test edx, 15\n" "test edx, 15\n"
"jnz WriteUnaligned\n" "jnz WriteUnaligned\n"
"movdqa xmm7, [%[s_clut16mask]]\n" // saves upper 16 bits "movdqa xmm7, [%[s_clut16mask]]\n" // saves upper 16 bits
// have to save interlaced with the old data // have to save interlaced with the old data
"movdqa xmm4, [edx]\n" "movdqa xmm4, [edx]\n"
"movdqa xmm5, [edx+32]\n" "movdqa xmm5, [edx+32]\n"
"movhlps xmm1, xmm0\n" "movhlps xmm1, xmm0\n"
"movlhps xmm0, xmm2\n"// lower 8 colors "movlhps xmm0, xmm2\n"// lower 8 colors
"pand xmm4, xmm7\n" "pand xmm4, xmm7\n"
"pand xmm5, xmm7\n" "pand xmm5, xmm7\n"
"shufps xmm1, xmm2, 0xe4\n" // upper 8 colors "shufps xmm1, xmm2, 0xe4\n" // upper 8 colors
"movdqa xmm2, xmm0\n" "movdqa xmm2, xmm0\n"
"movdqa xmm3, xmm1\n" "movdqa xmm3, xmm1\n"
"punpcklwd xmm0, xmm6\n" "punpcklwd xmm0, xmm6\n"
"punpcklwd xmm1, xmm6\n" "punpcklwd xmm1, xmm6\n"
"por xmm0, xmm4\n" "por xmm0, xmm4\n"
"por xmm1, xmm5\n" "por xmm1, xmm5\n"
"punpckhwd xmm2, xmm6\n" "punpckhwd xmm2, xmm6\n"
"punpckhwd xmm3, xmm6\n" "punpckhwd xmm3, xmm6\n"
"movdqa [edx], xmm0\n" "movdqa [edx], xmm0\n"
"movdqa [edx+32], xmm1\n" "movdqa [edx+32], xmm1\n"
"movdqa xmm5, xmm7\n" "movdqa xmm5, xmm7\n"
"pand xmm7, [edx+16]\n" "pand xmm7, [edx+16]\n"
"pand xmm5, [edx+48]\n" "pand xmm5, [edx+48]\n"
"por xmm2, xmm7\n" "por xmm2, xmm7\n"
"por xmm3, xmm5\n" "por xmm3, xmm5\n"
"movdqa [edx+16], xmm2\n" "movdqa [edx+16], xmm2\n"
"movdqa [edx+48], xmm3\n" "movdqa [edx+48], xmm3\n"
"jmp WriteCLUT_T16_I4_CSM1_End\n" "jmp WriteCLUT_T16_I4_CSM1_End\n"
"WriteUnaligned:\n" "WriteUnaligned:\n"
// %edx is offset by 2 // %edx is offset by 2
"sub edx, 2\n" "sub edx, 2\n"
"movdqa xmm7, [%[s_clut16mask2]]\n" // saves lower 16 bits "movdqa xmm7, [%[s_clut16mask2]]\n" // saves lower 16 bits
// have to save interlaced with the old data // have to save interlaced with the old data
"movdqa xmm4, [edx]\n" "movdqa xmm4, [edx]\n"
"movdqa xmm5, [edx+32]\n" "movdqa xmm5, [edx+32]\n"
"movhlps xmm1, xmm0\n" "movhlps xmm1, xmm0\n"
"movlhps xmm0, xmm2\n" // lower 8 colors "movlhps xmm0, xmm2\n" // lower 8 colors
"pand xmm4, xmm7\n" "pand xmm4, xmm7\n"
"pand xmm5, xmm7\n" "pand xmm5, xmm7\n"
"shufps xmm1, xmm2, 0xe4\n" // upper 8 colors "shufps xmm1, xmm2, 0xe4\n" // upper 8 colors
"movdqa xmm2, xmm0\n" "movdqa xmm2, xmm0\n"
"movdqa xmm3, xmm1\n" "movdqa xmm3, xmm1\n"
"punpcklwd xmm0, xmm6\n" "punpcklwd xmm0, xmm6\n"
"punpcklwd xmm1, xmm6\n" "punpcklwd xmm1, xmm6\n"
"pslld xmm0, 16\n" "pslld xmm0, 16\n"
"pslld xmm1, 16\n" "pslld xmm1, 16\n"
"por xmm0, xmm4\n" "por xmm0, xmm4\n"
"por xmm1, xmm5\n" "por xmm1, xmm5\n"
"punpckhwd xmm2, xmm6\n" "punpckhwd xmm2, xmm6\n"
"punpckhwd xmm3, xmm6\n" "punpckhwd xmm3, xmm6\n"
"pslld xmm2, 16\n" "pslld xmm2, 16\n"
"pslld xmm3, 16\n" "pslld xmm3, 16\n"
"movdqa [edx], xmm0\n" "movdqa [edx], xmm0\n"
"movdqa [edx+32], xmm1\n" "movdqa [edx+32], xmm1\n"
"movdqa xmm5, xmm7\n" "movdqa xmm5, xmm7\n"
"pand xmm7, [edx+16]\n" "pand xmm7, [edx+16]\n"
"pand xmm5, [edx+48]\n" "pand xmm5, [edx+48]\n"
"por xmm2, xmm7\n" "por xmm2, xmm7\n"
"por xmm3, xmm5\n" "por xmm3, xmm5\n"
"movdqa [edx+16], xmm2\n" "movdqa [edx+16], xmm2\n"
"movdqa [edx+48], xmm3\n" "movdqa [edx+48], xmm3\n"
"WriteCLUT_T16_I4_CSM1_End:\n" "WriteCLUT_T16_I4_CSM1_End:\n"
".att_syntax\n" ".att_syntax\n"
: [s_clut16mask]"=m"(s_clut16mask), [s_clut16mask2]"=m"(s_clut16mask2)
); : [s_clut16mask]"=m"(s_clut16mask), [s_clut16mask2]"=m"(s_clut16mask2)
);
#endif // _MSC_VER #endif // _MSC_VER
} }
#endif // ZEROGS_SSE2 #endif // ZEROGS_SSE2
void __fastcall WriteCLUT_T16_I8_CSM1_c(u32* _vm, u32* _clut) void __fastcall WriteCLUT_T16_I8_CSM1_c(u32* _vm, u32* _clut)
@ -559,27 +565,31 @@ void __fastcall WriteCLUT_T16_I8_CSM1_c(u32* _vm, u32* _clut)
u16* vm = (u16*)_vm; u16* vm = (u16*)_vm;
u16* clut = (u16*)_clut; u16* clut = (u16*)_clut;
int left = ((u32)(uptr)clut&2) ? 512 : 512-(((u32)(uptr)clut)&0x3ff)/2; int left = ((u32)(uptr)clut & 2) ? 512 : 512 - (((u32)(uptr)clut) & 0x3ff) / 2;
for(int j = 0; j < 8; j++, vm += 32, clut += 64, left -= 32) for (int j = 0; j < 8; j++, vm += 32, clut += 64, left -= 32)
{ {
if(left == 32) { if (left == 32)
assert( left == 32 ); {
for(int i = 0; i < 16; i++) assert(left == 32);
for (int i = 0; i < 16; i++)
clut[2*i] = vm[map[i]]; clut[2*i] = vm[map[i]];
clut = (u16*)((uptr)clut & ~0x3ff) + 1; clut = (u16*)((uptr)clut & ~0x3ff) + 1;
for(int i = 16; i < 32; i++) for (int i = 16; i < 32; i++)
clut[2*i] = vm[map[i]]; clut[2*i] = vm[map[i]];
} }
else { else
if( left == 0 ) { {
if (left == 0)
{
clut = (u16*)((uptr)clut & ~0x3ff) + 1; clut = (u16*)((uptr)clut & ~0x3ff) + 1;
left = -1; left = -1;
} }
for(int i = 0; i < 32; i++) for (int i = 0; i < 32; i++)
clut[2*i] = vm[map[i]]; clut[2*i] = vm[map[i]];
} }
} }
@ -590,8 +600,9 @@ void __fastcall WriteCLUT_T32_I8_CSM1_c(u32* vm, u32* clut)
u64* src = (u64*)vm; u64* src = (u64*)vm;
u64* dst = (u64*)clut; u64* dst = (u64*)clut;
for(int j = 0; j < 2; j++, src += 32) { for (int j = 0; j < 2; j++, src += 32)
for(int i = 0; i < 4; i++, dst+=16, src+=8) {
for (int i = 0; i < 4; i++, dst += 16, src += 8)
{ {
dst[0] = src[0]; dst[0] = src[0];
dst[1] = src[2]; dst[1] = src[2];
@ -619,14 +630,22 @@ void __fastcall WriteCLUT_T16_I4_CSM1_c(u32* _vm, u32* _clut)
u16* dst = (u16*)_clut; u16* dst = (u16*)_clut;
u16* src = (u16*)_vm; u16* src = (u16*)_vm;
dst[0] = src[0]; dst[2] = src[2]; dst[0] = src[0];
dst[4] = src[8]; dst[6] = src[10]; dst[2] = src[2];
dst[8] = src[16]; dst[10] = src[18]; dst[4] = src[8];
dst[12] = src[24]; dst[14] = src[26]; dst[6] = src[10];
dst[16] = src[4]; dst[18] = src[6]; dst[8] = src[16];
dst[20] = src[12]; dst[22] = src[14]; dst[10] = src[18];
dst[24] = src[20]; dst[26] = src[22]; dst[12] = src[24];
dst[28] = src[28]; dst[30] = src[30]; dst[14] = src[26];
dst[16] = src[4];
dst[18] = src[6];
dst[20] = src[12];
dst[22] = src[14];
dst[24] = src[20];
dst[26] = src[22];
dst[28] = src[28];
dst[30] = src[30];
} }
void __fastcall WriteCLUT_T32_I4_CSM1_c(u32* vm, u32* clut) void __fastcall WriteCLUT_T32_I4_CSM1_c(u32* vm, u32* clut)
@ -644,10 +663,12 @@ void __fastcall WriteCLUT_T32_I4_CSM1_c(u32* vm, u32* clut)
dst[7] = src[7]; dst[7] = src[7];
} }
void SSE2_UnswizzleZ16Target( u16* dst, u16* src, int iters ) { void SSE2_UnswizzleZ16Target(u16* dst, u16* src, int iters)
{
#if defined(_MSC_VER) #if defined(_MSC_VER)
__asm { __asm
{
mov edx, iters mov edx, iters
pxor xmm7, xmm7 pxor xmm7, xmm7
mov eax, dst mov eax, dst
@ -698,51 +719,52 @@ Z16Loop:
#else // _MSC_VER #else // _MSC_VER
__asm__(".intel_syntax\n" __asm__(".intel_syntax\n"
"pxor %%xmm7, %%xmm7\n" "pxor %%xmm7, %%xmm7\n"
"Z16Loop:\n" "Z16Loop:\n"
// unpack 64 bytes at a time // unpack 64 bytes at a time
"movdqa %%xmm0, [%0]\n" "movdqa %%xmm0, [%0]\n"
"movdqa %%xmm2, [%0+16]\n" "movdqa %%xmm2, [%0+16]\n"
"movdqa %%xmm4, [%0+32]\n" "movdqa %%xmm4, [%0+32]\n"
"movdqa %%xmm6, [%0+48]\n" "movdqa %%xmm6, [%0+48]\n"
"movdqa %%xmm1, %%xmm0\n" "movdqa %%xmm1, %%xmm0\n"
"movdqa %%xmm3, %%xmm2\n" "movdqa %%xmm3, %%xmm2\n"
"movdqa %%xmm5, %%xmm4\n" "movdqa %%xmm5, %%xmm4\n"
"punpcklwd %%xmm0, %%xmm7\n" "punpcklwd %%xmm0, %%xmm7\n"
"punpckhwd %%xmm1, %%xmm7\n" "punpckhwd %%xmm1, %%xmm7\n"
"punpcklwd %%xmm2, %%xmm7\n" "punpcklwd %%xmm2, %%xmm7\n"
"punpckhwd %%xmm3, %%xmm7\n" "punpckhwd %%xmm3, %%xmm7\n"
// start saving // start saving
"movdqa [%1], %%xmm0\n" "movdqa [%1], %%xmm0\n"
"movdqa [%1+16], %%xmm1\n" "movdqa [%1+16], %%xmm1\n"
"punpcklwd %%xmm4, %%xmm7\n" "punpcklwd %%xmm4, %%xmm7\n"
"punpckhwd %%xmm5, %%xmm7\n" "punpckhwd %%xmm5, %%xmm7\n"
"movdqa [%1+32], %%xmm2\n" "movdqa [%1+32], %%xmm2\n"
"movdqa [%1+48], %%xmm3\n" "movdqa [%1+48], %%xmm3\n"
"movdqa %%xmm0, %%xmm6\n" "movdqa %%xmm0, %%xmm6\n"
"punpcklwd %%xmm6, %%xmm7\n" "punpcklwd %%xmm6, %%xmm7\n"
"movdqa [%1+64], %%xmm4\n" "movdqa [%1+64], %%xmm4\n"
"movdqa [%1+80], %%xmm5\n" "movdqa [%1+80], %%xmm5\n"
"punpckhwd %%xmm0, %%xmm7\n" "punpckhwd %%xmm0, %%xmm7\n"
"movdqa [%1+96], %%xmm6\n" "movdqa [%1+96], %%xmm6\n"
"movdqa [%1+112], %%xmm0\n" "movdqa [%1+112], %%xmm0\n"
"add %0, 64\n" "add %0, 64\n"
"add %1, 128\n" "add %1, 128\n"
"sub %2, 1\n" "sub %2, 1\n"
"jne Z16Loop\n" "jne Z16Loop\n"
".att_syntax\n" : "=r"(src), "=r"(dst), "=r"(iters) : "0"(src), "1"(dst), "2"(iters)
); ".att_syntax\n" : "=r"(src), "=r"(dst), "=r"(iters) : "0"(src), "1"(dst), "2"(iters)
);
#endif // _MSC_VER #endif // _MSC_VER
} }

503
plugins/zzogl-pg/opengl/zerogs.cpp
View File

File diff suppressed because it is too large Load Diff

6
plugins/zzogl-pg/opengl/zerogsmath.h
View File

@ -59,6 +59,12 @@ public:
inline void Set3(const float* pvals) { x = pvals[0]; y = pvals[1]; z = pvals[2]; } inline void Set3(const float* pvals) { x = pvals[0]; y = pvals[1]; z = pvals[2]; }
inline void Set4(const float* pvals) { x = pvals[0]; y = pvals[1]; z = pvals[2]; w = pvals[3]; } inline void Set4(const float* pvals) { x = pvals[0]; y = pvals[1]; z = pvals[2]; w = pvals[3]; }
inline void SetColor(u32 color)
{
x = (color & 0xff) / 255.0f;
y = ((color >> 8) & 0xff) / 255.0f;
z = ((color >> 16) & 0xff) / 255.0f;
}
// 3 dim cross product, w is not touched // 3 dim cross product, w is not touched
/// this = this x v /// this = this x v

74
plugins/zzogl-pg/opengl/zpipe.cpp
View File

@ -25,23 +25,28 @@ int def(char *src, char *dst, int bytes_to_compress, int *bytes_after_compressed
strm.zfree = Z_NULL; strm.zfree = Z_NULL;
strm.opaque = Z_NULL; strm.opaque = Z_NULL;
ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION) ; ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION) ;
if (ret != Z_OK) if (ret != Z_OK)
return ret; return ret;
/* compress */ /* compress */
strm.avail_in = bytes_to_compress ; strm.avail_in = bytes_to_compress ;
strm.avail_out = bytes_to_compress ; strm.avail_out = bytes_to_compress ;
strm.next_in = (Bytef *)src ; strm.next_in = (Bytef *)src ;
strm.next_out = (Bytef *)dst ; strm.next_out = (Bytef *)dst ;
ret = deflate(&strm, Z_FINISH) ; ret = deflate(&strm, Z_FINISH) ;
have = bytes_to_compress - strm.avail_out ; have = bytes_to_compress - strm.avail_out ;
*bytes_after_compressed = have ; *bytes_after_compressed = have ;
assert(ret == Z_STREAM_END); /* stream will be complete */ assert(ret == Z_STREAM_END); /* stream will be complete */
/* clean up and return */ /* clean up and return */
(void)deflateEnd(&strm); (void)deflateEnd(&strm);
return Z_OK; return Z_OK;
} }
@ -59,8 +64,8 @@ int inf(char *src, char *dst, int bytes_to_decompress, int maximum_after_decompr
strm.avail_in = 0; strm.avail_in = 0;
strm.next_in = Z_NULL; strm.next_in = Z_NULL;
ret = inflateInit(&strm); ret = inflateInit(&strm);
if (ret != Z_OK)
return ret; if (ret != Z_OK) return ret;
/* decompress */ /* decompress */
strm.avail_in = bytes_to_decompress ; strm.avail_in = bytes_to_decompress ;
@ -69,23 +74,29 @@ int inf(char *src, char *dst, int bytes_to_decompress, int maximum_after_decompr
strm.avail_out = maximum_after_decompress ; strm.avail_out = maximum_after_decompress ;
ret = inflate(&strm, Z_NO_FLUSH) ; ret = inflate(&strm, Z_NO_FLUSH) ;
assert(ret != Z_STREAM_ERROR); /* state not clobbered */ assert(ret != Z_STREAM_ERROR); /* state not clobbered */
switch (ret) {
case Z_NEED_DICT: switch (ret)
ret = Z_DATA_ERROR; /* and fall through */ {
case Z_DATA_ERROR:
case Z_MEM_ERROR: case Z_NEED_DICT:
(void)inflateEnd(&strm); ret = Z_DATA_ERROR; /* and fall through */
return ret;
case Z_DATA_ERROR:
case Z_MEM_ERROR:
(void)inflateEnd(&strm);
return ret;
} }
assert(strm.avail_in == 0); /* all input will be used */ assert(strm.avail_in == 0); /* all input will be used */
if( outbytes != NULL ) if (outbytes != NULL) *outbytes = strm.total_out;
*outbytes = strm.total_out;
/* clean up and return */ /* clean up and return */
(void)inflateEnd(&strm); (void)inflateEnd(&strm);
return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR; return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
} }
@ -93,23 +104,28 @@ int inf(char *src, char *dst, int bytes_to_decompress, int maximum_after_decompr
void zerr(int ret) void zerr(int ret)
{ {
fputs("zpipe: ", stderr); fputs("zpipe: ", stderr);
switch (ret) {
case Z_ERRNO: switch (ret)
if (ferror(stdin)) {
fputs("error reading stdin\n", stderr);
if (ferror(stdout)) case Z_ERRNO:
fputs("error writing stdout\n", stderr); if (ferror(stdin)) fputs("error reading stdin\n", stderr);
break; if (ferror(stdout)) fputs("error writing stdout\n", stderr);
case Z_STREAM_ERROR: break;
fputs("invalid compression level\n", stderr);
break; case Z_STREAM_ERROR:
case Z_DATA_ERROR: fputs("invalid compression level\n", stderr);
fputs("invalid or incomplete deflate data\n", stderr); break;
break;
case Z_MEM_ERROR: case Z_DATA_ERROR:
fputs("out of memory\n", stderr); fputs("invalid or incomplete deflate data\n", stderr);
break; break;
case Z_VERSION_ERROR:
fputs("zlib version mismatch!\n", stderr); case Z_MEM_ERROR:
fputs("out of memory\n", stderr);
break;
case Z_VERSION_ERROR:
fputs("zlib version mismatch!\n", stderr);
} }
} }