mirror of https://github.com/PCSX2/pcsx2.git
gsdx-ogl-wnd:
* load extension as gl_Function instead of glFunction git-svn-id: http://pcsx2.googlecode.com/svn/branches/gsdx-ogl-wnd@5635 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
gregory.hainaut
parent
dce89ff1a0
commit
9376b26537
|
|
@ -22,72 +22,68 @@
|
|||
#include "stdafx.h"
|
||||
#include "GLLoader.h"
|
||||
|
||||
// Those are provided on gl.h on linux...
|
||||
#ifdef _WINDOWS
|
||||
PFNGLACTIVETEXTUREPROC glActiveTexture = NULL;
|
||||
PFNGLBLENDCOLORPROC glBlendColor = NULL;
|
||||
#endif
|
||||
|
||||
PFNGLATTACHSHADERPROC glAttachShader = NULL;
|
||||
PFNGLBINDBUFFERPROC glBindBuffer = NULL;
|
||||
PFNGLBINDBUFFERBASEPROC glBindBufferBase = NULL;
|
||||
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glBindFragDataLocationIndexed = NULL;
|
||||
PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer = NULL;
|
||||
PFNGLBINDPROGRAMPIPELINEPROC glBindProgramPipeline = NULL;
|
||||
PFNGLBINDSAMPLERPROC glBindSampler = NULL;
|
||||
PFNGLBINDVERTEXARRAYPROC glBindVertexArray = NULL;
|
||||
PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate = NULL;
|
||||
PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = NULL;
|
||||
PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer = NULL;
|
||||
PFNGLBUFFERDATAPROC glBufferData = NULL;
|
||||
PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus = NULL;
|
||||
PFNGLCLEARBUFFERFVPROC glClearBufferfv = NULL;
|
||||
PFNGLCLEARBUFFERIVPROC glClearBufferiv = NULL;
|
||||
PFNGLCOMPILESHADERPROC glCompileShader = NULL;
|
||||
PFNGLCOPYIMAGESUBDATANVPROC glCopyImageSubDataNV = NULL;
|
||||
PFNGLCREATEPROGRAMPROC glCreateProgram = NULL;
|
||||
PFNGLCREATESHADERPROC glCreateShader = NULL;
|
||||
PFNGLCREATESHADERPROGRAMVPROC glCreateShaderProgramv = NULL;
|
||||
PFNGLDELETEBUFFERSPROC glDeleteBuffers = NULL;
|
||||
PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers = NULL;
|
||||
PFNGLDELETEPROGRAMPROC glDeleteProgram = NULL;
|
||||
PFNGLDELETEPROGRAMPIPELINESPROC glDeleteProgramPipelines = NULL;
|
||||
PFNGLDELETESAMPLERSPROC glDeleteSamplers = NULL;
|
||||
PFNGLDELETESHADERPROC glDeleteShader = NULL;
|
||||
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays = NULL;
|
||||
PFNGLDETACHSHADERPROC glDetachShader = NULL;
|
||||
PFNGLDRAWBUFFERSPROC glDrawBuffers = NULL;
|
||||
PFNGLDRAWELEMENTSBASEVERTEXPROC glDrawElementsBaseVertex = NULL;
|
||||
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = NULL;
|
||||
PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer = NULL;
|
||||
PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D = NULL;
|
||||
PFNGLGENBUFFERSPROC glGenBuffers = NULL;
|
||||
PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers = NULL;
|
||||
PFNGLGENPROGRAMPIPELINESPROC glGenProgramPipelines = NULL;
|
||||
PFNGLGENSAMPLERSPROC glGenSamplers = NULL;
|
||||
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays = NULL;
|
||||
PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv = NULL;
|
||||
PFNGLGETDEBUGMESSAGELOGARBPROC glGetDebugMessageLogARB = NULL;
|
||||
PFNGLGETFRAGDATAINDEXPROC glGetFragDataIndex = NULL;
|
||||
PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation = NULL;
|
||||
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = NULL;
|
||||
PFNGLGETPROGRAMIVPROC glGetProgramiv = NULL;
|
||||
PFNGLGETSHADERIVPROC glGetShaderiv = NULL;
|
||||
PFNGLGETSTRINGIPROC glGetStringi = NULL;
|
||||
PFNGLISFRAMEBUFFERPROC glIsFramebuffer = NULL;
|
||||
PFNGLLINKPROGRAMPROC glLinkProgram = NULL;
|
||||
PFNGLMAPBUFFERPROC glMapBuffer = NULL;
|
||||
PFNGLMAPBUFFERRANGEPROC glMapBufferRange = NULL;
|
||||
PFNGLPROGRAMPARAMETERIPROC glProgramParameteri = NULL;
|
||||
PFNGLSAMPLERPARAMETERFPROC glSamplerParameterf = NULL;
|
||||
PFNGLSAMPLERPARAMETERIPROC glSamplerParameteri = NULL;
|
||||
PFNGLSHADERSOURCEPROC glShaderSource = NULL;
|
||||
PFNGLUNIFORM1IPROC glUniform1i = NULL;
|
||||
PFNGLUNMAPBUFFERPROC glUnmapBuffer = NULL;
|
||||
PFNGLUSEPROGRAMSTAGESPROC glUseProgramStages = NULL;
|
||||
PFNGLVERTEXATTRIBIPOINTERPROC glVertexAttribIPointer = NULL;
|
||||
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = NULL;
|
||||
PFNGLTEXSTORAGE2DPROC glTexStorage2D = NULL;
|
||||
PFNGLACTIVETEXTUREPROC gl_ActiveTexture = NULL;
|
||||
PFNGLBLENDCOLORPROC gl_BlendColor = NULL;
|
||||
PFNGLATTACHSHADERPROC gl_AttachShader = NULL;
|
||||
PFNGLBINDBUFFERPROC gl_BindBuffer = NULL;
|
||||
PFNGLBINDBUFFERBASEPROC gl_BindBufferBase = NULL;
|
||||
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC gl_BindFragDataLocationIndexed = NULL;
|
||||
PFNGLBINDFRAMEBUFFERPROC gl_BindFramebuffer = NULL;
|
||||
PFNGLBINDPROGRAMPIPELINEPROC gl_BindProgramPipeline = NULL;
|
||||
PFNGLBINDSAMPLERPROC gl_BindSampler = NULL;
|
||||
PFNGLBINDVERTEXARRAYPROC gl_BindVertexArray = NULL;
|
||||
PFNGLBLENDEQUATIONSEPARATEPROC gl_BlendEquationSeparate = NULL;
|
||||
PFNGLBLENDFUNCSEPARATEPROC gl_BlendFuncSeparate = NULL;
|
||||
PFNGLBLITFRAMEBUFFERPROC gl_BlitFramebuffer = NULL;
|
||||
PFNGLBUFFERDATAPROC gl_BufferData = NULL;
|
||||
PFNGLCHECKFRAMEBUFFERSTATUSPROC gl_CheckFramebufferStatus = NULL;
|
||||
PFNGLCLEARBUFFERFVPROC gl_ClearBufferfv = NULL;
|
||||
PFNGLCLEARBUFFERIVPROC gl_ClearBufferiv = NULL;
|
||||
PFNGLCOMPILESHADERPROC gl_CompileShader = NULL;
|
||||
PFNGLCOPYIMAGESUBDATANVPROC gl_CopyImageSubDataNV = NULL;
|
||||
PFNGLCREATEPROGRAMPROC gl_CreateProgram = NULL;
|
||||
PFNGLCREATESHADERPROC gl_CreateShader = NULL;
|
||||
PFNGLCREATESHADERPROGRAMVPROC gl_CreateShaderProgramv = NULL;
|
||||
PFNGLDELETEBUFFERSPROC gl_DeleteBuffers = NULL;
|
||||
PFNGLDELETEFRAMEBUFFERSPROC gl_DeleteFramebuffers = NULL;
|
||||
PFNGLDELETEPROGRAMPROC gl_DeleteProgram = NULL;
|
||||
PFNGLDELETEPROGRAMPIPELINESPROC gl_DeleteProgramPipelines = NULL;
|
||||
PFNGLDELETESAMPLERSPROC gl_DeleteSamplers = NULL;
|
||||
PFNGLDELETESHADERPROC gl_DeleteShader = NULL;
|
||||
PFNGLDELETEVERTEXARRAYSPROC gl_DeleteVertexArrays = NULL;
|
||||
PFNGLDETACHSHADERPROC gl_DetachShader = NULL;
|
||||
PFNGLDRAWBUFFERSPROC gl_DrawBuffers = NULL;
|
||||
PFNGLDRAWELEMENTSBASEVERTEXPROC gl_DrawElementsBaseVertex = NULL;
|
||||
PFNGLENABLEVERTEXATTRIBARRAYPROC gl_EnableVertexAttribArray = NULL;
|
||||
PFNGLFRAMEBUFFERRENDERBUFFERPROC gl_FramebufferRenderbuffer = NULL;
|
||||
PFNGLFRAMEBUFFERTEXTURE2DPROC gl_FramebufferTexture2D = NULL;
|
||||
PFNGLGENBUFFERSPROC gl_GenBuffers = NULL;
|
||||
PFNGLGENFRAMEBUFFERSPROC gl_GenFramebuffers = NULL;
|
||||
PFNGLGENPROGRAMPIPELINESPROC gl_GenProgramPipelines = NULL;
|
||||
PFNGLGENSAMPLERSPROC gl_GenSamplers = NULL;
|
||||
PFNGLGENVERTEXARRAYSPROC gl_GenVertexArrays = NULL;
|
||||
PFNGLGETBUFFERPARAMETERIVPROC gl_GetBufferParameteriv = NULL;
|
||||
PFNGLGETDEBUGMESSAGELOGARBPROC gl_GetDebugMessageLogARB = NULL;
|
||||
PFNGLGETFRAGDATAINDEXPROC gl_GetFragDataIndex = NULL;
|
||||
PFNGLGETFRAGDATALOCATIONPROC gl_GetFragDataLocation = NULL;
|
||||
PFNGLGETPROGRAMINFOLOGPROC gl_GetProgramInfoLog = NULL;
|
||||
PFNGLGETPROGRAMIVPROC gl_GetProgramiv = NULL;
|
||||
PFNGLGETSHADERIVPROC gl_GetShaderiv = NULL;
|
||||
PFNGLGETSTRINGIPROC gl_GetStringi = NULL;
|
||||
PFNGLISFRAMEBUFFERPROC gl_IsFramebuffer = NULL;
|
||||
PFNGLLINKPROGRAMPROC gl_LinkProgram = NULL;
|
||||
PFNGLMAPBUFFERPROC gl_MapBuffer = NULL;
|
||||
PFNGLMAPBUFFERRANGEPROC gl_MapBufferRange = NULL;
|
||||
PFNGLPROGRAMPARAMETERIPROC gl_ProgramParameteri = NULL;
|
||||
PFNGLSAMPLERPARAMETERFPROC gl_SamplerParameterf = NULL;
|
||||
PFNGLSAMPLERPARAMETERIPROC gl_SamplerParameteri = NULL;
|
||||
PFNGLSHADERSOURCEPROC gl_ShaderSource = NULL;
|
||||
PFNGLUNIFORM1IPROC gl_Uniform1i = NULL;
|
||||
PFNGLUNMAPBUFFERPROC gl_UnmapBuffer = NULL;
|
||||
PFNGLUSEPROGRAMSTAGESPROC gl_UseProgramStages = NULL;
|
||||
PFNGLVERTEXATTRIBIPOINTERPROC gl_VertexAttribIPointer = NULL;
|
||||
PFNGLVERTEXATTRIBPOINTERPROC gl_VertexAttribPointer = NULL;
|
||||
PFNGLTEXSTORAGE2DPROC gl_TexStorage2D = NULL;
|
||||
|
||||
namespace GLLoader {
|
||||
|
||||
|
|
@ -107,7 +103,7 @@ namespace GLLoader {
|
|||
GLuint minor_gl = s[dot+1]-'0';
|
||||
|
||||
if ( (major_gl < major) || ( major_gl == major && minor_gl < minor ) ) {
|
||||
fprintf(stderr, "OPENGL 3.3 is not supported\n");
|
||||
fprintf(stderr, "OPENGL %d.%d is not supported\n", major, minor);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -115,72 +111,68 @@ namespace GLLoader {
|
|||
}
|
||||
|
||||
void init_gl_function() {
|
||||
// Those are provided on gl.h on linux...
|
||||
#ifdef _WINDOWS
|
||||
GL_LOADFN(glActiveTexture);
|
||||
GL_LOADFN(glBlendColor);
|
||||
#endif
|
||||
|
||||
GL_LOADFN(glAttachShader);
|
||||
GL_LOADFN(glBindBuffer);
|
||||
GL_LOADFN(glBindBufferBase);
|
||||
GL_LOADFN(glBindFragDataLocationIndexed);
|
||||
GL_LOADFN(glBindFramebuffer);
|
||||
GL_LOADFN(glBindProgramPipeline);
|
||||
GL_LOADFN(glBindSampler);
|
||||
GL_LOADFN(glBindVertexArray);
|
||||
GL_LOADFN(glBlendEquationSeparate);
|
||||
GL_LOADFN(glBlendFuncSeparate);
|
||||
GL_LOADFN(glBlitFramebuffer);
|
||||
GL_LOADFN(glBufferData);
|
||||
GL_LOADFN(glCheckFramebufferStatus);
|
||||
GL_LOADFN(glClearBufferfv);
|
||||
GL_LOADFN(glClearBufferiv);
|
||||
GL_LOADFN(glCompileShader);
|
||||
GL_LOADFN(glCopyImageSubDataNV);
|
||||
GL_LOADFN(glCreateProgram);
|
||||
GL_LOADFN(glCreateShader);
|
||||
GL_LOADFN(glCreateShaderProgramv);
|
||||
GL_LOADFN(glDeleteBuffers);
|
||||
GL_LOADFN(glDeleteFramebuffers);
|
||||
GL_LOADFN(glDeleteProgram);
|
||||
GL_LOADFN(glDeleteProgramPipelines);
|
||||
GL_LOADFN(glDeleteSamplers);
|
||||
GL_LOADFN(glDeleteShader);
|
||||
GL_LOADFN(glDeleteVertexArrays);
|
||||
GL_LOADFN(glDetachShader);
|
||||
GL_LOADFN(glDrawBuffers);
|
||||
GL_LOADFN(glDrawElementsBaseVertex);
|
||||
GL_LOADFN(glEnableVertexAttribArray);
|
||||
GL_LOADFN(glFramebufferRenderbuffer);
|
||||
GL_LOADFN(glFramebufferTexture2D);
|
||||
GL_LOADFN(glGenBuffers);
|
||||
GL_LOADFN(glGenFramebuffers);
|
||||
GL_LOADFN(glGenProgramPipelines);
|
||||
GL_LOADFN(glGenSamplers);
|
||||
GL_LOADFN(glGenVertexArrays);
|
||||
GL_LOADFN(glGetBufferParameteriv);
|
||||
GL_LOADFN(glGetDebugMessageLogARB);
|
||||
GL_LOADFN(glGetFragDataIndex);
|
||||
GL_LOADFN(glGetFragDataLocation);
|
||||
GL_LOADFN(glGetProgramInfoLog);
|
||||
GL_LOADFN(glGetProgramiv);
|
||||
GL_LOADFN(glGetShaderiv);
|
||||
GL_LOADFN(glGetStringi);
|
||||
GL_LOADFN(glIsFramebuffer);
|
||||
GL_LOADFN(glLinkProgram);
|
||||
GL_LOADFN(glMapBuffer);
|
||||
GL_LOADFN(glMapBufferRange);
|
||||
GL_LOADFN(glProgramParameteri);
|
||||
GL_LOADFN(glSamplerParameterf);
|
||||
GL_LOADFN(glSamplerParameteri);
|
||||
GL_LOADFN(glShaderSource);
|
||||
GL_LOADFN(glUniform1i);
|
||||
GL_LOADFN(glUnmapBuffer);
|
||||
GL_LOADFN(glUseProgramStages);
|
||||
GL_LOADFN(glVertexAttribIPointer);
|
||||
GL_LOADFN(glVertexAttribPointer);
|
||||
GL_LOADFN(glTexStorage2D);
|
||||
GL_LOADFN(gl_ActiveTexture, glActiveTexture);
|
||||
GL_LOADFN(gl_BlendColor, glBlendColor);
|
||||
GL_LOADFN(gl_AttachShader, glAttachShader);
|
||||
GL_LOADFN(gl_BindBuffer, glBindBuffer);
|
||||
GL_LOADFN(gl_BindBufferBase, glBindBufferBase);
|
||||
GL_LOADFN(gl_BindFragDataLocationIndexed, glBindFragDataLocationIndexed);
|
||||
GL_LOADFN(gl_BindFramebuffer, glBindFramebuffer);
|
||||
GL_LOADFN(gl_BindProgramPipeline, glBindProgramPipeline);
|
||||
GL_LOADFN(gl_BindSampler, glBindSampler);
|
||||
GL_LOADFN(gl_BindVertexArray, glBindVertexArray);
|
||||
GL_LOADFN(gl_BlendEquationSeparate, glBlendEquationSeparate);
|
||||
GL_LOADFN(gl_BlendFuncSeparate, glBlendFuncSeparate);
|
||||
GL_LOADFN(gl_BlitFramebuffer, glBlitFramebuffer);
|
||||
GL_LOADFN(gl_BufferData, glBufferData);
|
||||
GL_LOADFN(gl_CheckFramebufferStatus, glCheckFramebufferStatus);
|
||||
GL_LOADFN(gl_ClearBufferfv, glClearBufferfv);
|
||||
GL_LOADFN(gl_ClearBufferiv, glClearBufferiv);
|
||||
GL_LOADFN(gl_CompileShader, glCompileShader);
|
||||
GL_LOADFN(gl_CopyImageSubDataNV, glCopyImageSubDataNV);
|
||||
GL_LOADFN(gl_CreateProgram, glCreateProgram);
|
||||
GL_LOADFN(gl_CreateShader, glCreateShader);
|
||||
GL_LOADFN(gl_CreateShaderProgramv, glCreateShaderProgramv);
|
||||
GL_LOADFN(gl_DeleteBuffers, glDeleteBuffers);
|
||||
GL_LOADFN(gl_DeleteFramebuffers, glDeleteFramebuffers);
|
||||
GL_LOADFN(gl_DeleteProgram, glDeleteProgram);
|
||||
GL_LOADFN(gl_DeleteProgramPipelines, glDeleteProgramPipelines);
|
||||
GL_LOADFN(gl_DeleteSamplers, glDeleteSamplers);
|
||||
GL_LOADFN(gl_DeleteShader, glDeleteShader);
|
||||
GL_LOADFN(gl_DeleteVertexArrays, glDeleteVertexArrays);
|
||||
GL_LOADFN(gl_DetachShader, glDetachShader);
|
||||
GL_LOADFN(gl_DrawBuffers, glDrawBuffers);
|
||||
GL_LOADFN(gl_DrawElementsBaseVertex, glDrawElementsBaseVertex);
|
||||
GL_LOADFN(gl_EnableVertexAttribArray, glEnableVertexAttribArray);
|
||||
GL_LOADFN(gl_FramebufferRenderbuffer, glFramebufferRenderbuffer);
|
||||
GL_LOADFN(gl_FramebufferTexture2D, glFramebufferTexture2D);
|
||||
GL_LOADFN(gl_GenBuffers, glGenBuffers);
|
||||
GL_LOADFN(gl_GenFramebuffers, glGenFramebuffers);
|
||||
GL_LOADFN(gl_GenProgramPipelines, glGenProgramPipelines);
|
||||
GL_LOADFN(gl_GenSamplers, glGenSamplers);
|
||||
GL_LOADFN(gl_GenVertexArrays, glGenVertexArrays);
|
||||
GL_LOADFN(gl_GetBufferParameteriv, glGetBufferParameteriv);
|
||||
GL_LOADFN(gl_GetDebugMessageLogARB, glGetDebugMessageLogARB);
|
||||
GL_LOADFN(gl_GetFragDataIndex, glGetFragDataIndex);
|
||||
GL_LOADFN(gl_GetFragDataLocation, glGetFragDataLocation);
|
||||
GL_LOADFN(gl_GetProgramInfoLog, glGetProgramInfoLog);
|
||||
GL_LOADFN(gl_GetProgramiv, glGetProgramiv);
|
||||
GL_LOADFN(gl_GetShaderiv, glGetShaderiv);
|
||||
GL_LOADFN(gl_GetStringi, glGetStringi);
|
||||
GL_LOADFN(gl_IsFramebuffer, glIsFramebuffer);
|
||||
GL_LOADFN(gl_LinkProgram, glLinkProgram);
|
||||
GL_LOADFN(gl_MapBuffer, glMapBuffer);
|
||||
GL_LOADFN(gl_MapBufferRange, glMapBufferRange);
|
||||
GL_LOADFN(gl_ProgramParameteri, glProgramParameteri);
|
||||
GL_LOADFN(gl_SamplerParameterf, glSamplerParameterf);
|
||||
GL_LOADFN(gl_SamplerParameteri, glSamplerParameteri);
|
||||
GL_LOADFN(gl_ShaderSource, glShaderSource);
|
||||
GL_LOADFN(gl_Uniform1i, glUniform1i);
|
||||
GL_LOADFN(gl_UnmapBuffer, glUnmapBuffer);
|
||||
GL_LOADFN(gl_UseProgramStages, glUseProgramStages);
|
||||
GL_LOADFN(gl_VertexAttribIPointer, glVertexAttribIPointer);
|
||||
GL_LOADFN(gl_VertexAttribPointer, glVertexAttribPointer);
|
||||
GL_LOADFN(gl_TexStorage2D, glTexStorage2D);
|
||||
}
|
||||
|
||||
bool check_gl_supported_extension() {
|
||||
|
|
@ -192,9 +184,9 @@ namespace GLLoader {
|
|||
bool found_GL_ARB_texture_storage = false;
|
||||
fprintf(stderr, "DEBUG: check_gl_supported_extension\n");
|
||||
|
||||
if (glGetStringi && max_ext) {
|
||||
if (gl_GetStringi && max_ext) {
|
||||
for (GLint i = 0; i < max_ext; i++) {
|
||||
string ext((const char*)glGetStringi(GL_EXTENSIONS, i));
|
||||
string ext((const char*)gl_GetStringi(GL_EXTENSIONS, i));
|
||||
if (ext.compare("GL_ARB_separate_shader_objects") == 0) {
|
||||
found_GL_ARB_separate_shader_objects = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,92 +28,89 @@
|
|||
#endif
|
||||
|
||||
#ifdef _WINDOWS
|
||||
#define GL_LOADFN(name) { \
|
||||
if( (*(void**)&name = (void*)wglGetProcAddress(#name)) == NULL ) { \
|
||||
fprintf(stderr,"Failed to find %s\n", #name); \
|
||||
#define GL_LOADFN(name, glName) { \
|
||||
if( (*(void**)&name = (void*)wglGetProcAddress(#glName)) == NULL ) { \
|
||||
fprintf(stderr,"Failed to find %s\n", #glName); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#ifdef EGL_API
|
||||
#define GL_LOADFN(name) { \
|
||||
if( (*(void**)&name = (void*)eglGetProcAddress(#name)) == NULL ) { \
|
||||
fprintf(stderr,"Failed to find %s\n", #name); \
|
||||
#define GL_LOADFN(name, glName) { \
|
||||
if( (*(void**)&name = (void*)eglGetProcAddress(#glName)) == NULL ) { \
|
||||
fprintf(stderr,"Failed to find %s\n", #glName); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define GL_LOADFN(name) { \
|
||||
if( (*(void**)&name = (void*)glXGetProcAddress((const GLubyte*)#name)) == NULL ) { \
|
||||
fprintf(stderr,"Failed to find %s\n", #name); \
|
||||
#define GL_LOADFN(name, glName) { \
|
||||
if( (*(void**)&name = (void*)glXGetProcAddress((const GLubyte*)#glName)) == NULL ) { \
|
||||
fprintf(stderr,"Failed to find %s\n", #glName); \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Those are provided on gl.h on linux...
|
||||
#ifdef _WINDOWS
|
||||
extern PFNGLACTIVETEXTUREPROC glActiveTexture;
|
||||
extern PFNGLBLENDCOLORPROC glBlendColor;
|
||||
#endif
|
||||
extern PFNGLATTACHSHADERPROC glAttachShader;
|
||||
extern PFNGLBINDBUFFERPROC glBindBuffer;
|
||||
extern PFNGLBINDBUFFERBASEPROC glBindBufferBase;
|
||||
extern PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glBindFragDataLocationIndexed;
|
||||
extern PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer;
|
||||
extern PFNGLBINDPROGRAMPIPELINEPROC glBindProgramPipeline;
|
||||
extern PFNGLBINDSAMPLERPROC glBindSampler;
|
||||
extern PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
|
||||
extern PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate;
|
||||
extern PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate;
|
||||
extern PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
|
||||
extern PFNGLBUFFERDATAPROC glBufferData;
|
||||
extern PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus;
|
||||
extern PFNGLCLEARBUFFERFVPROC glClearBufferfv;
|
||||
extern PFNGLCLEARBUFFERIVPROC glClearBufferiv;
|
||||
extern PFNGLCOMPILESHADERPROC glCompileShader;
|
||||
extern PFNGLCOPYIMAGESUBDATANVPROC glCopyImageSubDataNV;
|
||||
extern PFNGLCREATEPROGRAMPROC glCreateProgram;
|
||||
extern PFNGLCREATESHADERPROC glCreateShader;
|
||||
extern PFNGLCREATESHADERPROGRAMVPROC glCreateShaderProgramv;
|
||||
extern PFNGLDELETEBUFFERSPROC glDeleteBuffers;
|
||||
extern PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers;
|
||||
extern PFNGLDELETEPROGRAMPROC glDeleteProgram;
|
||||
extern PFNGLDELETEPROGRAMPIPELINESPROC glDeleteProgramPipelines;
|
||||
extern PFNGLDELETESAMPLERSPROC glDeleteSamplers;
|
||||
extern PFNGLDELETESHADERPROC glDeleteShader;
|
||||
extern PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
|
||||
extern PFNGLDETACHSHADERPROC glDetachShader;
|
||||
extern PFNGLDRAWBUFFERSPROC glDrawBuffers;
|
||||
extern PFNGLDRAWELEMENTSBASEVERTEXPROC glDrawElementsBaseVertex;
|
||||
extern PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
|
||||
extern PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer;
|
||||
extern PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D;
|
||||
extern PFNGLGENBUFFERSPROC glGenBuffers;
|
||||
extern PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
|
||||
extern PFNGLGENPROGRAMPIPELINESPROC glGenProgramPipelines;
|
||||
extern PFNGLGENSAMPLERSPROC glGenSamplers;
|
||||
extern PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
|
||||
extern PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv;
|
||||
extern PFNGLGETDEBUGMESSAGELOGARBPROC glGetDebugMessageLogARB;
|
||||
extern PFNGLGETFRAGDATAINDEXPROC glGetFragDataIndex;
|
||||
extern PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation;
|
||||
extern PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
|
||||
extern PFNGLGETPROGRAMIVPROC glGetProgramiv;
|
||||
extern PFNGLGETSHADERIVPROC glGetShaderiv;
|
||||
extern PFNGLGETSTRINGIPROC glGetStringi;
|
||||
extern PFNGLISFRAMEBUFFERPROC glIsFramebuffer;
|
||||
extern PFNGLLINKPROGRAMPROC glLinkProgram;
|
||||
extern PFNGLMAPBUFFERPROC glMapBuffer;
|
||||
extern PFNGLMAPBUFFERRANGEPROC glMapBufferRange;
|
||||
extern PFNGLPROGRAMPARAMETERIPROC glProgramParameteri;
|
||||
extern PFNGLSAMPLERPARAMETERFPROC glSamplerParameterf;
|
||||
extern PFNGLSAMPLERPARAMETERIPROC glSamplerParameteri;
|
||||
extern PFNGLSHADERSOURCEPROC glShaderSource;
|
||||
extern PFNGLUNIFORM1IPROC glUniform1i;
|
||||
extern PFNGLUNMAPBUFFERPROC glUnmapBuffer;
|
||||
extern PFNGLUSEPROGRAMSTAGESPROC glUseProgramStages;
|
||||
extern PFNGLVERTEXATTRIBIPOINTERPROC glVertexAttribIPointer;
|
||||
extern PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
|
||||
extern PFNGLTEXSTORAGE2DPROC glTexStorage2D;
|
||||
extern PFNGLACTIVETEXTUREPROC gl_ActiveTexture;
|
||||
extern PFNGLBLENDCOLORPROC gl_BlendColor;
|
||||
extern PFNGLATTACHSHADERPROC gl_AttachShader;
|
||||
extern PFNGLBINDBUFFERPROC gl_BindBuffer;
|
||||
extern PFNGLBINDBUFFERBASEPROC gl_BindBufferBase;
|
||||
extern PFNGLBINDFRAGDATALOCATIONINDEXEDPROC gl_BindFragDataLocationIndexed;
|
||||
extern PFNGLBINDFRAMEBUFFERPROC gl_BindFramebuffer;
|
||||
extern PFNGLBINDPROGRAMPIPELINEPROC gl_BindProgramPipeline;
|
||||
extern PFNGLBINDSAMPLERPROC gl_BindSampler;
|
||||
extern PFNGLBINDVERTEXARRAYPROC gl_BindVertexArray;
|
||||
extern PFNGLBLENDEQUATIONSEPARATEPROC gl_BlendEquationSeparate;
|
||||
extern PFNGLBLENDFUNCSEPARATEPROC gl_BlendFuncSeparate;
|
||||
extern PFNGLBLITFRAMEBUFFERPROC gl_BlitFramebuffer;
|
||||
extern PFNGLBUFFERDATAPROC gl_BufferData;
|
||||
extern PFNGLCHECKFRAMEBUFFERSTATUSPROC gl_CheckFramebufferStatus;
|
||||
extern PFNGLCLEARBUFFERFVPROC gl_ClearBufferfv;
|
||||
extern PFNGLCLEARBUFFERIVPROC gl_ClearBufferiv;
|
||||
extern PFNGLCOMPILESHADERPROC gl_CompileShader;
|
||||
extern PFNGLCOPYIMAGESUBDATANVPROC gl_CopyImageSubDataNV;
|
||||
extern PFNGLCREATEPROGRAMPROC gl_CreateProgram;
|
||||
extern PFNGLCREATESHADERPROC gl_CreateShader;
|
||||
extern PFNGLCREATESHADERPROGRAMVPROC gl_CreateShaderProgramv;
|
||||
extern PFNGLDELETEBUFFERSPROC gl_DeleteBuffers;
|
||||
extern PFNGLDELETEFRAMEBUFFERSPROC gl_DeleteFramebuffers;
|
||||
extern PFNGLDELETEPROGRAMPROC gl_DeleteProgram;
|
||||
extern PFNGLDELETEPROGRAMPIPELINESPROC gl_DeleteProgramPipelines;
|
||||
extern PFNGLDELETESAMPLERSPROC gl_DeleteSamplers;
|
||||
extern PFNGLDELETESHADERPROC gl_DeleteShader;
|
||||
extern PFNGLDELETEVERTEXARRAYSPROC gl_DeleteVertexArrays;
|
||||
extern PFNGLDETACHSHADERPROC gl_DetachShader;
|
||||
extern PFNGLDRAWBUFFERSPROC gl_DrawBuffers;
|
||||
extern PFNGLDRAWELEMENTSBASEVERTEXPROC gl_DrawElementsBaseVertex;
|
||||
extern PFNGLENABLEVERTEXATTRIBARRAYPROC gl_EnableVertexAttribArray;
|
||||
extern PFNGLFRAMEBUFFERRENDERBUFFERPROC gl_FramebufferRenderbuffer;
|
||||
extern PFNGLFRAMEBUFFERTEXTURE2DPROC gl_FramebufferTexture2D;
|
||||
extern PFNGLGENBUFFERSPROC gl_GenBuffers;
|
||||
extern PFNGLGENFRAMEBUFFERSPROC gl_GenFramebuffers;
|
||||
extern PFNGLGENPROGRAMPIPELINESPROC gl_GenProgramPipelines;
|
||||
extern PFNGLGENSAMPLERSPROC gl_GenSamplers;
|
||||
extern PFNGLGENVERTEXARRAYSPROC gl_GenVertexArrays;
|
||||
extern PFNGLGETBUFFERPARAMETERIVPROC gl_GetBufferParameteriv;
|
||||
extern PFNGLGETDEBUGMESSAGELOGARBPROC gl_GetDebugMessageLogARB;
|
||||
extern PFNGLGETFRAGDATAINDEXPROC gl_GetFragDataIndex;
|
||||
extern PFNGLGETFRAGDATALOCATIONPROC gl_GetFragDataLocation;
|
||||
extern PFNGLGETPROGRAMINFOLOGPROC gl_GetProgramInfoLog;
|
||||
extern PFNGLGETPROGRAMIVPROC gl_GetProgramiv;
|
||||
extern PFNGLGETSHADERIVPROC gl_GetShaderiv;
|
||||
extern PFNGLGETSTRINGIPROC gl_GetStringi;
|
||||
extern PFNGLISFRAMEBUFFERPROC gl_IsFramebuffer;
|
||||
extern PFNGLLINKPROGRAMPROC gl_LinkProgram;
|
||||
extern PFNGLMAPBUFFERPROC gl_MapBuffer;
|
||||
extern PFNGLMAPBUFFERRANGEPROC gl_MapBufferRange;
|
||||
extern PFNGLPROGRAMPARAMETERIPROC gl_ProgramParameteri;
|
||||
extern PFNGLSAMPLERPARAMETERFPROC gl_SamplerParameterf;
|
||||
extern PFNGLSAMPLERPARAMETERIPROC gl_SamplerParameteri;
|
||||
extern PFNGLSHADERSOURCEPROC gl_ShaderSource;
|
||||
extern PFNGLUNIFORM1IPROC gl_Uniform1i;
|
||||
extern PFNGLUNMAPBUFFERPROC gl_UnmapBuffer;
|
||||
extern PFNGLUSEPROGRAMSTAGESPROC gl_UseProgramStages;
|
||||
extern PFNGLVERTEXATTRIBIPOINTERPROC gl_VertexAttribIPointer;
|
||||
extern PFNGLVERTEXATTRIBPOINTERPROC gl_VertexAttribPointer;
|
||||
extern PFNGLTEXSTORAGE2DPROC gl_TexStorage2D;
|
||||
|
||||
namespace GLLoader {
|
||||
bool check_gl_version(uint32 major, uint32 minor);
|
||||
|
|
|
|||
|
|
@ -76,9 +76,9 @@ GSDeviceOGL::~GSDeviceOGL()
|
|||
// Clean m_merge_obj
|
||||
for (uint32 i = 0; i < 2; i++)
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glDeleteProgram(m_merge_obj.ps[i]);
|
||||
gl_DeleteProgram(m_merge_obj.ps[i]);
|
||||
#else
|
||||
glDeleteShader(m_merge_obj.ps[i]);
|
||||
gl_DeleteShader(m_merge_obj.ps[i]);
|
||||
#endif
|
||||
delete (m_merge_obj.cb);
|
||||
delete (m_merge_obj.bs);
|
||||
|
|
@ -86,24 +86,24 @@ GSDeviceOGL::~GSDeviceOGL()
|
|||
// Clean m_interlace
|
||||
for (uint32 i = 0; i < 2; i++)
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glDeleteProgram(m_interlace.ps[i]);
|
||||
gl_DeleteProgram(m_interlace.ps[i]);
|
||||
#else
|
||||
glDeleteShader(m_interlace.ps[i]);
|
||||
gl_DeleteShader(m_interlace.ps[i]);
|
||||
#endif
|
||||
delete (m_interlace.cb);
|
||||
|
||||
// Clean m_convert
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glDeleteProgram(m_convert.vs);
|
||||
gl_DeleteProgram(m_convert.vs);
|
||||
for (uint32 i = 0; i < 2; i++)
|
||||
glDeleteProgram(m_convert.ps[i]);
|
||||
gl_DeleteProgram(m_convert.ps[i]);
|
||||
#else
|
||||
glDeleteShader(m_convert.vs);
|
||||
gl_DeleteShader(m_convert.vs);
|
||||
for (uint i = 0; i < 2; i++)
|
||||
glDeleteShader(m_convert.ps[i]);
|
||||
gl_DeleteShader(m_convert.ps[i]);
|
||||
#endif
|
||||
glDeleteSamplers(1, &m_convert.ln);
|
||||
glDeleteSamplers(1, &m_convert.pt);
|
||||
gl_DeleteSamplers(1, &m_convert.ln);
|
||||
gl_DeleteSamplers(1, &m_convert.pt);
|
||||
delete m_convert.dss;
|
||||
delete m_convert.bs;
|
||||
|
||||
|
|
@ -113,30 +113,30 @@ GSDeviceOGL::~GSDeviceOGL()
|
|||
|
||||
// Clean various opengl allocation
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glDeleteProgramPipelines(1, &m_pipeline);
|
||||
gl_DeleteProgramPipelines(1, &m_pipeline);
|
||||
#endif
|
||||
glDeleteFramebuffers(1, &m_fbo);
|
||||
glDeleteFramebuffers(1, &m_fbo_read);
|
||||
gl_DeleteFramebuffers(1, &m_fbo);
|
||||
gl_DeleteFramebuffers(1, &m_fbo_read);
|
||||
|
||||
// Delete HW FX
|
||||
delete m_vs_cb;
|
||||
delete m_ps_cb;
|
||||
glDeleteSamplers(1, &m_rt_ss);
|
||||
gl_DeleteSamplers(1, &m_rt_ss);
|
||||
delete m_vb;
|
||||
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
for (auto it = m_vs.begin(); it != m_vs.end() ; it++) glDeleteProgram(it->second);
|
||||
for (auto it = m_gs.begin(); it != m_gs.end() ; it++) glDeleteProgram(it->second);
|
||||
for (auto it = m_ps.begin(); it != m_ps.end() ; it++) glDeleteProgram(it->second);
|
||||
for (auto it = m_vs.begin(); it != m_vs.end() ; it++) gl_DeleteProgram(it->second);
|
||||
for (auto it = m_gs.begin(); it != m_gs.end() ; it++) gl_DeleteProgram(it->second);
|
||||
for (auto it = m_ps.begin(); it != m_ps.end() ; it++) gl_DeleteProgram(it->second);
|
||||
#else
|
||||
for (auto it = m_vs.begin(); it != m_vs.end() ; it++) glDeleteShader(it->second);
|
||||
for (auto it = m_gs.begin(); it != m_gs.end() ; it++) glDeleteShader(it->second);
|
||||
for (auto it = m_ps.begin(); it != m_ps.end() ; it++) glDeleteShader(it->second);
|
||||
for (auto it = m_vs.begin(); it != m_vs.end() ; it++) gl_DeleteShader(it->second);
|
||||
for (auto it = m_gs.begin(); it != m_gs.end() ; it++) gl_DeleteShader(it->second);
|
||||
for (auto it = m_ps.begin(); it != m_ps.end() ; it++) gl_DeleteShader(it->second);
|
||||
|
||||
for (auto it = m_single_prog.begin(); it != m_single_prog.end() ; it++) glDeleteProgram(it->second);
|
||||
for (auto it = m_single_prog.begin(); it != m_single_prog.end() ; it++) gl_DeleteProgram(it->second);
|
||||
m_single_prog.clear();
|
||||
#endif
|
||||
for (auto it = m_ps_ss.begin(); it != m_ps_ss.end() ; it++) glDeleteSamplers(1, &it->second);
|
||||
for (auto it = m_ps_ss.begin(); it != m_ps_ss.end() ; it++) gl_DeleteSamplers(1, &it->second);
|
||||
m_vs.clear();
|
||||
m_gs.clear();
|
||||
m_ps.clear();
|
||||
|
|
@ -197,12 +197,12 @@ bool GSDeviceOGL::Create(GSWnd* wnd)
|
|||
// Various object
|
||||
// ****************************************************************
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glGenProgramPipelines(1, &m_pipeline);
|
||||
glBindProgramPipeline(m_pipeline);
|
||||
gl_GenProgramPipelines(1, &m_pipeline);
|
||||
gl_BindProgramPipeline(m_pipeline);
|
||||
#endif
|
||||
|
||||
glGenFramebuffers(1, &m_fbo);
|
||||
glGenFramebuffers(1, &m_fbo_read);
|
||||
gl_GenFramebuffers(1, &m_fbo);
|
||||
gl_GenFramebuffers(1, &m_fbo_read);
|
||||
|
||||
// ****************************************************************
|
||||
// Vertex buffer state
|
||||
|
|
@ -240,35 +240,35 @@ bool GSDeviceOGL::Create(GSWnd* wnd)
|
|||
|
||||
hr = m_dev->CreateBlendState(&bsd, &m_convert.bs);
|
||||
#endif
|
||||
glGenSamplers(1, &m_convert.ln);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
gl_GenSamplers(1, &m_convert.ln);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
// FIXME which value for GL_TEXTURE_MIN_LOD
|
||||
glSamplerParameterf(m_convert.ln, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
gl_SamplerParameterf(m_convert.ln, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
// FIXME: seems there is 2 possibility in opengl
|
||||
// DX: sd.ComparisonFunc = D3D11_COMPARISON_NEVER;
|
||||
// glSamplerParameteri(m_convert.ln, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
glSamplerParameteri(m_convert.ln, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
gl_SamplerParameteri(m_convert.ln, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// FIXME: need ogl extension sd.MaxAnisotropy = 16;
|
||||
|
||||
|
||||
glGenSamplers(1, &m_convert.pt);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
gl_GenSamplers(1, &m_convert.pt);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
// FIXME which value for GL_TEXTURE_MIN_LOD
|
||||
glSamplerParameterf(m_convert.pt, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
gl_SamplerParameterf(m_convert.pt, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
// FIXME: seems there is 2 possibility in opengl
|
||||
// DX: sd.ComparisonFunc = D3D11_COMPARISON_NEVER;
|
||||
// glSamplerParameteri(m_convert.pt, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
glSamplerParameteri(m_convert.pt, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
gl_SamplerParameteri(m_convert.pt, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// FIXME: need ogl extension sd.MaxAnisotropy = 16;
|
||||
|
||||
m_convert.dss = new GSDepthStencilOGL();
|
||||
|
|
@ -530,7 +530,7 @@ void GSDeviceOGL::DebugBB()
|
|||
|
||||
static_cast<GSTextureOGL*>(rt)->Attach(GL_COLOR_ATTACHMENT0);
|
||||
|
||||
glBlitFramebuffer(0, 0, size.x, size.y,
|
||||
gl_BlitFramebuffer(0, 0, size.x, size.y,
|
||||
0, 0, size.x, size.y,
|
||||
GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
||||
|
||||
|
|
@ -599,21 +599,21 @@ static void set_uniform_buffer_binding(GLuint prog, GLchar* name, GLuint binding
|
|||
#ifdef DISABLE_GL41_SSO
|
||||
GLuint GSDeviceOGL::link_prog()
|
||||
{
|
||||
GLuint single_prog = glCreateProgram();
|
||||
if (m_state.vs) glAttachShader(single_prog, m_state.vs);
|
||||
if (m_state.ps) glAttachShader(single_prog, m_state.ps);
|
||||
if (m_state.gs) glAttachShader(single_prog, m_state.gs);
|
||||
GLuint single_prog = gl_CreateProgram();
|
||||
if (m_state.vs) gl_AttachShader(single_prog, m_state.vs);
|
||||
if (m_state.ps) gl_AttachShader(single_prog, m_state.ps);
|
||||
if (m_state.gs) gl_AttachShader(single_prog, m_state.gs);
|
||||
|
||||
glLinkProgram(single_prog);
|
||||
gl_LinkProgram(single_prog);
|
||||
|
||||
GLint status;
|
||||
glGetProgramiv(single_prog, GL_LINK_STATUS, &status);
|
||||
gl_GetProgramiv(single_prog, GL_LINK_STATUS, &status);
|
||||
if (!status) {
|
||||
GLint log_length = 0;
|
||||
glGetProgramiv(single_prog, GL_INFO_LOG_LENGTH, &log_length);
|
||||
gl_GetProgramiv(single_prog, GL_INFO_LOG_LENGTH, &log_length);
|
||||
if (log_length > 0) {
|
||||
char* log = new char[log_length];
|
||||
glGetProgramInfoLog(single_prog, log_length, NULL, log);
|
||||
gl_GetProgramInfoLog(single_prog, log_length, NULL, log);
|
||||
fprintf(stderr, "%s", log);
|
||||
delete[] log;
|
||||
}
|
||||
|
|
@ -621,9 +621,9 @@ GLuint GSDeviceOGL::link_prog()
|
|||
}
|
||||
|
||||
#if 0
|
||||
if (m_state.vs) glDetachShader(single_prog, m_state.vs);
|
||||
if (m_state.ps) glDetachShader(single_prog, m_state.ps);
|
||||
if (m_state.gs) glDetachShader(single_prog, m_state.gs);
|
||||
if (m_state.vs) gl_DetachShader(single_prog, m_state.vs);
|
||||
if (m_state.ps) gl_DetachShader(single_prog, m_state.ps);
|
||||
if (m_state.gs) gl_DetachShader(single_prog, m_state.gs);
|
||||
#endif
|
||||
|
||||
return single_prog;
|
||||
|
|
@ -700,8 +700,8 @@ void GSDeviceOGL::ClearRenderTarget(GSTexture* t, const GSVector4& c)
|
|||
if (static_cast<GSTextureOGL*>(t)->IsBackbuffer()) {
|
||||
// FIXME I really not sure
|
||||
OMSetFBO(0);
|
||||
//glClearBufferfv(GL_COLOR, GL_LEFT, c.v);
|
||||
glClearBufferfv(GL_COLOR, 0, c.v);
|
||||
//gl_ClearBufferfv(GL_COLOR, GL_LEFT, c.v);
|
||||
gl_ClearBufferfv(GL_COLOR, 0, c.v);
|
||||
// code for the old interface
|
||||
// glClearColor(c.x, c.y, c.z, c.w);
|
||||
// glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
|
@ -710,7 +710,7 @@ void GSDeviceOGL::ClearRenderTarget(GSTexture* t, const GSVector4& c)
|
|||
// I would like to avoid FBO for a basic clean operation
|
||||
OMSetFBO(m_fbo);
|
||||
static_cast<GSTextureOGL*>(t)->Attach(GL_COLOR_ATTACHMENT0);
|
||||
glClearBufferfv(GL_COLOR, 0, c.v);
|
||||
gl_ClearBufferfv(GL_COLOR, 0, c.v);
|
||||
}
|
||||
OMSetFBO(fbo_old);
|
||||
}
|
||||
|
|
@ -733,10 +733,10 @@ void GSDeviceOGL::ClearDepth(GSTexture* t, float c)
|
|||
// could be smaller than the texture and we really want to clean all pixels.
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
if (m_state.dss != NULL && m_state.dss->IsMaskEnable()) {
|
||||
glClearBufferfv(GL_DEPTH, 0, &c);
|
||||
gl_ClearBufferfv(GL_DEPTH, 0, &c);
|
||||
} else {
|
||||
glDepthMask(true);
|
||||
glClearBufferfv(GL_DEPTH, 0, &c);
|
||||
gl_ClearBufferfv(GL_DEPTH, 0, &c);
|
||||
glDepthMask(false);
|
||||
}
|
||||
glEnable(GL_SCISSOR_TEST);
|
||||
|
|
@ -752,7 +752,7 @@ void GSDeviceOGL::ClearStencil(GSTexture* t, uint8 c)
|
|||
static_cast<GSTextureOGL*>(t)->Attach(GL_DEPTH_STENCIL_ATTACHMENT);
|
||||
GLint color = c;
|
||||
// FIXME can you clean depth and stencil separately
|
||||
glClearBufferiv(GL_STENCIL, 0, &color);
|
||||
gl_ClearBufferiv(GL_STENCIL, 0, &color);
|
||||
OMSetFBO(fbo_old);
|
||||
}
|
||||
|
||||
|
|
@ -841,7 +841,7 @@ void GSDeviceOGL::CopyRect(GSTexture* st, GSTexture* dt, const GSVector4i& r)
|
|||
// uint32 srcName, enum srcTarget, int srcLevel, int srcX, int srcY, int srcZ,
|
||||
// uint32 dstName, enum dstTarget, int dstLevel, int dstX, int dstY, int dstZ,
|
||||
// sizei width, sizei height, sizei depth);
|
||||
glCopyImageSubDataNV( static_cast<GSTextureOGL*>(st)->GetID(), static_cast<GSTextureOGL*>(st)->GetTarget(),
|
||||
gl_CopyImageSubDataNV( static_cast<GSTextureOGL*>(st)->GetID(), static_cast<GSTextureOGL*>(st)->GetTarget(),
|
||||
0, r.x, r.y, 0,
|
||||
static_cast<GSTextureOGL*>(dt)->GetID(), static_cast<GSTextureOGL*>(dt)->GetTarget(),
|
||||
0, r.x, r.y, 0,
|
||||
|
|
@ -1140,7 +1140,7 @@ void GSDeviceOGL::VSSetShader(GLuint vs)
|
|||
{
|
||||
m_state.vs = vs;
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, vs);
|
||||
gl_UseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, vs);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -1151,7 +1151,7 @@ void GSDeviceOGL::GSSetShader(GLuint gs)
|
|||
{
|
||||
m_state.gs = gs;
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glUseProgramStages(m_pipeline, GL_GEOMETRY_SHADER_BIT, gs);
|
||||
gl_UseProgramStages(m_pipeline, GL_GEOMETRY_SHADER_BIT, gs);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -1194,24 +1194,24 @@ void GSDeviceOGL::PSSetShader(GLuint ps)
|
|||
{
|
||||
m_state.ps = ps;
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, ps);
|
||||
gl_UseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, ps);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Sampler and texture must be set at the same time
|
||||
// 1/ select the texture unit
|
||||
// glActiveTexture(GL_TEXTURE0 + 1);
|
||||
// gl_ActiveTexture(GL_TEXTURE0 + 1);
|
||||
// 2/ bind the texture
|
||||
// glBindTexture(GL_TEXTURE_2D , brickTexture);
|
||||
// 3/ sets the texture sampler in GLSL (could be useless with layout stuff)
|
||||
// glUniform1i(brickSamplerId , 1);
|
||||
// gl_Uniform1i(brickSamplerId , 1);
|
||||
// 4/ set the sampler state
|
||||
// glBindSampler(1 , sampler);
|
||||
// gl_BindSampler(1 , sampler);
|
||||
if (m_srv_changed || m_ss_changed) {
|
||||
for (uint32 i=0 ; i < 1; i++) {
|
||||
if (m_state.ps_srv[i] != NULL) {
|
||||
m_state.ps_srv[i]->EnableUnit(i);
|
||||
glBindSampler(i, m_state.ps_ss[i]);
|
||||
gl_BindSampler(i, m_state.ps_ss[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1221,9 +1221,9 @@ void GSDeviceOGL::OMSetFBO(GLuint fbo, GLenum buffer)
|
|||
{
|
||||
if (m_state.fbo != fbo) {
|
||||
m_state.fbo = fbo;
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
||||
gl_BindFramebuffer(GL_FRAMEBUFFER, fbo);
|
||||
// FIXME DEBUG
|
||||
//if (fbo) fprintf(stderr, "FB status %x\n", glCheckFramebufferStatus(GL_FRAMEBUFFER));
|
||||
//if (fbo) fprintf(stderr, "FB status %x\n", gl_CheckFramebufferStatus(GL_FRAMEBUFFER));
|
||||
}
|
||||
|
||||
if (m_state.draw != buffer) {
|
||||
|
|
@ -1396,14 +1396,14 @@ void GSDeviceOGL::CompileShaderFromSource(const std::string& glsl_file, const st
|
|||
// Could be useful one day
|
||||
const GLchar* ShaderSource[1];
|
||||
ShaderSource[0] = header.append(source).c_str();
|
||||
*program = glCreateShaderProgramv(type, 1, &ShaderSource[0]);
|
||||
*program = gl_CreateShaderProgramv(type, 1, &ShaderSource[0]);
|
||||
#else
|
||||
*program = glCreateShaderProgramv(type, 2, sources_array);
|
||||
*program = gl_CreateShaderProgramv(type, 2, sources_array);
|
||||
#endif
|
||||
#else
|
||||
*program = glCreateShader(type);
|
||||
glShaderSource(*program, 2, sources_array, NULL);
|
||||
glCompileShader(*program);
|
||||
*program = gl_CreateShader(type);
|
||||
gl_ShaderSource(*program, 2, sources_array, NULL);
|
||||
gl_CompileShader(*program);
|
||||
#endif
|
||||
|
||||
free(source_str);
|
||||
|
|
@ -1417,14 +1417,14 @@ void GSDeviceOGL::CompileShaderFromSource(const std::string& glsl_file, const st
|
|||
|
||||
GLint log_length = 0;
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glGetProgramiv(*program, GL_INFO_LOG_LENGTH, &log_length);
|
||||
gl_GetProgramiv(*program, GL_INFO_LOG_LENGTH, &log_length);
|
||||
#else
|
||||
glGetShaderiv(*program, GL_INFO_LOG_LENGTH, &log_length);
|
||||
gl_GetShaderiv(*program, GL_INFO_LOG_LENGTH, &log_length);
|
||||
#endif
|
||||
if (log_length > 0) {
|
||||
char* log = new char[log_length];
|
||||
#ifndef DISABLE_GL41_SSO
|
||||
glGetProgramInfoLog(*program, log_length, NULL, log);
|
||||
gl_GetProgramInfoLog(*program, log_length, NULL, log);
|
||||
#else
|
||||
glGetShaderInfoLog(*program, log_length, NULL, log);
|
||||
#endif
|
||||
|
|
@ -1446,7 +1446,7 @@ void GSDeviceOGL::CheckDebugLog()
|
|||
int* lengths = new int[count];
|
||||
char* messageLog = new char[bufsize];
|
||||
|
||||
unsigned int retVal = glGetDebugMessageLogARB(count, bufsize, sources, types, ids, severities, lengths, messageLog);
|
||||
unsigned int retVal = gl_GetDebugMessageLogARB(count, bufsize, sources, types, ids, severities, lengths, messageLog);
|
||||
|
||||
if(retVal > 0)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -105,11 +105,11 @@ public:
|
|||
glEnable(GL_BLEND);
|
||||
if (HasConstantFactor()) {
|
||||
debug_factor = factor;
|
||||
glBlendColor(factor, factor, factor, 0);
|
||||
gl_BlendColor(factor, factor, factor, 0);
|
||||
}
|
||||
|
||||
glBlendEquationSeparate(m_equation_RGB, m_equation_ALPHA);
|
||||
glBlendFuncSeparate(m_func_sRGB, m_func_dRGB, m_func_sALPHA, m_func_dALPHA);
|
||||
gl_BlendEquationSeparate(m_equation_RGB, m_equation_ALPHA);
|
||||
gl_BlendFuncSeparate(m_func_sRGB, m_func_dRGB, m_func_sALPHA, m_func_dALPHA);
|
||||
} else {
|
||||
glDisable(GL_BLEND);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,22 +33,22 @@ void GSDeviceOGL::CreateTextureFX()
|
|||
m_vs_cb = new GSUniformBufferOGL(g_vs_cb_index, sizeof(VSConstantBuffer));
|
||||
m_ps_cb = new GSUniformBufferOGL(g_ps_cb_index, sizeof(PSConstantBuffer));
|
||||
|
||||
glGenSamplers(1, &m_rt_ss);
|
||||
gl_GenSamplers(1, &m_rt_ss);
|
||||
// FIXME, seem to have no difference between sampler !!!
|
||||
m_palette_ss = m_rt_ss;
|
||||
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
// FIXME which value for GL_TEXTURE_MIN_LOD
|
||||
glSamplerParameterf(m_rt_ss, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
gl_SamplerParameterf(m_rt_ss, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
// FIXME: seems there is 2 possibility in opengl
|
||||
// DX: sd.ComparisonFunc = D3D11_COMPARISON_NEVER;
|
||||
// glSamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// FIXME: need ogl extension sd.MaxAnisotropy = 16;
|
||||
|
||||
GSInputLayoutOGL vert_format[] =
|
||||
|
|
@ -200,35 +200,35 @@ void GSDeviceOGL::SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerS
|
|||
// *************************************************************
|
||||
// Static
|
||||
// *************************************************************
|
||||
glGenSamplers(1, &ss0);
|
||||
gl_GenSamplers(1, &ss0);
|
||||
if (ssel.ltf) {
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
} else {
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
}
|
||||
|
||||
// FIXME ensure U -> S, V -> T and W->R
|
||||
if (ssel.tau)
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
else
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
|
||||
if (ssel.tav)
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
else
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
|
||||
glSamplerParameteri(ss0, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
gl_SamplerParameteri(ss0, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
||||
|
||||
// FIXME which value for GL_TEXTURE_MIN_LOD
|
||||
glSamplerParameterf(m_rt_ss, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
gl_SamplerParameterf(m_rt_ss, GL_TEXTURE_MAX_LOD, FLT_MAX);
|
||||
// FIXME: seems there is 2 possibility in opengl
|
||||
// DX: sd.ComparisonFunc = D3D11_COMPARISON_NEVER;
|
||||
// glSamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
glSamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_NONE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
gl_SamplerParameteri(m_rt_ss, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
|
||||
// FIXME: need ogl extension sd.MaxAnisotropy = 16;
|
||||
|
||||
m_ps_ss[ssel] = ss0;
|
||||
|
|
|
|||
|
|
@ -33,19 +33,19 @@ GSTextureOGL::GSTextureOGL(int type, int w, int h, bool msaa, int format, GLuint
|
|||
// Opengl world
|
||||
|
||||
// Render work in parallal with framebuffer object (FBO) http://www.opengl.org/wiki/Framebuffer_Objects
|
||||
// render are attached to FBO through : glFramebufferRenderbuffer. You can query the number of colorattachement with GL_MAX_COLOR_ATTACHMENTS
|
||||
// FBO : constructor -> glGenFramebuffers, glDeleteFramebuffers
|
||||
// binding -> glBindFramebuffer (target can be read/write/both)
|
||||
// blit -> glBlitFramebuffer (read FB to draw FB)
|
||||
// info -> glIsFramebuffer, glGetFramebufferAttachmentParameter, glCheckFramebufferStatus
|
||||
// render are attached to FBO through : gl_FramebufferRenderbuffer. You can query the number of colorattachement with GL_MAX_COLOR_ATTACHMENTS
|
||||
// FBO : constructor -> gl_GenFramebuffers, gl_DeleteFramebuffers
|
||||
// binding -> gl_BindFramebuffer (target can be read/write/both)
|
||||
// blit -> gl_BlitFramebuffer (read FB to draw FB)
|
||||
// info -> gl_IsFramebuffer, glGetFramebufferAttachmentParameter, gl_CheckFramebufferStatus
|
||||
//
|
||||
// There are two types of framebuffer-attachable images; texture images and renderbuffer images.
|
||||
// If an image of a texture object is attached to a framebuffer, OpenGL performs "render to texture".
|
||||
// And if an image of a renderbuffer object is attached to a framebuffer, then OpenGL performs "offscreen rendering".
|
||||
// Blitting:
|
||||
// glDrawBuffers
|
||||
// gl_DrawBuffers
|
||||
// glReadBuffer
|
||||
// glBlitFramebuffer
|
||||
// gl_BlitFramebuffer
|
||||
|
||||
// *************************************************************
|
||||
// m_size.x = w;
|
||||
|
|
@ -62,7 +62,7 @@ GSTextureOGL::GSTextureOGL(int type, int w, int h, bool msaa, int format, GLuint
|
|||
switch (m_type) {
|
||||
case GSTexture::Offscreen:
|
||||
//FIXME I not sure we need a pixel buffer object. It seems more a texture
|
||||
// glGenBuffers(1, &m_texture_id);
|
||||
// gl_GenBuffers(1, &m_texture_id);
|
||||
// m_texture_target = GL_PIXEL_UNPACK_BUFFER;
|
||||
// ASSERT(0);
|
||||
// Note there is also a buffer texture!!!
|
||||
|
|
@ -84,7 +84,7 @@ GSTextureOGL::GSTextureOGL(int type, int w, int h, bool msaa, int format, GLuint
|
|||
break;
|
||||
}
|
||||
// Extra buffer to handle various pixel transfer
|
||||
glGenBuffers(1, &m_pbo_id);
|
||||
gl_GenBuffers(1, &m_pbo_id);
|
||||
|
||||
uint32 msaa_level;
|
||||
if (m_msaa) {
|
||||
|
|
@ -105,9 +105,9 @@ GSTextureOGL::GSTextureOGL(int type, int w, int h, bool msaa, int format, GLuint
|
|||
ASSERT(0); // TODO Later
|
||||
}
|
||||
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, m_pbo_id);
|
||||
glBufferData(GL_PIXEL_PACK_BUFFER, m_pbo_size, NULL, GL_STREAM_DRAW);
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
gl_BindBuffer(GL_PIXEL_PACK_BUFFER, m_pbo_id);
|
||||
gl_BufferData(GL_PIXEL_PACK_BUFFER, m_pbo_size, NULL, GL_STREAM_DRAW);
|
||||
gl_BindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
ASSERT(!m_msaa);
|
||||
|
||||
case GSTexture::DepthStencil:
|
||||
|
|
@ -121,9 +121,9 @@ GSTextureOGL::GSTextureOGL(int type, int w, int h, bool msaa, int format, GLuint
|
|||
if (m_msaa) {
|
||||
ASSERT(m_texture_target == GL_TEXTURE_2D_MULTISAMPLE);
|
||||
// Require a recent GLEW and GL4.3
|
||||
//glTexStorage2DMultisample(m_texture_target, msaa_level, m_format, m_size.x, m_size.y, false);
|
||||
//gl_TexStorage2DMultisample(m_texture_target, msaa_level, m_format, m_size.x, m_size.y, false);
|
||||
} else {
|
||||
glTexStorage2D(m_texture_target, 1, m_format, m_size.x, m_size.y);
|
||||
gl_TexStorage2D(m_texture_target, 1, m_format, m_size.x, m_size.y);
|
||||
}
|
||||
break;
|
||||
default: break;
|
||||
|
|
@ -132,16 +132,16 @@ GSTextureOGL::GSTextureOGL(int type, int w, int h, bool msaa, int format, GLuint
|
|||
|
||||
GSTextureOGL::~GSTextureOGL()
|
||||
{
|
||||
glDeleteBuffers(1, &m_pbo_id);
|
||||
gl_DeleteBuffers(1, &m_pbo_id);
|
||||
glDeleteTextures(1, &m_texture_id);
|
||||
}
|
||||
|
||||
void GSTextureOGL::Attach(GLenum attachment)
|
||||
{
|
||||
//fprintf(stderr, "format %d,%x\n", m_type, m_format);
|
||||
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, m_texture_target, m_texture_id, 0);
|
||||
gl_FramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, m_texture_target, m_texture_id, 0);
|
||||
// FIXME DEBUG
|
||||
//fprintf(stderr, "FB status %x\n", glCheckFramebufferStatus(GL_FRAMEBUFFER));
|
||||
//fprintf(stderr, "FB status %x\n", gl_CheckFramebufferStatus(GL_FRAMEBUFFER));
|
||||
}
|
||||
|
||||
bool GSTextureOGL::Update(const GSVector4i& r, const void* data, int pitch)
|
||||
|
|
@ -206,7 +206,7 @@ void GSTextureOGL::EnableUnit(uint32 unit)
|
|||
// For the moment SW renderer only use 1 so don't bother
|
||||
if (g_state_texture_unit != unit) {
|
||||
g_state_texture_unit = unit;
|
||||
glActiveTexture(GL_TEXTURE0 + unit);
|
||||
gl_ActiveTexture(GL_TEXTURE0 + unit);
|
||||
// When you change the texture unit, texture must be rebinded
|
||||
g_state_texture_id = m_texture_id;
|
||||
glBindTexture(m_texture_target, m_texture_id);
|
||||
|
|
@ -224,18 +224,18 @@ bool GSTextureOGL::Map(GSMap& m, const GSVector4i* r)
|
|||
// Set m.pitch <- size of a row
|
||||
// I think in opengl we need to copy back the data to the RAM: glReadPixels — read a block of pixels from the frame buffer
|
||||
//
|
||||
// glMapBuffer — map a buffer object's data store
|
||||
// gl_MapBuffer — map a buffer object's data store
|
||||
// Can be used on GL_PIXEL_UNPACK_BUFFER or GL_TEXTURE_BUFFER
|
||||
if (m_type == GSTexture::Offscreen) {
|
||||
// Bind the texture to the read framebuffer to avoid any disturbance
|
||||
EnableUnit(0);
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read);
|
||||
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture_target, m_texture_id, 0);
|
||||
gl_BindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read);
|
||||
gl_FramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture_target, m_texture_id, 0);
|
||||
glReadBuffer(GL_COLOR_ATTACHMENT0);
|
||||
|
||||
// FIXME It might be possible to only read a subrange of the texture based on r object
|
||||
// Load the PBO with the data
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, m_pbo_id);
|
||||
gl_BindBuffer(GL_PIXEL_PACK_BUFFER, m_pbo_id);
|
||||
if (m_format == GL_RGBA8) {
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
||||
glReadPixels(0, 0, m_size.x, m_size.y, GL_RGBA, GL_UNSIGNED_BYTE, 0);
|
||||
|
|
@ -249,17 +249,17 @@ bool GSTextureOGL::Map(GSMap& m, const GSVector4i* r)
|
|||
fprintf(stderr, "wrong texture pixel format :%x\n", m_format);
|
||||
ASSERT(0);
|
||||
}
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
gl_BindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
|
||||
// Give access from the CPU
|
||||
m.bits = (uint8*) glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, m_pbo_size, GL_MAP_READ_BIT);
|
||||
m.bits = (uint8*) gl_MapBufferRange(GL_PIXEL_PACK_BUFFER, 0, m_pbo_size, GL_MAP_READ_BIT);
|
||||
m.pitch = m_size.x;
|
||||
|
||||
if ( m.bits ) {
|
||||
return true;
|
||||
} else {
|
||||
fprintf(stderr, "bad mapping of the pbo\n");
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
gl_BindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -286,8 +286,8 @@ bool GSTextureOGL::Map(GSMap& m, const GSVector4i* r)
|
|||
void GSTextureOGL::Unmap()
|
||||
{
|
||||
if (m_type == GSTexture::Offscreen) {
|
||||
glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
gl_UnmapBuffer(GL_PIXEL_PACK_BUFFER);
|
||||
gl_BindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -405,22 +405,22 @@ bool GSTextureOGL::Save(const string& fn, bool dds)
|
|||
// for us
|
||||
if (IsBackbuffer()) {
|
||||
//glReadBuffer(GL_BACK);
|
||||
//glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
//gl_BindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
glReadPixels(0, 0, m_size.x, m_size.y, GL_RGBA, GL_UNSIGNED_BYTE, image);
|
||||
} else if(IsDss()) {
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read);
|
||||
gl_BindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read);
|
||||
|
||||
//EnableUnit(0);
|
||||
|
||||
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_texture_target, m_texture_id, 0);
|
||||
gl_FramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_texture_target, m_texture_id, 0);
|
||||
glReadPixels(0, 0, m_size.x, m_size.y, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, image);
|
||||
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
gl_BindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
} else {
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read);
|
||||
gl_BindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read);
|
||||
|
||||
EnableUnit(0);
|
||||
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture_target, m_texture_id, 0);
|
||||
gl_FramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture_target, m_texture_id, 0);
|
||||
|
||||
glReadBuffer(GL_COLOR_ATTACHMENT0);
|
||||
if (m_format == GL_RGBA8)
|
||||
|
|
@ -438,7 +438,7 @@ bool GSTextureOGL::Save(const string& fn, bool dds)
|
|||
status = false;
|
||||
}
|
||||
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
gl_BindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||||
}
|
||||
|
||||
if (status) Save(fn, image, pitch);
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ public:
|
|||
, size(size)
|
||||
,target(GL_UNIFORM_BUFFER)
|
||||
{
|
||||
glGenBuffers(1, &buffer);
|
||||
gl_GenBuffers(1, &buffer);
|
||||
bind();
|
||||
allocate();
|
||||
attach();
|
||||
|
|
@ -40,28 +40,28 @@ public:
|
|||
|
||||
void bind()
|
||||
{
|
||||
glBindBuffer(target, buffer);
|
||||
gl_BindBuffer(target, buffer);
|
||||
}
|
||||
|
||||
void allocate()
|
||||
{
|
||||
glBufferData(target, size, NULL, GL_STREAM_DRAW);
|
||||
gl_BufferData(target, size, NULL, GL_STREAM_DRAW);
|
||||
}
|
||||
|
||||
void attach()
|
||||
{
|
||||
glBindBufferBase(target, index, buffer);
|
||||
gl_BindBufferBase(target, index, buffer);
|
||||
}
|
||||
|
||||
void upload(const void* src)
|
||||
{
|
||||
uint32 flags = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
|
||||
uint8* dst = (uint8*) glMapBufferRange(target, 0, size, flags);
|
||||
uint8* dst = (uint8*) gl_MapBufferRange(target, 0, size, flags);
|
||||
memcpy(dst, src, size);
|
||||
glUnmapBuffer(target);
|
||||
gl_UnmapBuffer(target);
|
||||
}
|
||||
|
||||
~GSUniformBufferOGL() {
|
||||
glDeleteBuffers(1, &buffer);
|
||||
gl_DeleteBuffers(1, &buffer);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -47,12 +47,12 @@ class GSBufferOGL {
|
|||
, m_limit(0)
|
||||
, m_target(target)
|
||||
{
|
||||
glGenBuffers(1, &m_buffer);
|
||||
gl_GenBuffers(1, &m_buffer);
|
||||
// Opengl works best with 1-4MB buffer.
|
||||
m_default_size = 2 * 1024 * 1024 / m_stride;
|
||||
}
|
||||
|
||||
~GSBufferOGL() { glDeleteBuffers(1, &m_buffer); }
|
||||
~GSBufferOGL() { gl_DeleteBuffers(1, &m_buffer); }
|
||||
|
||||
void allocate() { allocate(m_default_size); }
|
||||
|
||||
|
|
@ -60,12 +60,12 @@ class GSBufferOGL {
|
|||
{
|
||||
m_start = 0;
|
||||
m_limit = new_limit;
|
||||
glBufferData(m_target, m_limit * m_stride, NULL, GL_STREAM_DRAW);
|
||||
gl_BufferData(m_target, m_limit * m_stride, NULL, GL_STREAM_DRAW);
|
||||
}
|
||||
|
||||
void bind()
|
||||
{
|
||||
glBindBuffer(m_target, m_buffer);
|
||||
gl_BindBuffer(m_target, m_buffer);
|
||||
}
|
||||
|
||||
void upload(const void* src, uint32 count)
|
||||
|
|
@ -83,7 +83,7 @@ class GSBufferOGL {
|
|||
bool Map(void** pointer, uint32 count ) {
|
||||
#ifdef ENABLE_OGL_DEBUG
|
||||
GLint b_size = -1;
|
||||
glGetBufferParameteriv(m_target, GL_BUFFER_SIZE, &b_size);
|
||||
gl_GetBufferParameteriv(m_target, GL_BUFFER_SIZE, &b_size);
|
||||
|
||||
if (b_size <= 0) return false;
|
||||
#endif
|
||||
|
|
@ -112,7 +112,7 @@ class GSBufferOGL {
|
|||
}
|
||||
|
||||
// Upload the data to the buffer
|
||||
*pointer = (uint8*) glMapBufferRange(m_target, m_stride*m_start, m_stride*m_count, map_flags);
|
||||
*pointer = (uint8*) gl_MapBufferRange(m_target, m_stride*m_start, m_stride*m_count, map_flags);
|
||||
//fprintf(stderr, "Map %x from %d to %d\n", *pointer, m_start, m_start+m_count);
|
||||
#ifdef ENABLE_OGL_DEBUG
|
||||
if (*pointer == NULL) {
|
||||
|
|
@ -123,7 +123,7 @@ class GSBufferOGL {
|
|||
return true;
|
||||
}
|
||||
|
||||
void Unmap() { glUnmapBuffer(m_target); }
|
||||
void Unmap() { gl_UnmapBuffer(m_target); }
|
||||
|
||||
void EndScene()
|
||||
{
|
||||
|
|
@ -138,12 +138,12 @@ class GSBufferOGL {
|
|||
|
||||
void Draw(GLenum mode, GLint basevertex)
|
||||
{
|
||||
glDrawElementsBaseVertex(mode, m_count, GL_UNSIGNED_INT, (void*)(m_start * m_stride), basevertex);
|
||||
gl_DrawElementsBaseVertex(mode, m_count, GL_UNSIGNED_INT, (void*)(m_start * m_stride), basevertex);
|
||||
}
|
||||
|
||||
void Draw(GLenum mode, GLint basevertex, int offset, int count)
|
||||
{
|
||||
glDrawElementsBaseVertex(mode, count, GL_UNSIGNED_INT, (void*)((m_start + offset) * m_stride), basevertex);
|
||||
gl_DrawElementsBaseVertex(mode, count, GL_UNSIGNED_INT, (void*)((m_start + offset) * m_stride), basevertex);
|
||||
}
|
||||
|
||||
size_t GetStart() { return m_start; }
|
||||
|
|
@ -165,7 +165,7 @@ class GSVertexBufferStateOGL {
|
|||
public:
|
||||
GSVertexBufferStateOGL(size_t stride, GSInputLayoutOGL* layout, uint32 layout_nbr)
|
||||
{
|
||||
glGenVertexArrays(1, &m_va);
|
||||
gl_GenVertexArrays(1, &m_va);
|
||||
|
||||
m_vb = new GSBufferOGL(GL_ARRAY_BUFFER, stride);
|
||||
m_ib = new GSBufferOGL(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32));
|
||||
|
|
@ -181,7 +181,7 @@ public:
|
|||
|
||||
void bind()
|
||||
{
|
||||
glBindVertexArray(m_va);
|
||||
gl_BindVertexArray(m_va);
|
||||
m_vb->bind();
|
||||
}
|
||||
|
||||
|
|
@ -189,15 +189,15 @@ public:
|
|||
{
|
||||
for (uint32 i = 0; i < layout_nbr; i++) {
|
||||
// Note this function need both a vertex array object and a GL_ARRAY_BUFFER buffer
|
||||
glEnableVertexAttribArray(layout[i].index);
|
||||
gl_EnableVertexAttribArray(layout[i].index);
|
||||
switch (layout[i].type) {
|
||||
case GL_UNSIGNED_SHORT:
|
||||
case GL_UNSIGNED_INT:
|
||||
// Rule: when shader use integral (not normalized) you must use glVertexAttribIPointer (note the extra I)
|
||||
glVertexAttribIPointer(layout[i].index, layout[i].size, layout[i].type, layout[i].stride, layout[i].offset);
|
||||
// Rule: when shader use integral (not normalized) you must use gl_VertexAttribIPointer (note the extra I)
|
||||
gl_VertexAttribIPointer(layout[i].index, layout[i].size, layout[i].type, layout[i].stride, layout[i].offset);
|
||||
break;
|
||||
default:
|
||||
glVertexAttribPointer(layout[i].index, layout[i].size, layout[i].type, layout[i].normalize, layout[i].stride, layout[i].offset);
|
||||
gl_VertexAttribPointer(layout[i].index, layout[i].size, layout[i].type, layout[i].normalize, layout[i].stride, layout[i].offset);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -227,7 +227,7 @@ public:
|
|||
|
||||
~GSVertexBufferStateOGL()
|
||||
{
|
||||
glDeleteVertexArrays(1, &m_va);
|
||||
gl_DeleteVertexArrays(1, &m_va);
|
||||
delete m_vb;
|
||||
delete m_ib;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue