| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,389 @@ | ||
| #include "mythrender_opengl1.h" | ||
|
|
||
| #define LOC QString("OpenGL1: ") | ||
| #define LOC_ERR QString("OpenGL1 Error: ") | ||
|
|
||
| MythRenderOpenGL1::MythRenderOpenGL1(const QGLFormat& format, QPaintDevice* device) | ||
| : MythRenderOpenGL(format, device) | ||
| { | ||
| ResetVars(); | ||
| ResetProcs(); | ||
| } | ||
|
|
||
| MythRenderOpenGL1::MythRenderOpenGL1(const QGLFormat& format) | ||
| : MythRenderOpenGL(format) | ||
| { | ||
| ResetVars(); | ||
| ResetProcs(); | ||
| } | ||
|
|
||
| MythRenderOpenGL1::~MythRenderOpenGL1() | ||
| { | ||
| makeCurrent(); | ||
| DeleteOpenGLResources(); | ||
| doneCurrent(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::Init2DState(void) | ||
| { | ||
| glShadeModel(GL_FLAT); | ||
| glDisable(GL_POLYGON_SMOOTH); | ||
| glDisable(GL_LINE_SMOOTH); | ||
| glDisable(GL_POINT_SMOOTH); | ||
| glColor4f(0.0f, 0.0f, 0.0f, 0.0f); | ||
| MythRenderOpenGL::Init2DState(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::ResetVars(void) | ||
| { | ||
| MythRenderOpenGL::ResetVars(); | ||
| m_active_prog = 0; | ||
| m_color = 0x00000000; | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::ResetProcs(void) | ||
| { | ||
| MythRenderOpenGL::ResetProcs(); | ||
| m_glGenProgramsARB = NULL; | ||
| m_glBindProgramARB = NULL; | ||
| m_glProgramStringARB = NULL; | ||
| m_glProgramLocalParameter4fARB = NULL; | ||
| m_glDeleteProgramsARB = NULL; | ||
| m_glGetProgramivARB = NULL; | ||
| } | ||
|
|
||
| bool MythRenderOpenGL1::InitFeatures(void) | ||
| { | ||
| m_exts_supported = kGLFeatNone; | ||
|
|
||
| static bool fragmentprog = true; | ||
| static bool check = true; | ||
| if (check) | ||
| { | ||
| check = false; | ||
| fragmentprog = !getenv("OPENGL_NOFRAGPROG"); | ||
| if (!fragmentprog) | ||
| VERBOSE(VB_GENERAL, LOC + "Disabling fragment programs."); | ||
| } | ||
|
|
||
| if (m_extensions.contains("GL_ARB_fragment_program") && | ||
| m_glGenProgramsARB && m_glBindProgramARB && | ||
| m_glProgramStringARB && m_glDeleteProgramsARB && | ||
| m_glGetProgramivARB && m_glProgramLocalParameter4fARB && | ||
| fragmentprog) | ||
| { | ||
| m_exts_supported += kGLExtFragProg; | ||
| VERBOSE(VB_GENERAL, LOC + QString("Fragment program support available")); | ||
| } | ||
|
|
||
| return MythRenderOpenGL::InitFeatures(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::InitProcs(void) | ||
| { | ||
| MythRenderOpenGL::InitProcs(); | ||
|
|
||
| m_glGenProgramsARB = (MYTH_GLGENPROGRAMSARBPROC) | ||
| GetProcAddress("glGenProgramsARB"); | ||
| m_glBindProgramARB = (MYTH_GLBINDPROGRAMARBPROC) | ||
| GetProcAddress("glBindProgramARB"); | ||
| m_glProgramStringARB = (MYTH_GLPROGRAMSTRINGARBPROC) | ||
| GetProcAddress("glProgramStringARB"); | ||
| m_glProgramLocalParameter4fARB = (MYTH_GLPROGRAMLOCALPARAMETER4FARBPROC) | ||
| GetProcAddress("glProgramLocalParameter4fARB"); | ||
| m_glDeleteProgramsARB = (MYTH_GLDELETEPROGRAMSARBPROC) | ||
| GetProcAddress("glDeleteProgramsARB"); | ||
| m_glGetProgramivARB = (MYTH_GLGETPROGRAMIVARBPROC) | ||
| GetProcAddress("glGetProgramivARB"); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::SetColor(int r, int g, int b, int a) | ||
| { | ||
| uint32_t tmp = (r << 24) + (g << 16) + (b << 8) + a; | ||
| if (tmp == m_color) | ||
| return; | ||
|
|
||
| m_color = tmp; | ||
| makeCurrent(); | ||
| glColor4f(r / 255.0, g / 255.0, b / 255.0, a / 255.0); | ||
| doneCurrent(); | ||
| } | ||
|
|
||
| uint MythRenderOpenGL1::CreateShaderObject(const QString &vert, const QString &frag) | ||
| { | ||
| (void)vert; | ||
| if (!(m_exts_used & kGLExtFragProg)) | ||
| return 0; | ||
|
|
||
| bool success = true; | ||
| GLint error; | ||
|
|
||
| makeCurrent(); | ||
|
|
||
| QByteArray tmp = frag.toAscii(); | ||
|
|
||
| GLuint glfp; | ||
| m_glGenProgramsARB(1, &glfp); | ||
| m_glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, glfp); | ||
| m_glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, | ||
| GL_PROGRAM_FORMAT_ASCII_ARB, | ||
| tmp.length(), tmp.constData()); | ||
|
|
||
| glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error); | ||
| if (error != -1) | ||
| { | ||
| VERBOSE(VB_PLAYBACK, LOC_ERR + | ||
| QString("Fragment Program compile error: position %1:'%2'") | ||
| .arg(error).arg(frag.mid(error))); | ||
|
|
||
| success = false; | ||
| } | ||
| m_glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, | ||
| GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &error); | ||
| if (error != 1) | ||
| { | ||
| VERBOSE(VB_PLAYBACK, LOC_ERR + | ||
| "Fragment program exceeds hardware capabilities."); | ||
|
|
||
| success = false; | ||
| } | ||
|
|
||
| if (success) | ||
| { | ||
| VERBOSE(VB_PLAYBACK|VB_EXTRA, "\n" + frag + "\n"); | ||
| m_programs.push_back(glfp); | ||
| } | ||
| else | ||
| m_glDeleteProgramsARB(1, &glfp); | ||
|
|
||
| Flush(true); | ||
| doneCurrent(); | ||
| return glfp; | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::DeleteShaderObject(uint fp) | ||
| { | ||
| if (!m_programs.contains(fp)) | ||
| return; | ||
|
|
||
| makeCurrent(); | ||
| QVector<GLuint>::iterator it; | ||
| for (it = m_programs.begin(); it != m_programs.end(); ++it) | ||
| { | ||
| if (*it == fp) | ||
| { | ||
| m_glDeleteProgramsARB(1, &(*it)); | ||
| m_programs.erase(it); | ||
| break; | ||
| } | ||
| } | ||
| Flush(true); | ||
| doneCurrent(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::EnableShaderObject(uint obj) | ||
| { | ||
| if ((!obj && !m_active_prog) || | ||
| (obj && (obj == m_active_prog))) | ||
| return; | ||
|
|
||
| makeCurrent(); | ||
|
|
||
| if (!obj && m_active_prog) | ||
| { | ||
| glDisable(GL_FRAGMENT_PROGRAM_ARB); | ||
| m_active_prog = 0; | ||
| doneCurrent(); | ||
| return; | ||
| } | ||
|
|
||
| if (!m_programs.contains(obj)) | ||
| return; | ||
|
|
||
| if (!m_active_prog) | ||
| glEnable(GL_FRAGMENT_PROGRAM_ARB); | ||
|
|
||
| if (obj != m_active_prog) | ||
| { | ||
| m_glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, obj); | ||
| m_active_prog = obj; | ||
| } | ||
|
|
||
| doneCurrent(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::SetShaderParams(uint obj, void* vals, | ||
| const char* uniform) | ||
| { | ||
| makeCurrent(); | ||
| const float *v = (float*)vals; | ||
|
|
||
| EnableShaderObject(obj); | ||
| m_glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, | ||
| 0, v[0], v[1], v[2], v[3]); | ||
| m_glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, | ||
| 1, v[4], v[5], v[6], v[7]); | ||
| m_glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, | ||
| 2, v[8], v[9], v[10], v[11]); | ||
|
|
||
| doneCurrent(); | ||
| } | ||
|
|
||
| uint MythRenderOpenGL1::CreateHelperTexture(void) | ||
| { | ||
| makeCurrent(); | ||
|
|
||
| uint width = m_max_tex_size; | ||
| uint tmp_tex = CreateTexture(QSize(width, 1), false, | ||
| GL_TEXTURE_1D, GL_FLOAT, GL_RGBA, | ||
| GL_RGBA16, GL_NEAREST, GL_REPEAT); | ||
|
|
||
| if (!tmp_tex) | ||
| { | ||
| DeleteTexture(tmp_tex); | ||
| return 0; | ||
| } | ||
|
|
||
| float *buf = NULL; | ||
| buf = new float[m_textures[tmp_tex].m_data_size]; | ||
| float *ref = buf; | ||
|
|
||
| for (uint i = 0; i < width; i++) | ||
| { | ||
| float x = (((float)i) + 0.5f) / (float)width; | ||
| StoreBicubicWeights(x, ref); | ||
| ref += 4; | ||
| } | ||
| StoreBicubicWeights(0, buf); | ||
| StoreBicubicWeights(1, &buf[(width - 1) << 2]); | ||
|
|
||
| EnableTextures(tmp_tex); | ||
| glBindTexture(m_textures[tmp_tex].m_type, tmp_tex); | ||
| glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA16, width, 0, GL_RGBA, GL_FLOAT, buf); | ||
|
|
||
| VERBOSE(VB_PLAYBACK, LOC + | ||
| QString("Created bicubic helper texture (%1 samples)") | ||
| .arg(width)); | ||
| delete [] buf; | ||
| doneCurrent(); | ||
| return tmp_tex; | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::DeleteOpenGLResources(void) | ||
| { | ||
| VERBOSE(VB_GENERAL, LOC + "Deleting OpenGL Resources"); | ||
| DeleteShaders(); | ||
| MythRenderOpenGL::DeleteOpenGLResources(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::SetMatrixView(void) | ||
| { | ||
| glMatrixMode(GL_PROJECTION); | ||
| glLoadIdentity(); | ||
| glOrtho(0, m_viewport.width(), m_viewport.height(), 0, 1, -1); | ||
| glMatrixMode(GL_MODELVIEW); | ||
| glLoadIdentity(); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::DeleteShaders(void) | ||
| { | ||
| QVector<GLuint>::iterator it; | ||
| for (it = m_programs.begin(); it != m_programs.end(); ++it) | ||
| m_glDeleteProgramsARB(1, &(*(it))); | ||
| m_programs.clear(); | ||
| Flush(true); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::DrawBitmapPriv(uint tex, const QRect *src, | ||
| const QRect *dst, uint prog, int alpha, | ||
| int red, int green, int blue) | ||
| { | ||
| if (prog && !m_programs.contains(prog)) | ||
| prog = 0; | ||
|
|
||
| EnableShaderObject(prog); | ||
| SetBlend(true); | ||
| SetColor(red, green, blue, alpha); | ||
|
|
||
| glEnableClientState(GL_VERTEX_ARRAY); | ||
| glEnableClientState(GL_TEXTURE_COORD_ARRAY); | ||
| EnableTextures(tex); | ||
| glBindTexture(m_textures[tex].m_type, tex); | ||
| UpdateTextureVertices(tex, src, dst); | ||
| glVertexPointer(2, GL_FLOAT, 0, m_textures[tex].m_vertex_data); | ||
| glTexCoordPointer(2, GL_FLOAT, 0, m_textures[tex].m_vertex_data + TEX_OFFSET); | ||
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); | ||
| glDisableClientState(GL_TEXTURE_COORD_ARRAY); | ||
| glDisableClientState(GL_VERTEX_ARRAY); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::DrawBitmapPriv(uint *textures, uint texture_count, | ||
| const QRectF *src, const QRectF *dst, | ||
| uint prog) | ||
| { | ||
| if (prog && !m_programs.contains(prog)) | ||
| prog = 0; | ||
|
|
||
| uint first = textures[0]; | ||
|
|
||
| EnableShaderObject(prog); | ||
| SetBlend(false); | ||
| SetColor(255, 255, 255, 255); | ||
|
|
||
| glEnableClientState(GL_VERTEX_ARRAY); | ||
| glEnableClientState(GL_TEXTURE_COORD_ARRAY); | ||
| EnableTextures(first); | ||
| uint active_tex = 0; | ||
| for (uint i = 0; i < texture_count; i++) | ||
| { | ||
| if (m_textures.contains(textures[i])) | ||
| { | ||
| ActiveTexture(GL_TEXTURE0 + active_tex++); | ||
| glBindTexture(m_textures[textures[i]].m_type, textures[i]); | ||
| } | ||
| } | ||
|
|
||
| UpdateTextureVertices(first, src, dst); | ||
| glVertexPointer(2, GL_FLOAT, 0, m_textures[first].m_vertex_data); | ||
| glTexCoordPointer(2, GL_FLOAT, 0, m_textures[first].m_vertex_data + TEX_OFFSET); | ||
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); | ||
|
|
||
| ActiveTexture(GL_TEXTURE0); | ||
| glDisableClientState(GL_TEXTURE_COORD_ARRAY); | ||
| glDisableClientState(GL_VERTEX_ARRAY); | ||
| } | ||
|
|
||
| void MythRenderOpenGL1::DrawRectPriv(const QRect &area, bool drawFill, | ||
| const QColor &fillColor, bool drawLine, | ||
| int lineWidth, const QColor &lineColor, | ||
| int prog) | ||
| { | ||
| if (prog && !m_programs.contains(prog)) | ||
| prog = 0; | ||
|
|
||
| EnableShaderObject(prog); | ||
| SetBlend(true); | ||
| DisableTextures(); | ||
| glEnableClientState(GL_VERTEX_ARRAY); | ||
|
|
||
| if (drawFill) | ||
| { | ||
| SetColor(fillColor.red(), fillColor.green(), | ||
| fillColor.blue(), fillColor.alpha()); | ||
| GLfloat *vertices = GetCachedVertices(GL_TRIANGLE_STRIP, area); | ||
| glVertexPointer(2, GL_FLOAT, 0, vertices); | ||
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); | ||
| } | ||
|
|
||
| if (drawLine) | ||
| { | ||
| SetColor(lineColor.red(), lineColor.green(), | ||
| lineColor.blue(), lineColor.alpha()); | ||
| glLineWidth(lineWidth); | ||
| GLfloat *vertices = GetCachedVertices(GL_LINE_LOOP, area); | ||
| glVertexPointer(2, GL_FLOAT, 0, vertices); | ||
| glDrawArrays(GL_LINE_LOOP, 0, 4); | ||
| } | ||
|
|
||
| glDisableClientState(GL_VERTEX_ARRAY); | ||
| } |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,59 @@ | ||
| #ifndef MYTHRENDEROPENGL1_H | ||
| #define MYTHRENDEROPENGL1_H | ||
|
|
||
| #include "mythrender_opengl.h" | ||
| #include "mythrender_opengl_defs1.h" | ||
|
|
||
| class MPUBLIC MythRenderOpenGL1 : public MythRenderOpenGL | ||
| { | ||
| public: | ||
| MythRenderOpenGL1(const QGLFormat& format, QPaintDevice* device); | ||
| MythRenderOpenGL1(const QGLFormat& format); | ||
| virtual ~MythRenderOpenGL1(); | ||
|
|
||
| virtual void SetColor(int r, int g, int b, int a); | ||
|
|
||
| virtual uint CreateShaderObject(const QString &vert, const QString &frag); | ||
| virtual void DeleteShaderObject(uint obj); | ||
| virtual void EnableShaderObject(uint obj); | ||
| virtual void SetShaderParams(uint obj, void* vals, const char* uniform); | ||
|
|
||
| virtual uint CreateHelperTexture(void); | ||
|
|
||
| private: | ||
| virtual void DrawBitmapPriv(uint tex, const QRect *src, const QRect *dst, | ||
| uint prog, int alpha, | ||
| int red, int green, int blue); | ||
| virtual void DrawBitmapPriv(uint *textures, uint texture_count, | ||
| const QRectF *src, const QRectF *dst, | ||
| uint prog); | ||
| virtual void DrawRectPriv(const QRect &area, bool drawFill, | ||
| const QColor &fillColor, bool drawLine, | ||
| int lineWidth, const QColor &lineColor, | ||
| int prog); | ||
|
|
||
| virtual void Init2DState(void); | ||
| virtual void InitProcs(void); | ||
| virtual bool InitFeatures(void); | ||
| virtual void DeleteShaders(void); | ||
| virtual void ResetVars(void); | ||
| virtual void ResetProcs(void); | ||
| virtual void DeleteOpenGLResources(void); | ||
| virtual void SetMatrixView(void); | ||
| // Resources | ||
| QVector<GLuint> m_programs; | ||
|
|
||
| // State | ||
| uint m_active_prog; | ||
| uint32_t m_color; | ||
|
|
||
| // Fragment programs | ||
| MYTH_GLGENPROGRAMSARBPROC m_glGenProgramsARB; | ||
| MYTH_GLBINDPROGRAMARBPROC m_glBindProgramARB; | ||
| MYTH_GLPROGRAMSTRINGARBPROC m_glProgramStringARB; | ||
| MYTH_GLPROGRAMLOCALPARAMETER4FARBPROC m_glProgramLocalParameter4fARB; | ||
| MYTH_GLDELETEPROGRAMSARBPROC m_glDeleteProgramsARB; | ||
| MYTH_GLGETPROGRAMIVARBPROC m_glGetProgramivARB; | ||
| }; | ||
|
|
||
| #endif // MYTHRENDEROPENGL1_H |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,87 @@ | ||
| #ifndef MYTHRENDEROPENGL2_H | ||
| #define MYTHRENDEROPENGL2_H | ||
|
|
||
| #include "mythrender_opengl.h" | ||
| #include "mythrender_opengl_defs2.h" | ||
|
|
||
| typedef enum | ||
| { | ||
| kShaderSimple = 0, | ||
| kShaderDefault = 1, | ||
| kShaderCount = 2, | ||
| } DefaultShaders; | ||
|
|
||
| class MythGLShaderObject; | ||
|
|
||
| class MPUBLIC MythRenderOpenGL2 : public MythRenderOpenGL | ||
| { | ||
| public: | ||
| MythRenderOpenGL2(const QGLFormat& format, QPaintDevice* device); | ||
| MythRenderOpenGL2(const QGLFormat& format); | ||
| virtual ~MythRenderOpenGL2(); | ||
|
|
||
| virtual uint CreateShaderObject(const QString &vert, const QString &frag); | ||
| virtual void DeleteShaderObject(uint obj); | ||
| virtual void EnableShaderObject(uint obj); | ||
| virtual void SetShaderParams(uint obj, void* vals, const char* uniform); | ||
|
|
||
| protected: | ||
| virtual void DrawBitmapPriv(uint tex, const QRect *src, const QRect *dst, | ||
| uint prog, int alpha, | ||
| int red, int green, int blue); | ||
| virtual void DrawBitmapPriv(uint *textures, uint texture_count, | ||
| const QRectF *src, const QRectF *dst, | ||
| uint prog); | ||
| virtual void DrawRectPriv(const QRect &area, bool drawFill, | ||
| const QColor &fillColor, bool drawLine, | ||
| int lineWidth, const QColor &lineColor, | ||
| int prog); | ||
| virtual void Init2DState(void); | ||
| virtual void InitProcs(void); | ||
| virtual void DeleteShaders(void); | ||
| virtual bool InitFeatures(void); | ||
| virtual void ResetVars(void); | ||
| virtual void ResetProcs(void); | ||
| virtual void DeleteOpenGLResources(void); | ||
| virtual void SetMatrixView(void); | ||
|
|
||
| void CreateDefaultShaders(void); | ||
| void DeleteDefaultShaders(void); | ||
| uint CreateShader(int type, const QString &source); | ||
| bool ValidateShaderObject(uint obj); | ||
| bool CheckObjectStatus(uint obj); | ||
| void OptimiseShaderSource(QString &source); | ||
|
|
||
| // Resources | ||
| QHash<GLuint, MythGLShaderObject> m_shader_objects; | ||
| uint m_shaders[kShaderCount]; | ||
|
|
||
| // State | ||
| uint m_active_obj; | ||
|
|
||
| // Procs | ||
| MYTH_GLCREATESHADEROBJECTPROC m_glCreateShaderObject; | ||
| MYTH_GLSHADERSOURCEPROC m_glShaderSource; | ||
| MYTH_GLCOMPILESHADERPROC m_glCompileShader; | ||
| MYTH_GLGETSHADERPROC m_glGetShader; | ||
| MYTH_GLGETSHADERINFOLOGPROC m_glGetShaderInfoLog; | ||
| MYTH_GLDELETESHADERPROC m_glDeleteShader; | ||
| MYTH_GLCREATEPROGRAMOBJECTPROC m_glCreateProgramObject; | ||
| MYTH_GLATTACHOBJECTPROC m_glAttachObject; | ||
| MYTH_GLLINKPROGRAMPROC m_glLinkProgram; | ||
| MYTH_GLUSEPROGRAMPROC m_glUseProgram; | ||
| MYTH_GLGETINFOLOGPROC m_glGetInfoLog; | ||
| MYTH_GLGETOBJECTPARAMETERIVPROC m_glGetObjectParameteriv; | ||
| MYTH_GLDETACHOBJECTPROC m_glDetachObject; | ||
| MYTH_GLDELETEOBJECTPROC m_glDeleteObject; | ||
| MYTH_GLGETUNIFORMLOCATIONPROC m_glGetUniformLocation; | ||
| MYTH_GLUNIFORM4FPROC m_glUniform4f; | ||
| MYTH_GLUNIFORMMATRIX4FVPROC m_glUniformMatrix4fv; | ||
| MYTH_GLVERTEXATTRIBPOINTERPROC m_glVertexAttribPointer; | ||
| MYTH_GLENABLEVERTEXATTRIBARRAYPROC m_glEnableVertexAttribArray; | ||
| MYTH_GLDISABLEVERTEXATTRIBARRAYPROC m_glDisableVertexAttribArray; | ||
| MYTH_GLBINDATTRIBLOCATIONPROC m_glBindAttribLocation; | ||
| MYTH_GLVERTEXATTRIB4FPROC m_glVertexAttrib4f; | ||
| }; | ||
|
|
||
| #endif // MYTHRENDEROPENGL2_H |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,33 @@ | ||
| #ifndef MYTHRENDER_OPENGL_DEFS1_H | ||
| #define MYTHRENDER_OPENGL_DEFS1_H | ||
|
|
||
| #ifndef GL_FRAGMENT_PROGRAM_ARB | ||
| #define GL_FRAGMENT_PROGRAM_ARB 0x8804 | ||
| #endif | ||
|
|
||
| #ifndef GL_PROGRAM_FORMAT_ASCII_ARB | ||
| #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 | ||
| #endif | ||
|
|
||
| #ifndef GL_PROGRAM_ERROR_POSITION_ARB | ||
| #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B | ||
| #endif | ||
|
|
||
| #ifndef GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB | ||
| #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 | ||
| #endif | ||
|
|
||
| typedef void (APIENTRY * MYTH_GLPROGRAMSTRINGARBPROC) | ||
| (GLenum target, GLenum format, GLsizei len, const GLvoid *string); | ||
| typedef void (APIENTRY * MYTH_GLBINDPROGRAMARBPROC) | ||
| (GLenum target, GLuint program); | ||
| typedef void (APIENTRY * MYTH_GLDELETEPROGRAMSARBPROC) | ||
| (GLsizei n, const GLuint *programs); | ||
| typedef void (APIENTRY * MYTH_GLGENPROGRAMSARBPROC) | ||
| (GLsizei n, GLuint *programs); | ||
| typedef void (APIENTRY * MYTH_GLPROGRAMLOCALPARAMETER4FARBPROC) | ||
| (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); | ||
| typedef void (APIENTRY * MYTH_GLGETPROGRAMIVARBPROC) | ||
| (GLenum target, GLenum pname, GLint *params); | ||
|
|
||
| #endif // MYTHRENDER_OPENGL_DEFS1_H |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,81 @@ | ||
| #ifndef MYTHRENDER_OPENGL_DEFS2_H | ||
| #define MYTHRENDER_OPENGL_DEFS2_H | ||
|
|
||
| #ifndef APIENTRY | ||
| #define APIENTRY | ||
| #endif | ||
|
|
||
| #ifndef GL_VERSION_2_0 | ||
| typedef char GLchar; | ||
| #endif | ||
| #ifndef GL_ARB_shader_objects | ||
| typedef char GLcharARB; | ||
| #endif | ||
|
|
||
| #ifndef GL_FRAGMENT_SHADER | ||
| #define GL_FRAGMENT_SHADER 0x8B30 | ||
| #endif | ||
| #ifndef GL_VERTEX_SHADER | ||
| #define GL_VERTEX_SHADER 0x8B31 | ||
| #endif | ||
| #ifndef GL_OBJECT_LINK_STATUS | ||
| #define GL_OBJECT_LINK_STATUS 0x8B82 | ||
| #endif | ||
| #ifndef GL_OBJECT_INFO_LOG_LENGTH | ||
| #define GL_OBJECT_INFO_LOG_LENGTH 0x8B84 | ||
| #endif | ||
|
|
||
| #ifndef GL_COMPILE_STATUS | ||
| #define GL_COMPILE_STATUS 0x8B81 | ||
| #endif | ||
| #ifndef GL_INFO_LOG_LENGTH | ||
| #define GL_INFO_LOG_LENGTH 0x8B84 | ||
| #endif | ||
|
|
||
| typedef GLuint ( * MYTH_GLCREATESHADEROBJECTPROC) | ||
| (GLenum shaderType); | ||
| typedef void ( * MYTH_GLSHADERSOURCEPROC) | ||
| (GLuint shader, int numOfStrings, const char **strings, int *lenOfStrings); | ||
| typedef void ( * MYTH_GLCOMPILESHADERPROC) | ||
| (GLuint shader); | ||
| typedef void ( * MYTH_GLGETSHADERPROC) | ||
| (GLuint shader, GLenum pname, GLint *params); | ||
| typedef void ( * MYTH_GLGETSHADERINFOLOGPROC) | ||
| (GLuint shader, GLint maxlength, GLint length, GLchar *infolog); | ||
| typedef void ( * MYTH_GLDELETESHADERPROC) | ||
| (GLuint shader); | ||
| typedef GLuint ( * MYTH_GLCREATEPROGRAMOBJECTPROC) | ||
| (void); | ||
| typedef void ( * MYTH_GLATTACHOBJECTPROC) | ||
| (GLuint program, GLuint shader); | ||
| typedef void ( * MYTH_GLLINKPROGRAMPROC) | ||
| (GLuint program); | ||
| typedef void ( * MYTH_GLUSEPROGRAMPROC) | ||
| (GLuint program); | ||
| typedef void ( * MYTH_GLGETINFOLOGPROC) | ||
| (GLuint object, int maxLen, int *len, char *log); | ||
| typedef void ( * MYTH_GLGETOBJECTPARAMETERIVPROC) | ||
| (GLuint object, GLenum type, int *param); | ||
| typedef void ( * MYTH_GLDETACHOBJECTPROC) | ||
| (GLuint program, GLuint shader); | ||
| typedef void ( * MYTH_GLDELETEOBJECTPROC) | ||
| (GLuint id); | ||
| typedef GLint ( * MYTH_GLGETUNIFORMLOCATIONPROC) | ||
| (GLuint program, const char *name); | ||
| typedef void ( * MYTH_GLUNIFORM4FPROC) | ||
| (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); | ||
| typedef void ( * MYTH_GLUNIFORMMATRIX4FVPROC) | ||
| (GLint location, GLint size, GLboolean transpose, const GLfloat *values); | ||
| typedef void ( * MYTH_GLVERTEXATTRIBPOINTERPROC) | ||
| (GLuint index, GLint size, GLenum type, GLboolean normalize, | ||
| GLsizei stride, const GLvoid *ptr); | ||
| typedef void ( * MYTH_GLENABLEVERTEXATTRIBARRAYPROC) | ||
| (GLuint index); | ||
| typedef void ( * MYTH_GLDISABLEVERTEXATTRIBARRAYPROC) | ||
| (GLuint index); | ||
| typedef void ( * MYTH_GLBINDATTRIBLOCATIONPROC) | ||
| (GLuint program, GLuint index, const GLcharARB *name); | ||
| typedef void ( * MYTH_GLVERTEXATTRIB4FPROC) | ||
| (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); | ||
|
|
||
| #endif // MYTHRENDER_OPENGL_DEFS2_H |