2010-03-19 00:31:15 +00:00
|
|
|
/* ZZ Open GL graphics plugin
|
2010-07-10 08:20:50 +00:00
|
|
|
* Copyright (c)2009-2010 zeydlitz@gmail.com, arcum42@gmail.com
|
|
|
|
* Based on Zerofrog's ZeroGS KOSMOS (c)2005-2008
|
2010-03-19 00:31:15 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2010-07-04 22:49:00 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
2010-03-19 00:31:15 +00:00
|
|
|
*/
|
|
|
|
|
2010-04-25 00:31:27 +00:00
|
|
|
// Create and Destroy function. They would be called once per session.
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
//------------------ Includes
|
|
|
|
#include "GS.h"
|
|
|
|
#include "Mem.h"
|
2010-09-01 10:28:37 +00:00
|
|
|
#include "GLWin.h"
|
2010-09-15 16:54:19 +00:00
|
|
|
#include "ZZoglShaders.h"
|
2010-10-17 09:07:16 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
#include "targets.h"
|
2010-10-17 08:47:31 +00:00
|
|
|
#include "rasterfont.h" // simple font
|
2010-11-23 03:35:01 +00:00
|
|
|
#include "ZZoglDrawing.h"
|
2010-10-23 08:15:39 +00:00
|
|
|
#include "ZZoglVB.h"
|
2010-10-17 08:47:31 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
// This include for windows resource file with Shaders
|
|
|
|
#ifdef _WIN32
|
|
|
|
# include "Win32.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// ----------------- Types
|
2010-05-01 20:33:53 +00:00
|
|
|
typedef void (APIENTRYP _PFNSWAPINTERVAL)(int);
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
map<string, GLbyte> mapGLExtensions;
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
extern bool LoadEffects();
|
2010-09-19 08:01:48 +00:00
|
|
|
extern bool ZZshLoadExtraEffects();
|
|
|
|
extern FRAGMENTSHADER* ZZshLoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
GLuint vboRect = 0;
|
2012-04-19 21:22:08 +00:00
|
|
|
GLuint g_vboBuffers[VB_NUMBUFFERS]; // VBOs for all drawing commands
|
|
|
|
u32 g_nCurVBOIndex = 0;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
inline bool CreateImportantCheck();
|
|
|
|
inline void CreateOtherCheck();
|
|
|
|
inline bool CreateOpenShadersFile();
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-10-18 11:24:40 +00:00
|
|
|
void ZZGSStateReset();
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
//------------------ Dummies
|
|
|
|
#ifdef _WIN32
|
2010-05-01 20:33:53 +00:00
|
|
|
void __stdcall glBlendFuncSeparateDummy(GLenum e1, GLenum e2, GLenum e3, GLenum e4)
|
2010-03-19 00:31:15 +00:00
|
|
|
#else
|
2010-05-01 20:33:53 +00:00
|
|
|
void APIENTRY glBlendFuncSeparateDummy(GLenum e1, GLenum e2, GLenum e3, GLenum e4)
|
2010-03-19 00:31:15 +00:00
|
|
|
#endif
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
|
|
|
glBlendFunc(e1, e2);
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
2010-05-01 20:33:53 +00:00
|
|
|
void __stdcall glBlendEquationSeparateDummy(GLenum e1, GLenum e2)
|
2010-03-19 00:31:15 +00:00
|
|
|
#else
|
2010-05-01 20:33:53 +00:00
|
|
|
void APIENTRY glBlendEquationSeparateDummy(GLenum e1, GLenum e2)
|
2010-03-19 00:31:15 +00:00
|
|
|
#endif
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
|
|
|
glBlendEquation(e1);
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
2010-05-01 20:33:53 +00:00
|
|
|
extern HINSTANCE hInst;
|
|
|
|
void (__stdcall *zgsBlendEquationSeparateEXT)(GLenum, GLenum) = NULL;
|
|
|
|
void (__stdcall *zgsBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL;
|
2010-03-19 00:31:15 +00:00
|
|
|
#else
|
2010-05-01 20:33:53 +00:00
|
|
|
void (APIENTRY *zgsBlendEquationSeparateEXT)(GLenum, GLenum) = NULL;
|
|
|
|
void (APIENTRY *zgsBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL;
|
2010-03-19 00:31:15 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
//------------------ variables
|
|
|
|
////////////////////////////
|
|
|
|
// State parameters
|
|
|
|
|
2010-07-03 07:57:56 +00:00
|
|
|
extern u8* s_lpShaderResources;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-04-25 07:21:29 +00:00
|
|
|
// String's for shader file in developer mode
|
2012-04-19 21:22:08 +00:00
|
|
|
//#ifdef ZEROGS_DEVBUILD
|
2010-05-01 20:33:53 +00:00
|
|
|
char* EFFECT_NAME = "";
|
|
|
|
char* EFFECT_DIR = "";
|
2012-04-19 21:22:08 +00:00
|
|
|
//#endif
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
/////////////////////
|
|
|
|
// graphics resources
|
|
|
|
GLenum s_srcrgb, s_dstrgb, s_srcalpha, s_dstalpha; // set by zgsBlendFuncSeparateEXT
|
|
|
|
u32 s_stencilfunc, s_stencilref, s_stencilmask;
|
|
|
|
GLenum s_drawbuffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT };
|
|
|
|
|
|
|
|
GLenum g_internalFloatFmt = GL_ALPHA_FLOAT32_ATI;
|
|
|
|
GLenum g_internalRGBAFloatFmt = GL_RGBA_FLOAT32_ATI;
|
|
|
|
GLenum g_internalRGBAFloat16Fmt = GL_RGBA_FLOAT16_ATI;
|
|
|
|
|
|
|
|
u32 ptexLogo = 0;
|
|
|
|
int nLogoWidth, nLogoHeight;
|
|
|
|
u32 s_ptexInterlace = 0; // holds interlace fields
|
2012-04-19 21:22:08 +00:00
|
|
|
static bool vb_buffer_allocated = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-04-25 00:31:27 +00:00
|
|
|
//------------------ Global Variables
|
2010-09-15 16:54:19 +00:00
|
|
|
int GPU_TEXWIDTH = 512;
|
|
|
|
float g_fiGPU_TEXWIDTH = 1/512.0f;
|
2010-03-19 00:31:15 +00:00
|
|
|
int g_MaxTexWidth = 4096, g_MaxTexHeight = 4096;
|
2012-04-19 21:22:08 +00:00
|
|
|
|
|
|
|
namespace FB
|
|
|
|
{
|
|
|
|
u32 buf = 0;
|
|
|
|
};
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
RasterFont* font_p = NULL;
|
|
|
|
float g_fBlockMult = 1;
|
2010-07-03 07:57:56 +00:00
|
|
|
//int s_nFullscreen = 0;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
u32 ptexBlocks = 0, ptexConv16to32 = 0; // holds information on block tiling
|
|
|
|
u32 ptexBilinearBlocks = 0;
|
|
|
|
u32 ptexConv32to16 = 0;
|
2012-04-19 21:22:08 +00:00
|
|
|
// int g_nDepthBias = 0;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-10-17 09:07:16 +00:00
|
|
|
extern void Delete_Avi_Capture();
|
2010-10-18 11:24:40 +00:00
|
|
|
extern void ZZDestroy();
|
|
|
|
extern void SetAA(int mode);
|
2010-10-17 09:07:16 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
//------------------ Code
|
|
|
|
|
2010-10-18 11:24:40 +00:00
|
|
|
///< returns true if the the opengl extension is supported
|
2010-10-16 11:54:46 +00:00
|
|
|
bool IsGLExt(const char* szTargetExtension)
|
2010-03-19 00:31:15 +00:00
|
|
|
{
|
|
|
|
return mapGLExtensions.find(string(szTargetExtension)) != mapGLExtensions.end();
|
|
|
|
}
|
|
|
|
|
2010-04-25 07:21:29 +00:00
|
|
|
// Function asks about different OGL extensions, that are required to setup accordingly. Return false if checks failed
|
2010-10-16 11:54:46 +00:00
|
|
|
inline bool CreateImportantCheck()
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
bool bSuccess = true;
|
|
|
|
#ifndef _WIN32
|
|
|
|
int const glew_ok = glewInit();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2012-04-29 18:50:07 +00:00
|
|
|
if (glew_ok != GLEW_OK) {
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("glewInit() is not ok!");
|
2010-03-19 00:31:15 +00:00
|
|
|
bSuccess = false;
|
2012-04-29 18:50:07 +00:00
|
|
|
} else {
|
|
|
|
const GLubyte* gl_version = glGetString(GL_VERSION);
|
|
|
|
ZZLog::Error_Log("Supported Opengl version : %s\n", gl_version);
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
#endif
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (!IsGLExt("GL_EXT_framebuffer_object"))
|
|
|
|
{
|
2010-12-20 19:57:50 +00:00
|
|
|
ZZLog::Error_Log("*********\nZZogl: ERROR: Need GL_EXT_framebuffer_object for multiple render targets\nZZogl: *********");
|
2010-03-19 00:31:15 +00:00
|
|
|
bSuccess = false;
|
|
|
|
}
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (!IsGLExt("GL_EXT_secondary_color"))
|
|
|
|
{
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_secondary_color\nZZogl: *********");
|
2010-03-19 00:31:15 +00:00
|
|
|
bSuccess = false;
|
|
|
|
}
|
2010-09-15 16:54:19 +00:00
|
|
|
|
|
|
|
bSuccess &= ZZshCheckProfilesSupport();
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
return bSuccess;
|
|
|
|
}
|
2010-04-25 00:31:27 +00:00
|
|
|
|
2010-04-25 07:21:29 +00:00
|
|
|
// This is a check for less important open gl extensions.
|
2010-10-16 11:54:46 +00:00
|
|
|
inline void CreateOtherCheck()
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
|
|
|
if (!IsGLExt("GL_EXT_blend_equation_separate") || glBlendEquationSeparateEXT == NULL)
|
|
|
|
{
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_blend_equation_separate\nZZogl: *********");
|
2010-03-19 00:31:15 +00:00
|
|
|
zgsBlendEquationSeparateEXT = glBlendEquationSeparateDummy;
|
|
|
|
}
|
2010-04-25 00:31:27 +00:00
|
|
|
else
|
2010-03-19 00:31:15 +00:00
|
|
|
zgsBlendEquationSeparateEXT = glBlendEquationSeparateEXT;
|
2010-04-25 00:31:27 +00:00
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (!IsGLExt("GL_EXT_blend_func_separate") || glBlendFuncSeparateEXT == NULL)
|
|
|
|
{
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: Need GL_EXT_blend_func_separate\nZZogl: *********");
|
2010-03-19 00:31:15 +00:00
|
|
|
zgsBlendFuncSeparateEXT = glBlendFuncSeparateDummy;
|
|
|
|
}
|
2010-04-25 00:31:27 +00:00
|
|
|
else
|
2010-03-19 00:31:15 +00:00
|
|
|
zgsBlendFuncSeparateEXT = glBlendFuncSeparateEXT;
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (!IsGLExt("GL_ARB_draw_buffers") && !IsGLExt("GL_ATI_draw_buffers"))
|
|
|
|
{
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("*********\nZZogl: OGL WARNING: multiple render targets not supported, some effects might look bad\nZZogl: *********");
|
2010-03-19 00:31:15 +00:00
|
|
|
conf.mrtdepth = 0;
|
|
|
|
}
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (IsGLExt("GL_ARB_draw_buffers"))
|
2010-03-19 00:31:15 +00:00
|
|
|
glDrawBuffers = (PFNGLDRAWBUFFERSPROC)wglGetProcAddress("glDrawBuffers");
|
2010-05-01 20:33:53 +00:00
|
|
|
else if (IsGLExt("GL_ATI_draw_buffers"))
|
2010-03-19 00:31:15 +00:00
|
|
|
glDrawBuffers = (PFNGLDRAWBUFFERSPROC)wglGetProcAddress("glDrawBuffersATI");
|
|
|
|
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (!IsGLExt("GL_ARB_multitexture"))
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("No multitexturing.");
|
2010-03-19 00:31:15 +00:00
|
|
|
else
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("Using multitexturing.");
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GLint Max_Texture_Size_NV = 0;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
GLint Max_Texture_Size_2d = 0;
|
|
|
|
|
|
|
|
glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, &Max_Texture_Size_NV);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &Max_Texture_Size_2d);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("Maximum texture size is %d for Tex_2d and %d for Tex_NV.", Max_Texture_Size_2d, Max_Texture_Size_NV);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
if (Max_Texture_Size_NV < 1024)
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("Could not properly make bitmasks, so some textures will be missed.");
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
2010-05-01 20:33:53 +00:00
|
|
|
if (IsGLExt("WGL_EXT_swap_control") || IsGLExt("EXT_swap_control"))
|
2010-03-19 00:31:15 +00:00
|
|
|
wglSwapIntervalEXT(0);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
#else
|
2010-05-01 20:33:53 +00:00
|
|
|
if (IsGLExt("GLX_SGI_swap_control"))
|
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
_PFNSWAPINTERVAL swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapInterval");
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (!swapinterval)
|
2010-03-19 00:31:15 +00:00
|
|
|
swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapIntervalSGI");
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (!swapinterval)
|
2010-03-19 00:31:15 +00:00
|
|
|
swapinterval = (_PFNSWAPINTERVAL)wglGetProcAddress("glXSwapIntervalEXT");
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (swapinterval)
|
2010-03-19 00:31:15 +00:00
|
|
|
swapinterval(0);
|
|
|
|
else
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("No support for SwapInterval (framerate clamped to monitor refresh rate),");
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-10 11:15:48 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
__forceinline bool LoadShadersFromRes()
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
HRSRC hShaderSrc = FindResource(hInst, MAKEINTRESOURCE(IDR_SHADERS), RT_RCDATA);
|
2010-05-01 20:33:53 +00:00
|
|
|
assert(hShaderSrc != NULL);
|
2010-03-19 00:31:15 +00:00
|
|
|
HGLOBAL hShaderGlob = LoadResource(hInst, hShaderSrc);
|
2010-05-01 20:33:53 +00:00
|
|
|
assert(hShaderGlob != NULL);
|
2010-03-19 00:31:15 +00:00
|
|
|
s_lpShaderResources = (u8*)LockResource(hShaderGlob);
|
2010-11-10 11:15:48 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
|
|
|
|
__forceinline bool LoadShadersFromDat()
|
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
FILE* fres = fopen("ps2hw.dat", "rb");
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (fres == NULL)
|
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
fres = fopen("plugins/ps2hw.dat", "rb");
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (fres == NULL)
|
|
|
|
{
|
2011-07-17 11:25:17 +00:00
|
|
|
// Each linux distributions have his rules for path so we give them the possibility to
|
|
|
|
// change it with compilation flags. -- Gregory
|
|
|
|
#ifdef PLUGIN_DIR_COMPILATION
|
|
|
|
#define xPLUGIN_DIR_str(s) PLUGIN_DIR_str(s)
|
|
|
|
#define PLUGIN_DIR_str(s) #s
|
2011-07-19 18:33:22 +00:00
|
|
|
const std::string shader_file = string(xPLUGIN_DIR_str(PLUGIN_DIR_COMPILATION)) + "/ps2hw.dat";
|
|
|
|
fres = fopen(shader_file.c_str(), "rb");
|
2011-07-17 11:25:17 +00:00
|
|
|
#endif
|
|
|
|
if (fres == NULL)
|
|
|
|
{
|
|
|
|
ZZLog::Error_Log("Cannot find ps2hw.dat in working directory. Exiting.");
|
|
|
|
return false;
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
fseek(fres, 0, SEEK_END);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
size_t s = ftell(fres);
|
|
|
|
s_lpShaderResources = new u8[s+1];
|
|
|
|
fseek(fres, 0, SEEK_SET);
|
|
|
|
fread(s_lpShaderResources, s, 1, fres);
|
|
|
|
s_lpShaderResources[s] = 0;
|
2010-11-10 11:15:48 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-11-24 04:45:24 +00:00
|
|
|
#ifdef DEVBUILD
|
2010-11-10 11:15:48 +00:00
|
|
|
__forceinline bool LoadShadersFromFX()
|
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
// test if ps2hw.fx exists
|
|
|
|
char tempstr[255];
|
|
|
|
char curwd[255];
|
2010-11-07 05:51:54 +00:00
|
|
|
getcwd(curwd, ArraySize(curwd));
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
strcpy(tempstr, "/plugins/");
|
|
|
|
sprintf(EFFECT_NAME, "%sps2hw.fx", tempstr);
|
|
|
|
FILE* f = fopen(EFFECT_NAME, "r");
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (f == NULL)
|
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-03-19 01:00:53 +00:00
|
|
|
strcpy(tempstr, "../../plugins/zzogl-pg/opengl/");
|
2010-03-19 00:31:15 +00:00
|
|
|
sprintf(EFFECT_NAME, "%sps2hw.fx", tempstr);
|
|
|
|
f = fopen(EFFECT_NAME, "r");
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (f == NULL)
|
|
|
|
{
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("Failed to find %s, try compiling a non-devbuild.", EFFECT_NAME);
|
2010-03-19 00:31:15 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
sprintf(EFFECT_DIR, "%s/%s", curwd, tempstr);
|
|
|
|
sprintf(EFFECT_NAME, "%sps2hw.fx", EFFECT_DIR);
|
2010-11-10 11:15:48 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
2010-11-24 04:45:24 +00:00
|
|
|
#endif
|
2010-11-10 11:15:48 +00:00
|
|
|
|
|
|
|
|
|
|
|
// open shader file according to build target
|
|
|
|
|
|
|
|
inline bool CreateOpenShadersFile()
|
|
|
|
{
|
|
|
|
#ifndef DEVBUILD
|
|
|
|
# ifdef _WIN32
|
|
|
|
return LoadShadersFromRes();
|
|
|
|
# else // not _WIN32
|
|
|
|
return LoadShadersFromDat();
|
|
|
|
# endif // _WIN32
|
|
|
|
#else // defined(ZEROGS_DEVBUILD)
|
|
|
|
# ifndef _WIN32 // NOT WINDOWS
|
|
|
|
return LoadShadersFromFX();
|
|
|
|
|
|
|
|
// No else clause?
|
2010-05-01 20:33:53 +00:00
|
|
|
#endif
|
2010-04-25 09:02:36 +00:00
|
|
|
#endif // !defined(ZEROGS_DEVBUILD)
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read all extensions name and fill mapGLExtensions
|
2010-05-01 20:33:53 +00:00
|
|
|
inline bool CreateFillExtensionsMap()
|
|
|
|
{
|
2011-01-09 17:19:41 +00:00
|
|
|
int max_ext = 0;
|
|
|
|
string all_ext("");
|
2011-01-09 06:21:47 +00:00
|
|
|
|
2010-11-10 11:15:48 +00:00
|
|
|
PFNGLGETSTRINGIPROC glGetStringi = 0;
|
|
|
|
glGetStringi = (PFNGLGETSTRINGIPROC)wglGetProcAddress("glGetStringi");
|
2011-06-12 14:48:36 +00:00
|
|
|
glGetIntegerv(GL_NUM_EXTENSIONS, &max_ext);
|
2011-01-09 17:19:41 +00:00
|
|
|
|
2011-06-12 14:48:36 +00:00
|
|
|
if (glGetStringi && max_ext) {
|
2011-01-09 17:19:41 +00:00
|
|
|
// Get opengl extension (opengl3)
|
|
|
|
for (GLint i = 0; i < max_ext; i++)
|
|
|
|
{
|
|
|
|
string extension((const char*)glGetStringi(GL_EXTENSIONS, i));
|
|
|
|
mapGLExtensions[extension];
|
|
|
|
|
|
|
|
all_ext += extension;
|
|
|
|
if (i != (max_ext - 1)) all_ext += ", ";
|
|
|
|
}
|
|
|
|
} else {
|
2011-06-12 14:48:36 +00:00
|
|
|
// fallback to old method (pre opengl3, intel gma, geforce 7 ...)
|
2011-01-09 17:19:41 +00:00
|
|
|
ZZLog::Error_Log("glGetStringi opengl 3 interface not supported, fallback to opengl 2");
|
|
|
|
|
|
|
|
const char* ptoken = (const char*)glGetString(GL_EXTENSIONS);
|
|
|
|
if (ptoken == NULL) return false;
|
|
|
|
|
2011-06-12 14:48:36 +00:00
|
|
|
all_ext = string(ptoken); // save the string to print a nice debug message
|
|
|
|
|
2011-01-09 17:19:41 +00:00
|
|
|
const char* pend = NULL;
|
|
|
|
while (ptoken != NULL)
|
|
|
|
{
|
|
|
|
pend = strchr(ptoken, ' ');
|
|
|
|
|
|
|
|
if (pend != NULL)
|
|
|
|
{
|
|
|
|
max_ext++;
|
|
|
|
mapGLExtensions[string(ptoken, pend-ptoken)];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
max_ext++;
|
|
|
|
mapGLExtensions[string(ptoken)];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptoken = pend;
|
|
|
|
while (*ptoken == ' ') ++ptoken;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-09 06:21:47 +00:00
|
|
|
#ifndef _DEBUG
|
2011-01-09 17:19:41 +00:00
|
|
|
ZZLog::Log("%d supported OpenGL Extensions: %s\n", max_ext, all_ext.c_str());
|
2011-01-09 06:21:47 +00:00
|
|
|
#endif
|
2011-01-09 17:19:41 +00:00
|
|
|
ZZLog::Debug_Log("%d supported OpenGL Extensions: %s\n", max_ext, all_ext.c_str());
|
2011-01-09 06:21:47 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-06-19 05:41:06 +00:00
|
|
|
void LoadglFunctions()
|
|
|
|
{
|
|
|
|
GL_LOADFN(glIsRenderbufferEXT);
|
|
|
|
GL_LOADFN(glBindRenderbufferEXT);
|
|
|
|
GL_LOADFN(glDeleteRenderbuffersEXT);
|
|
|
|
GL_LOADFN(glGenRenderbuffersEXT);
|
|
|
|
GL_LOADFN(glRenderbufferStorageEXT);
|
|
|
|
GL_LOADFN(glGetRenderbufferParameterivEXT);
|
|
|
|
GL_LOADFN(glIsFramebufferEXT);
|
|
|
|
GL_LOADFN(glBindFramebufferEXT);
|
|
|
|
GL_LOADFN(glDeleteFramebuffersEXT);
|
|
|
|
GL_LOADFN(glGenFramebuffersEXT);
|
|
|
|
GL_LOADFN(glCheckFramebufferStatusEXT);
|
|
|
|
GL_LOADFN(glFramebufferTexture1DEXT);
|
|
|
|
GL_LOADFN(glFramebufferTexture2DEXT);
|
|
|
|
GL_LOADFN(glFramebufferTexture3DEXT);
|
|
|
|
GL_LOADFN(glFramebufferRenderbufferEXT);
|
|
|
|
GL_LOADFN(glGetFramebufferAttachmentParameterivEXT);
|
|
|
|
GL_LOADFN(glGenerateMipmapEXT);
|
|
|
|
}
|
|
|
|
|
2010-09-15 16:54:19 +00:00
|
|
|
inline bool TryBlockFormat(GLint fmt, const GLvoid* vBlockData) {
|
|
|
|
g_internalFloatFmt = fmt;
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, g_internalFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_ALPHA, GL_FLOAT, vBlockData);
|
|
|
|
return (glGetError() == GL_NO_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool TryBlinearFormat(GLint fmt32, GLint fmt16, const GLvoid* vBilinearData) {
|
|
|
|
g_internalRGBAFloatFmt = fmt32;
|
|
|
|
g_internalRGBAFloat16Fmt = fmt16;
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, g_internalRGBAFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_RGBA, GL_FLOAT, vBilinearData);
|
|
|
|
return (glGetError() == GL_NO_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-16 11:54:46 +00:00
|
|
|
bool ZZCreate(int _width, int _height)
|
2010-03-19 00:31:15 +00:00
|
|
|
{
|
|
|
|
GLenum err = GL_NO_ERROR;
|
|
|
|
bool bSuccess = true;
|
|
|
|
|
2010-10-18 11:24:40 +00:00
|
|
|
ZZDestroy();
|
2010-10-16 11:54:46 +00:00
|
|
|
ZZGSStateReset();
|
2010-11-09 12:04:07 +00:00
|
|
|
|
|
|
|
if (!GLWin.DisplayWindow(_width, _height)) return false;
|
|
|
|
|
|
|
|
conf.mrtdepth = 0; // for now
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-04-25 07:21:29 +00:00
|
|
|
if (!CreateFillExtensionsMap()) return false;
|
|
|
|
if (!CreateImportantCheck()) return false;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-10-16 11:54:46 +00:00
|
|
|
CreateOtherCheck();
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
// check the max texture width and height
|
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &g_MaxTexWidth);
|
2010-08-22 10:22:07 +00:00
|
|
|
// Limit the texture size supported to 8192. We do not need bigger texture.
|
|
|
|
// Besides the following assertion is false when texture are too big.
|
|
|
|
// ZZoglFlush.cpp:2349: assert(fblockstride >= 1.0f)
|
2010-09-15 16:54:19 +00:00
|
|
|
//g_MaxTexWidth = min(8192, g_MaxTexWidth);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
g_MaxTexHeight = g_MaxTexWidth / 4;
|
2010-09-15 16:54:19 +00:00
|
|
|
GPU_TEXWIDTH = min (g_MaxTexWidth/8, 1024);
|
2010-03-19 00:31:15 +00:00
|
|
|
g_fiGPU_TEXWIDTH = 1.0f / GPU_TEXWIDTH;
|
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
// FIXME: not clean maybe re integrate the function in shader files --greg
|
|
|
|
#ifndef GLSL_API
|
2010-05-01 20:33:53 +00:00
|
|
|
if (!CreateOpenShadersFile()) return false;
|
2012-04-19 21:22:08 +00:00
|
|
|
#else
|
|
|
|
if (!ZZshCreateOpenShadersFile()) return false;
|
|
|
|
#endif
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GL_REPORT_ERROR();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
s_srcrgb = s_dstrgb = s_srcalpha = s_dstalpha = GL_ONE;
|
|
|
|
|
2010-06-19 05:41:06 +00:00
|
|
|
LoadglFunctions();
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
|
2010-03-19 00:31:15 +00:00
|
|
|
GL_REPORT_ERROR();
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
FB::Create();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
if (FB::buf == 0)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-04-25 08:33:05 +00:00
|
|
|
ZZLog::Error_Log("Failed to create the renderbuffer.");
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
2010-06-15 11:20:52 +00:00
|
|
|
GL_REPORT_ERRORD();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
FB::Bind();
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-06-19 05:41:06 +00:00
|
|
|
DrawBuffers(s_drawbuffers);
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
GL_REPORT_ERROR();
|
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-05-01 20:33:53 +00:00
|
|
|
font_p = new RasterFont();
|
2010-03-19 00:31:15 +00:00
|
|
|
GL_REPORT_ERROR();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
// init draw fns
|
2010-10-23 08:15:39 +00:00
|
|
|
//init_drawfn();
|
|
|
|
if (ZZKick != NULL) delete ZZKick;
|
|
|
|
ZZKick = new Kick;
|
2010-10-17 09:42:49 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
SetAA(conf.aa);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-06-19 08:46:40 +00:00
|
|
|
GSsetGameCRC(g_LastCRC, conf.settings()._u32);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
GL_STENCILFUNC(GL_ALWAYS, 0, 0);
|
|
|
|
|
2010-05-01 23:34:44 +00:00
|
|
|
//s_bWriteDepth = true;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GL_BLEND_ALL(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
|
2010-11-14 01:38:10 +00:00
|
|
|
glViewport(0, 0, GLWin.backbuffer.w, GLWin.backbuffer.h); // Reset The Current Viewport
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
glLoadIdentity();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
glLoadIdentity();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
glClearDepth(1.0f);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glDisable(GL_LIGHTING);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glDepthFunc(GL_LEQUAL);
|
|
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
|
|
|
|
glGenTextures(1, &ptexLogo);
|
|
|
|
glBindTexture(GL_TEXTURE_RECTANGLE_NV, ptexLogo);
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
HRSRC hBitmapSrc = FindResource(hInst, MAKEINTRESOURCE(IDB_ZEROGSLOGO), RT_BITMAP);
|
2010-05-01 20:33:53 +00:00
|
|
|
assert(hBitmapSrc != NULL);
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
HGLOBAL hBitmapGlob = LoadResource(hInst, hBitmapSrc);
|
2010-05-01 20:33:53 +00:00
|
|
|
assert(hBitmapGlob != NULL);
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
PBITMAPINFO pinfo = (PBITMAPINFO)LockResource(hBitmapGlob);
|
|
|
|
|
2010-06-20 07:33:47 +00:00
|
|
|
GLenum tempFmt = (pinfo->bmiHeader.biBitCount == 32) ? GL_RGBA : GL_RGB;
|
2010-09-16 18:07:23 +00:00
|
|
|
TextureRect(GL_RGBA, pinfo->bmiHeader.biWidth, pinfo->bmiHeader.biHeight, tempFmt, GL_UNSIGNED_BYTE, (u8*)pinfo + pinfo->bmiHeader.biSize);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
nLogoWidth = pinfo->bmiHeader.biWidth;
|
|
|
|
nLogoHeight = pinfo->bmiHeader.biHeight;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-06-19 12:59:51 +00:00
|
|
|
setRectFilters(GL_LINEAR);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
#else
|
|
|
|
#endif
|
|
|
|
|
|
|
|
GL_REPORT_ERROR();
|
|
|
|
|
|
|
|
g_nCurVBOIndex = 0;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
if (!vb_buffer_allocated) {
|
|
|
|
glGenBuffers((GLsizei)ArraySize(g_vboBuffers), g_vboBuffers);
|
|
|
|
for (int i = 0; i < ArraySize(g_vboBuffers); ++i)
|
|
|
|
{
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, g_vboBuffers[i]);
|
|
|
|
glBufferData(GL_ARRAY_BUFFER, 0x100*sizeof(VertexGPU), NULL, GL_STREAM_DRAW);
|
|
|
|
}
|
|
|
|
vb_buffer_allocated = true; // mark the buffer allocated
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GL_REPORT_ERROR();
|
2010-05-01 20:33:53 +00:00
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
// create the blocks texture
|
|
|
|
g_fBlockMult = 1;
|
2010-08-22 09:42:28 +00:00
|
|
|
bool do_not_use_billinear = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
#ifndef ZZNORMAL_MEMORY
|
|
|
|
FillAlowedPsnTable();
|
|
|
|
FillBlockTables();
|
|
|
|
#endif
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
vector<char> vBlockData, vBilinearData;
|
|
|
|
BLOCK::FillBlocks(vBlockData, vBilinearData, 1);
|
|
|
|
|
|
|
|
glGenTextures(1, &ptexBlocks);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, ptexBlocks);
|
2010-09-15 16:54:19 +00:00
|
|
|
|
|
|
|
if (TryBlockFormat(GL_RGBA32F, &vBlockData[0]))
|
|
|
|
ZZLog::Error_Log("Use GL_RGBA32F for blockdata.");
|
|
|
|
else if (TryBlockFormat(GL_ALPHA_FLOAT32_ATI, &vBlockData[0]))
|
|
|
|
ZZLog::Error_Log("Use ATI_texture_float for blockdata.");
|
|
|
|
else if (TryBlockFormat(GL_ALPHA32F_ARB, &vBlockData[0]))
|
|
|
|
ZZLog::Error_Log("Use ARB_texture_float for blockdata.");
|
|
|
|
else
|
|
|
|
{ // This case is bad. But for really old cards it could be nice.
|
|
|
|
g_fBlockMult = 65535.0f*(float)g_fiGPU_TEXWIDTH;
|
|
|
|
BLOCK::FillBlocks(vBlockData, vBilinearData, 0);
|
|
|
|
g_internalFloatFmt = GL_ALPHA16;
|
2010-08-22 09:42:28 +00:00
|
|
|
|
2010-09-15 16:54:19 +00:00
|
|
|
// We store block data on u16 rather float numbers. It's not so preciese, but ALPHA16 is OpenGL 2.0 standart
|
|
|
|
// and use only 16 bit. Old zerogs use red channel, but it does not work.
|
|
|
|
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, g_internalFloatFmt, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, GL_ALPHA, GL_UNSIGNED_SHORT, &vBlockData[0]);
|
|
|
|
if( glGetError() != GL_NO_ERROR ) {
|
|
|
|
ZZLog::Error_Log("ZZogl ERROR: could not fill blocks");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
do_not_use_billinear = true;
|
|
|
|
conf.bilinear = 0;
|
|
|
|
ZZLog::Error_Log("Using non-bilinear fill, quallity is outdated!");
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-08-22 09:42:28 +00:00
|
|
|
|
2010-06-19 12:59:51 +00:00
|
|
|
setTex2DFilters(GL_NEAREST);
|
|
|
|
setTex2DWrap(GL_REPEAT);
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-08-22 09:42:28 +00:00
|
|
|
if (!do_not_use_billinear)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-08-22 09:42:28 +00:00
|
|
|
// fill in the bilinear blocks (main variant).
|
2010-03-19 00:31:15 +00:00
|
|
|
glGenTextures(1, &ptexBilinearBlocks);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, ptexBilinearBlocks);
|
2010-09-15 16:54:19 +00:00
|
|
|
|
|
|
|
if (TryBlinearFormat(GL_RGBA32F, GL_RGBA16F, &vBilinearData[0]))
|
|
|
|
ZZLog::Error_Log("Fill bilinear blocks OK.!");
|
|
|
|
else if (TryBlinearFormat(GL_RGBA_FLOAT32_ATI, GL_RGBA_FLOAT16_ATI, &vBilinearData[0]))
|
|
|
|
ZZLog::Error_Log("Fill bilinear blocks with ATI_texture_float.");
|
|
|
|
else if (TryBlinearFormat(GL_FLOAT_RGBA32_NV, GL_FLOAT_RGBA16_NV, &vBilinearData[0]))
|
|
|
|
ZZLog::Error_Log("ZZogl Fill bilinear blocks with NVidia_float.");
|
|
|
|
else
|
|
|
|
ZZLog::Error_Log("Fill bilinear blocks failed.");
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-06-19 12:59:51 +00:00
|
|
|
setTex2DFilters(GL_NEAREST);
|
|
|
|
setTex2DWrap(GL_REPEAT);
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
float fpri = 1;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glPrioritizeTextures(1, &ptexBlocks, &fpri);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (ptexBilinearBlocks != 0) glPrioritizeTextures(1, &ptexBilinearBlocks, &fpri);
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GL_REPORT_ERROR();
|
|
|
|
|
|
|
|
// fill a simple rect
|
|
|
|
glGenBuffers(1, &vboRect);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboRect);
|
2010-04-25 00:31:27 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
vector<VertexGPU> verts(4);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
VertexGPU* pvert = &verts[0];
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-10-31 07:10:21 +00:00
|
|
|
pvert->set_xyzst(-0x7fff, 0x7fff, 0, 0, 0);
|
2010-05-01 20:33:53 +00:00
|
|
|
pvert++;
|
|
|
|
|
2010-10-31 07:10:21 +00:00
|
|
|
pvert->set_xyzst(0x7fff, 0x7fff, 0, 1, 0);
|
2010-05-01 20:33:53 +00:00
|
|
|
pvert++;
|
|
|
|
|
2010-10-31 07:10:21 +00:00
|
|
|
pvert->set_xyzst(-0x7fff, -0x7fff, 0, 0, 1);
|
2010-05-01 20:33:53 +00:00
|
|
|
pvert++;
|
|
|
|
|
2010-10-31 07:10:21 +00:00
|
|
|
pvert->set_xyzst(0x7fff, -0x7fff, 0, 1, 1);
|
2010-05-01 20:33:53 +00:00
|
|
|
pvert++;
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glBufferDataARB(GL_ARRAY_BUFFER, 4*sizeof(VertexGPU), &verts[0], GL_STATIC_DRAW);
|
|
|
|
|
2012-05-13 20:22:15 +00:00
|
|
|
// FIXME Done inside ZZoglShadersGLSL4 for the moment
|
|
|
|
// Move it later
|
|
|
|
#ifndef GLSL4_API
|
2010-03-19 00:31:15 +00:00
|
|
|
// setup the default vertex declaration
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glClientActiveTexture(GL_TEXTURE0);
|
|
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
|
|
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
|
|
|
GL_REPORT_ERROR();
|
2012-05-13 20:22:15 +00:00
|
|
|
#endif
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
// some cards don't support this
|
|
|
|
// glClientActiveTexture(GL_TEXTURE0);
|
|
|
|
// glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
// glTexCoordPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexGPU), (void*)12);
|
|
|
|
|
|
|
|
// create the conversion textures
|
|
|
|
glGenTextures(1, &ptexConv16to32);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, ptexConv16to32);
|
|
|
|
|
|
|
|
vector<u32> conv16to32data(256*256);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-11-10 11:15:48 +00:00
|
|
|
for (int i = 0; i < 256*256; ++i)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
u32 tempcol = RGBA16to32(i);
|
|
|
|
// have to flip r and b
|
2010-05-01 20:33:53 +00:00
|
|
|
conv16to32data[i] = (tempcol & 0xff00ff00) | ((tempcol & 0xff) << 16) | ((tempcol & 0xff0000) >> 16);
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-06-19 12:59:51 +00:00
|
|
|
Texture2D(4, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, &conv16to32data[0]);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-06-19 12:59:51 +00:00
|
|
|
setTex2DFilters(GL_NEAREST);
|
|
|
|
setTex2DWrap(GL_CLAMP);
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GL_REPORT_ERROR();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
vector<u32> conv32to16data(32*32*32);
|
|
|
|
|
|
|
|
glGenTextures(1, &ptexConv32to16);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glBindTexture(GL_TEXTURE_3D, ptexConv32to16);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
u32* dst = &conv32to16data[0];
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-11-10 11:15:48 +00:00
|
|
|
for (int i = 0; i < 32; ++i)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
|
|
|
for (int j = 0; j < 32; ++j)
|
|
|
|
{
|
|
|
|
for (int k = 0; k < 32; ++k)
|
|
|
|
{
|
|
|
|
u32 col = (i << 10) | (j << 5) | k;
|
|
|
|
*dst++ = ((col & 0xff) << 16) | (col & 0xff00);
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-06-19 12:59:51 +00:00
|
|
|
Texture3D(4, 32, 32, 32, GL_RGBA, GL_UNSIGNED_BYTE, &conv32to16data[0]);
|
|
|
|
setTex3DFilters(GL_NEAREST);
|
|
|
|
setTex3DWrap(GL_CLAMP);
|
2010-03-19 00:31:15 +00:00
|
|
|
GL_REPORT_ERROR();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-09-15 16:54:19 +00:00
|
|
|
if (!ZZshStartUsingShaders()) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
GL_REPORT_ERROR();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
if (err != GL_NO_ERROR) bSuccess = false;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
glDisable(GL_STENCIL_TEST);
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
|
|
|
|
GL_BLEND_ALPHA(GL_ONE, GL_ZERO);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glBlendColorEXT(0, 0, 0, 0.5f);
|
2010-04-25 00:31:27 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
|
|
|
|
// points
|
|
|
|
// This was changed in SetAA - should we be changing it back?
|
|
|
|
glPointSize(1.0f);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
// g_nDepthBias = 0;
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glEnable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
glEnable(GL_POLYGON_OFFSET_LINE);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
glPolygonOffset(0, 1);
|
|
|
|
|
|
|
|
vb[0].Init(VB_BUFFERSIZE);
|
|
|
|
vb[1].Init(VB_BUFFERSIZE);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
g_vsprog = g_psprog = sZero;
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2012-04-29 18:50:07 +00:00
|
|
|
#ifdef OGL4_LOG
|
|
|
|
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
|
|
|
|
#endif
|
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
if (glGetError() == GL_NO_ERROR)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-03-19 00:31:15 +00:00
|
|
|
return bSuccess;
|
2010-05-01 20:33:53 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-06-21 12:03:14 +00:00
|
|
|
ZZLog::Debug_Log("In final init!");
|
2010-03-19 00:31:15 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-18 11:24:40 +00:00
|
|
|
void ZZDestroy()
|
2010-03-19 00:31:15 +00:00
|
|
|
{
|
2010-07-03 07:57:56 +00:00
|
|
|
Delete_Avi_Capture();
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
g_MemTargs.Destroy();
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
s_RTs.Destroy();
|
|
|
|
s_DepthRTs.Destroy();
|
|
|
|
s_BitwiseTextures.Destroy();
|
|
|
|
|
|
|
|
SAFE_RELEASE_TEX(s_ptexInterlace);
|
|
|
|
SAFE_RELEASE_TEX(ptexBlocks);
|
|
|
|
SAFE_RELEASE_TEX(ptexBilinearBlocks);
|
|
|
|
SAFE_RELEASE_TEX(ptexConv16to32);
|
|
|
|
SAFE_RELEASE_TEX(ptexConv32to16);
|
|
|
|
|
|
|
|
vb[0].Destroy();
|
|
|
|
vb[1].Destroy();
|
|
|
|
|
2012-04-19 21:22:08 +00:00
|
|
|
if (vb_buffer_allocated)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2012-04-19 21:22:08 +00:00
|
|
|
glDeleteBuffers((GLsizei)ArraySize(g_vboBuffers), g_vboBuffers);
|
|
|
|
vb_buffer_allocated = false; // mark the buffer unallocated
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-03-19 00:31:15 +00:00
|
|
|
g_nCurVBOIndex = 0;
|
2010-09-01 10:28:37 +00:00
|
|
|
|
|
|
|
if (pvs != NULL)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-11-07 05:51:54 +00:00
|
|
|
for (int i = 0; i < ArraySize(pvs); ++i)
|
2010-09-01 10:28:37 +00:00
|
|
|
{
|
|
|
|
SAFE_RELEASE_PROG(pvs[i]);
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-09-01 10:28:37 +00:00
|
|
|
if (ppsRegular != NULL)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-11-07 05:51:54 +00:00
|
|
|
for (int i = 0; i < ArraySize(ppsRegular); ++i)
|
2010-09-01 10:28:37 +00:00
|
|
|
{
|
|
|
|
SAFE_RELEASE_PROG(ppsRegular[i].prog);
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
2010-05-01 20:33:53 +00:00
|
|
|
|
2010-09-01 10:28:37 +00:00
|
|
|
if (ppsTexture != NULL)
|
2010-05-01 20:33:53 +00:00
|
|
|
{
|
2010-11-07 05:51:54 +00:00
|
|
|
for (int i = 0; i < ArraySize(ppsTexture); ++i)
|
2010-09-01 10:28:37 +00:00
|
|
|
{
|
|
|
|
SAFE_RELEASE_PROG(ppsTexture[i].prog);
|
|
|
|
}
|
2010-03-19 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SAFE_RELEASE_PROG(pvsBitBlt.prog);
|
2010-05-01 20:33:53 +00:00
|
|
|
|
|
|
|
SAFE_RELEASE_PROG(ppsBitBlt[0].prog);
|
|
|
|
SAFE_RELEASE_PROG(ppsBitBlt[1].prog);
|
2010-03-19 00:31:15 +00:00
|
|
|
SAFE_RELEASE_PROG(ppsBitBltDepth.prog);
|
2010-05-01 20:33:53 +00:00
|
|
|
SAFE_RELEASE_PROG(ppsCRTCTarg[0].prog);
|
|
|
|
SAFE_RELEASE_PROG(ppsCRTCTarg[1].prog);
|
|
|
|
SAFE_RELEASE_PROG(ppsCRTC[0].prog);
|
|
|
|
SAFE_RELEASE_PROG(ppsCRTC[1].prog);
|
2012-04-19 21:22:08 +00:00
|
|
|
// SAFE_RELEASE_PROG(ppsCRTC24[0].prog);
|
|
|
|
// SAFE_RELEASE_PROG(ppsCRTC24[1].prog);
|
2010-03-19 00:31:15 +00:00
|
|
|
SAFE_RELEASE_PROG(ppsOne.prog);
|
|
|
|
|
2010-11-07 05:51:54 +00:00
|
|
|
safe_delete(font_p);
|
2010-03-19 00:31:15 +00:00
|
|
|
|
2010-09-01 10:28:37 +00:00
|
|
|
GLWin.ReleaseContext();
|
2010-03-19 00:31:15 +00:00
|
|
|
|
|
|
|
mapGLExtensions.clear();
|
|
|
|
}
|
|
|
|
|