From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h | 476 +++++ .../SDL-3.2.8/src/render/opengl/SDL_render_gl.c | 1844 ++++++++++++++++++++ .../SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c | 545 ++++++ .../SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h | 52 + 4 files changed, 2917 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h create mode 100644 contrib/SDL-3.2.8/src/render/opengl/SDL_render_gl.c create mode 100644 contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c create mode 100644 contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h (limited to 'contrib/SDL-3.2.8/src/render/opengl') diff --git a/contrib/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h b/contrib/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h new file mode 100644 index 0000000..7e9f265 --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h @@ -0,0 +1,476 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* list of OpenGL functions sorted alphabetically + If you need to use a GL function from the SDL video subsystem, + change its entry from SDL_PROC_UNUSED to SDL_PROC and rebuild. +*/ +#define SDL_PROC_UNUSED(ret, func, params) + +SDL_PROC_UNUSED(void, glAccum, (GLenum, GLfloat)) +SDL_PROC_UNUSED(void, glAlphaFunc, (GLenum, GLclampf)) +SDL_PROC_UNUSED(GLboolean, glAreTexturesResident, + (GLsizei, const GLuint *, GLboolean *)) +SDL_PROC_UNUSED(void, glArrayElement, (GLint)) +SDL_PROC(void, glBegin, (GLenum)) +SDL_PROC(void, glBindTexture, (GLenum, GLuint)) +SDL_PROC_UNUSED(void, glBitmap, + (GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, + const GLubyte *)) +SDL_PROC(void, glBlendEquation, (GLenum)) +SDL_PROC_UNUSED(void, glBlendFunc, (GLenum, GLenum)) +SDL_PROC(void, glBlendFuncSeparate, (GLenum, GLenum, GLenum, GLenum)) +SDL_PROC_UNUSED(void, glCallList, (GLuint)) +SDL_PROC_UNUSED(void, glCallLists, (GLsizei, GLenum, const GLvoid *)) +SDL_PROC(void, glClear, (GLbitfield)) +SDL_PROC_UNUSED(void, glClearAccum, (GLfloat, GLfloat, GLfloat, GLfloat)) +SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf)) +SDL_PROC_UNUSED(void, glClearDepth, (GLclampd)) +SDL_PROC_UNUSED(void, glClearIndex, (GLfloat)) +SDL_PROC_UNUSED(void, glClearStencil, (GLint)) +SDL_PROC_UNUSED(void, glClipPlane, (GLenum, const GLdouble *)) +SDL_PROC_UNUSED(void, glColor3b, (GLbyte, GLbyte, GLbyte)) +SDL_PROC_UNUSED(void, glColor3bv, (const GLbyte *)) +SDL_PROC_UNUSED(void, glColor3d, (GLdouble, GLdouble, GLdouble)) +SDL_PROC_UNUSED(void, glColor3dv, (const GLdouble *)) +SDL_PROC_UNUSED(void, glColor3f, (GLfloat, GLfloat, GLfloat)) +SDL_PROC(void, glColor3fv, (const GLfloat *)) +SDL_PROC_UNUSED(void, glColor3i, (GLint, GLint, GLint)) +SDL_PROC_UNUSED(void, glColor3iv, (const GLint *)) +SDL_PROC_UNUSED(void, glColor3s, (GLshort, GLshort, GLshort)) +SDL_PROC_UNUSED(void, glColor3sv, (const GLshort *)) +SDL_PROC_UNUSED(void, glColor3ub, (GLubyte, GLubyte, GLubyte)) +SDL_PROC_UNUSED(void, glColor3ubv, (const GLubyte *)) +SDL_PROC_UNUSED(void, glColor3ui, (GLuint, GLuint, GLuint)) +SDL_PROC_UNUSED(void, glColor3uiv, (const GLuint *)) +SDL_PROC_UNUSED(void, glColor3us, (GLushort, GLushort, GLushort)) +SDL_PROC_UNUSED(void, glColor3usv, (const GLushort *)) +SDL_PROC_UNUSED(void, glColor4b, (GLbyte, GLbyte, GLbyte, GLbyte)) +SDL_PROC_UNUSED(void, glColor4bv, (const GLbyte *)) +SDL_PROC_UNUSED(void, glColor4d, (GLdouble, GLdouble, GLdouble, GLdouble)) +SDL_PROC_UNUSED(void, glColor4dv, (const GLdouble *)) +SDL_PROC(void, glColor4f, (GLfloat, GLfloat, GLfloat, GLfloat)) +SDL_PROC_UNUSED(void, glColor4fv, (const GLfloat *)) +SDL_PROC_UNUSED(void, glColor4i, (GLint, GLint, GLint, GLint)) +SDL_PROC_UNUSED(void, glColor4iv, (const GLint *)) +SDL_PROC_UNUSED(void, glColor4s, (GLshort, GLshort, GLshort, GLshort)) +SDL_PROC_UNUSED(void, glColor4sv, (const GLshort *)) +SDL_PROC(void, glColor4ub, + (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)) +SDL_PROC_UNUSED(void, glColor4ubv, (const GLubyte *v)) +SDL_PROC_UNUSED(void, glColor4ui, + (GLuint red, GLuint green, GLuint blue, GLuint alpha)) +SDL_PROC_UNUSED(void, glColor4uiv, (const GLuint *v)) +SDL_PROC_UNUSED(void, glColor4us, + (GLushort red, GLushort green, GLushort blue, GLushort alpha)) +SDL_PROC_UNUSED(void, glColor4usv, (const GLushort *v)) +SDL_PROC_UNUSED(void, glColorMask, + (GLboolean red, GLboolean green, GLboolean blue, + GLboolean alpha)) +SDL_PROC_UNUSED(void, glColorMaterial, (GLenum face, GLenum mode)) +SDL_PROC(void, glColorPointer, + (GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer)) +SDL_PROC_UNUSED(void, glCopyPixels, + (GLint x, GLint y, GLsizei width, GLsizei height, + GLenum type)) +SDL_PROC_UNUSED(void, glCopyTexImage1D, + (GLenum target, GLint level, GLenum internalFormat, GLint x, + GLint y, GLsizei width, GLint border)) +SDL_PROC_UNUSED(void, glCopyTexImage2D, + (GLenum target, GLint level, GLenum internalFormat, GLint x, + GLint y, GLsizei width, GLsizei height, GLint border)) +SDL_PROC_UNUSED(void, glCopyTexSubImage1D, + (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, + GLsizei width)) +SDL_PROC_UNUSED(void, glCopyTexSubImage2D, + (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLint x, GLint y, GLsizei width, GLsizei height)) +SDL_PROC_UNUSED(void, glCullFace, (GLenum mode)) +SDL_PROC_UNUSED(void, glDeleteLists, (GLuint list, GLsizei range)) +SDL_PROC(void, glDeleteTextures, (GLsizei n, const GLuint *textures)) +SDL_PROC(void, glDepthFunc, (GLenum func)) +SDL_PROC_UNUSED(void, glDepthMask, (GLboolean flag)) +SDL_PROC_UNUSED(void, glDepthRange, (GLclampd zNear, GLclampd zFar)) +SDL_PROC(void, glDisable, (GLenum cap)) +SDL_PROC(void, glDisableClientState, (GLenum array)) +SDL_PROC(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count)) +SDL_PROC_UNUSED(void, glDrawBuffer, (GLenum mode)) +SDL_PROC_UNUSED(void, glDrawElements, + (GLenum mode, GLsizei count, GLenum type, + const GLvoid *indices)) +SDL_PROC(void, glDrawPixels, + (GLsizei width, GLsizei height, GLenum format, GLenum type, + const GLvoid *pixels)) +SDL_PROC_UNUSED(void, glEdgeFlag, (GLboolean flag)) +SDL_PROC_UNUSED(void, glEdgeFlagPointer, + (GLsizei stride, const GLvoid *pointer)) +SDL_PROC_UNUSED(void, glEdgeFlagv, (const GLboolean *flag)) +SDL_PROC(void, glEnable, (GLenum cap)) +SDL_PROC(void, glEnableClientState, (GLenum array)) +SDL_PROC(void, glEnd, (void)) +SDL_PROC_UNUSED(void, glEndList, (void)) +SDL_PROC_UNUSED(void, glEvalCoord1d, (GLdouble u)) +SDL_PROC_UNUSED(void, glEvalCoord1dv, (const GLdouble *u)) +SDL_PROC_UNUSED(void, glEvalCoord1f, (GLfloat u)) +SDL_PROC_UNUSED(void, glEvalCoord1fv, (const GLfloat *u)) +SDL_PROC_UNUSED(void, glEvalCoord2d, (GLdouble u, GLdouble v)) +SDL_PROC_UNUSED(void, glEvalCoord2dv, (const GLdouble *u)) +SDL_PROC_UNUSED(void, glEvalCoord2f, (GLfloat u, GLfloat v)) +SDL_PROC_UNUSED(void, glEvalCoord2fv, (const GLfloat *u)) +SDL_PROC_UNUSED(void, glEvalMesh1, (GLenum mode, GLint i1, GLint i2)) +SDL_PROC_UNUSED(void, glEvalMesh2, + (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)) +SDL_PROC_UNUSED(void, glEvalPoint1, (GLint i)) +SDL_PROC_UNUSED(void, glEvalPoint2, (GLint i, GLint j)) +SDL_PROC_UNUSED(void, glFeedbackBuffer, + (GLsizei size, GLenum type, GLfloat *buffer)) +SDL_PROC_UNUSED(void, glFinish, (void)) +SDL_PROC_UNUSED(void, glFlush, (void)) +SDL_PROC_UNUSED(void, glFogf, (GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glFogfv, (GLenum pname, const GLfloat *params)) +SDL_PROC_UNUSED(void, glFogi, (GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glFogiv, (GLenum pname, const GLint *params)) +SDL_PROC_UNUSED(void, glFrontFace, (GLenum mode)) +SDL_PROC_UNUSED(void, glFrustum, + (GLdouble left, GLdouble right, GLdouble bottom, + GLdouble top, GLdouble zNear, GLdouble zFar)) +SDL_PROC_UNUSED(GLuint, glGenLists, (GLsizei range)) +SDL_PROC(void, glGenTextures, (GLsizei n, GLuint *textures)) +SDL_PROC_UNUSED(void, glGetBooleanv, (GLenum pname, GLboolean *params)) +SDL_PROC_UNUSED(void, glGetClipPlane, (GLenum plane, GLdouble *equation)) +SDL_PROC_UNUSED(void, glGetDoublev, (GLenum pname, GLdouble *params)) +SDL_PROC(GLenum, glGetError, (void)) +SDL_PROC(void, glGetFloatv, (GLenum pname, GLfloat *params)) +SDL_PROC(void, glGetIntegerv, (GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glGetLightfv, + (GLenum light, GLenum pname, GLfloat *params)) +SDL_PROC_UNUSED(void, glGetLightiv, + (GLenum light, GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glGetMapdv, (GLenum target, GLenum query, GLdouble *v)) +SDL_PROC_UNUSED(void, glGetMapfv, (GLenum target, GLenum query, GLfloat *v)) +SDL_PROC_UNUSED(void, glGetMapiv, (GLenum target, GLenum query, GLint *v)) +SDL_PROC_UNUSED(void, glGetMaterialfv, + (GLenum face, GLenum pname, GLfloat *params)) +SDL_PROC_UNUSED(void, glGetMaterialiv, + (GLenum face, GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glGetPixelMapfv, (GLenum map, GLfloat *values)) +SDL_PROC_UNUSED(void, glGetPixelMapuiv, (GLenum map, GLuint *values)) +SDL_PROC_UNUSED(void, glGetPixelMapusv, (GLenum map, GLushort *values)) +SDL_PROC(void, glGetPointerv, (GLenum pname, GLvoid **params)) +SDL_PROC_UNUSED(void, glGetPolygonStipple, (GLubyte * mask)) +SDL_PROC(const GLubyte *, glGetString, (GLenum name)) +SDL_PROC_UNUSED(void, glGetTexEnvfv, + (GLenum target, GLenum pname, GLfloat *params)) +SDL_PROC_UNUSED(void, glGetTexEnviv, + (GLenum target, GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glGetTexGendv, + (GLenum coord, GLenum pname, GLdouble *params)) +SDL_PROC_UNUSED(void, glGetTexGenfv, + (GLenum coord, GLenum pname, GLfloat *params)) +SDL_PROC_UNUSED(void, glGetTexGeniv, + (GLenum coord, GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glGetTexImage, + (GLenum target, GLint level, GLenum format, GLenum type, + GLvoid *pixels)) +SDL_PROC_UNUSED(void, glGetTexLevelParameterfv, + (GLenum target, GLint level, GLenum pname, GLfloat *params)) +SDL_PROC_UNUSED(void, glGetTexLevelParameteriv, + (GLenum target, GLint level, GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glGetTexParameterfv, + (GLenum target, GLenum pname, GLfloat *params)) +SDL_PROC_UNUSED(void, glGetTexParameteriv, + (GLenum target, GLenum pname, GLint *params)) +SDL_PROC_UNUSED(void, glHint, (GLenum target, GLenum mode)) +SDL_PROC_UNUSED(void, glIndexMask, (GLuint mask)) +SDL_PROC_UNUSED(void, glIndexPointer, + (GLenum type, GLsizei stride, const GLvoid *pointer)) +SDL_PROC_UNUSED(void, glIndexd, (GLdouble c)) +SDL_PROC_UNUSED(void, glIndexdv, (const GLdouble *c)) +SDL_PROC_UNUSED(void, glIndexf, (GLfloat c)) +SDL_PROC_UNUSED(void, glIndexfv, (const GLfloat *c)) +SDL_PROC_UNUSED(void, glIndexi, (GLint c)) +SDL_PROC_UNUSED(void, glIndexiv, (const GLint *c)) +SDL_PROC_UNUSED(void, glIndexs, (GLshort c)) +SDL_PROC_UNUSED(void, glIndexsv, (const GLshort *c)) +SDL_PROC_UNUSED(void, glIndexub, (GLubyte c)) +SDL_PROC_UNUSED(void, glIndexubv, (const GLubyte *c)) +SDL_PROC_UNUSED(void, glInitNames, (void)) +SDL_PROC_UNUSED(void, glInterleavedArrays, + (GLenum format, GLsizei stride, const GLvoid *pointer)) +SDL_PROC_UNUSED(GLboolean, glIsEnabled, (GLenum cap)) +SDL_PROC_UNUSED(GLboolean, glIsList, (GLuint list)) +SDL_PROC_UNUSED(GLboolean, glIsTexture, (GLuint texture)) +SDL_PROC_UNUSED(void, glLightModelf, (GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glLightModelfv, (GLenum pname, const GLfloat *params)) +SDL_PROC_UNUSED(void, glLightModeli, (GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glLightModeliv, (GLenum pname, const GLint *params)) +SDL_PROC_UNUSED(void, glLightf, (GLenum light, GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glLightfv, + (GLenum light, GLenum pname, const GLfloat *params)) +SDL_PROC_UNUSED(void, glLighti, (GLenum light, GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glLightiv, + (GLenum light, GLenum pname, const GLint *params)) +SDL_PROC_UNUSED(void, glLineStipple, (GLint factor, GLushort pattern)) +SDL_PROC(void, glLineWidth, (GLfloat width)) +SDL_PROC_UNUSED(void, glListBase, (GLuint base)) +SDL_PROC(void, glLoadIdentity, (void)) +SDL_PROC_UNUSED(void, glLoadMatrixd, (const GLdouble *m)) +SDL_PROC_UNUSED(void, glLoadMatrixf, (const GLfloat *m)) +SDL_PROC_UNUSED(void, glLoadName, (GLuint name)) +SDL_PROC_UNUSED(void, glLogicOp, (GLenum opcode)) +SDL_PROC_UNUSED(void, glMap1d, + (GLenum target, GLdouble u1, GLdouble u2, GLint stride, + GLint order, const GLdouble *points)) +SDL_PROC_UNUSED(void, glMap1f, + (GLenum target, GLfloat u1, GLfloat u2, GLint stride, + GLint order, const GLfloat *points)) +SDL_PROC_UNUSED(void, glMap2d, + (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, + GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, + GLint vorder, const GLdouble *points)) +SDL_PROC_UNUSED(void, glMap2f, + (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, + GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, + GLint vorder, const GLfloat *points)) +SDL_PROC_UNUSED(void, glMapGrid1d, (GLint un, GLdouble u1, GLdouble u2)) +SDL_PROC_UNUSED(void, glMapGrid1f, (GLint un, GLfloat u1, GLfloat u2)) +SDL_PROC_UNUSED(void, glMapGrid2d, + (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, + GLdouble v2)) +SDL_PROC_UNUSED(void, glMapGrid2f, + (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, + GLfloat v2)) +SDL_PROC_UNUSED(void, glMaterialf, (GLenum face, GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glMaterialfv, + (GLenum face, GLenum pname, const GLfloat *params)) +SDL_PROC_UNUSED(void, glMateriali, (GLenum face, GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glMaterialiv, + (GLenum face, GLenum pname, const GLint *params)) +SDL_PROC(void, glMatrixMode, (GLenum mode)) +SDL_PROC_UNUSED(void, glMultMatrixd, (const GLdouble *m)) +SDL_PROC_UNUSED(void, glMultMatrixf, (const GLfloat *m)) +SDL_PROC_UNUSED(void, glNewList, (GLuint list, GLenum mode)) +SDL_PROC_UNUSED(void, glNormal3b, (GLbyte nx, GLbyte ny, GLbyte nz)) +SDL_PROC_UNUSED(void, glNormal3bv, (const GLbyte *v)) +SDL_PROC_UNUSED(void, glNormal3d, (GLdouble nx, GLdouble ny, GLdouble nz)) +SDL_PROC_UNUSED(void, glNormal3dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glNormal3f, (GLfloat nx, GLfloat ny, GLfloat nz)) +SDL_PROC_UNUSED(void, glNormal3fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glNormal3i, (GLint nx, GLint ny, GLint nz)) +SDL_PROC_UNUSED(void, glNormal3iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glNormal3s, (GLshort nx, GLshort ny, GLshort nz)) +SDL_PROC_UNUSED(void, glNormal3sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glNormalPointer, + (GLenum type, GLsizei stride, const GLvoid *pointer)) +SDL_PROC(void, glOrtho, + (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, + GLdouble zNear, GLdouble zFar)) +SDL_PROC_UNUSED(void, glPassThrough, (GLfloat token)) +SDL_PROC_UNUSED(void, glPixelMapfv, + (GLenum map, GLsizei mapsize, const GLfloat *values)) +SDL_PROC_UNUSED(void, glPixelMapuiv, + (GLenum map, GLsizei mapsize, const GLuint *values)) +SDL_PROC_UNUSED(void, glPixelMapusv, + (GLenum map, GLsizei mapsize, const GLushort *values)) +SDL_PROC_UNUSED(void, glPixelStoref, (GLenum pname, GLfloat param)) +SDL_PROC(void, glPixelStorei, (GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glPixelTransferf, (GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glPixelTransferi, (GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glPixelZoom, (GLfloat xfactor, GLfloat yfactor)) +SDL_PROC(void, glPointSize, (GLfloat size)) +SDL_PROC_UNUSED(void, glPolygonMode, (GLenum face, GLenum mode)) +SDL_PROC_UNUSED(void, glPolygonOffset, (GLfloat factor, GLfloat units)) +SDL_PROC_UNUSED(void, glPolygonStipple, (const GLubyte *mask)) +SDL_PROC_UNUSED(void, glPopAttrib, (void)) +SDL_PROC_UNUSED(void, glPopClientAttrib, (void)) +SDL_PROC_UNUSED(void, glPopMatrix, (void)) +SDL_PROC_UNUSED(void, glPopName, (void)) +SDL_PROC_UNUSED(void, glPrioritizeTextures, + (GLsizei n, const GLuint *textures, + const GLclampf *priorities)) +SDL_PROC_UNUSED(void, glPushAttrib, (GLbitfield mask)) +SDL_PROC_UNUSED(void, glPushClientAttrib, (GLbitfield mask)) +SDL_PROC_UNUSED(void, glPushMatrix, (void)) +SDL_PROC_UNUSED(void, glPushName, (GLuint name)) +SDL_PROC_UNUSED(void, glRasterPos2d, (GLdouble x, GLdouble y)) +SDL_PROC_UNUSED(void, glRasterPos2dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glRasterPos2f, (GLfloat x, GLfloat y)) +SDL_PROC_UNUSED(void, glRasterPos2fv, (const GLfloat *v)) +SDL_PROC(void, glRasterPos2i, (GLint x, GLint y)) +SDL_PROC_UNUSED(void, glRasterPos2iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glRasterPos2s, (GLshort x, GLshort y)) +SDL_PROC_UNUSED(void, glRasterPos2sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glRasterPos3d, (GLdouble x, GLdouble y, GLdouble z)) +SDL_PROC_UNUSED(void, glRasterPos3dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glRasterPos3f, (GLfloat x, GLfloat y, GLfloat z)) +SDL_PROC_UNUSED(void, glRasterPos3fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glRasterPos3i, (GLint x, GLint y, GLint z)) +SDL_PROC_UNUSED(void, glRasterPos3iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glRasterPos3s, (GLshort x, GLshort y, GLshort z)) +SDL_PROC_UNUSED(void, glRasterPos3sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glRasterPos4d, + (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) +SDL_PROC_UNUSED(void, glRasterPos4dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glRasterPos4f, + (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) +SDL_PROC_UNUSED(void, glRasterPos4fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glRasterPos4i, (GLint x, GLint y, GLint z, GLint w)) +SDL_PROC_UNUSED(void, glRasterPos4iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glRasterPos4s, + (GLshort x, GLshort y, GLshort z, GLshort w)) +SDL_PROC_UNUSED(void, glRasterPos4sv, (const GLshort *v)) +SDL_PROC(void, glReadBuffer, (GLenum mode)) +SDL_PROC(void, glReadPixels, + (GLint x, GLint y, GLsizei width, GLsizei height, + GLenum format, GLenum type, GLvoid *pixels)) +SDL_PROC_UNUSED(void, glRectd, + (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)) +SDL_PROC_UNUSED(void, glRectdv, (const GLdouble *v1, const GLdouble *v2)) +SDL_PROC(void, glRectf, + (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)) +SDL_PROC_UNUSED(void, glRectfv, (const GLfloat *v1, const GLfloat *v2)) +SDL_PROC_UNUSED(void, glRecti, (GLint x1, GLint y1, GLint x2, GLint y2)) +SDL_PROC_UNUSED(void, glRectiv, (const GLint *v1, const GLint *v2)) +SDL_PROC_UNUSED(void, glRects, + (GLshort x1, GLshort y1, GLshort x2, GLshort y2)) +SDL_PROC_UNUSED(void, glRectsv, (const GLshort *v1, const GLshort *v2)) +SDL_PROC_UNUSED(GLint, glRenderMode, (GLenum mode)) +SDL_PROC_UNUSED(void, glRotated, + (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)) +SDL_PROC(void, glRotatef, + (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)) +SDL_PROC_UNUSED(void, glScaled, (GLdouble x, GLdouble y, GLdouble z)) +SDL_PROC_UNUSED(void, glScalef, (GLfloat x, GLfloat y, GLfloat z)) +SDL_PROC(void, glScissor, (GLint x, GLint y, GLsizei width, GLsizei height)) +SDL_PROC_UNUSED(void, glSelectBuffer, (GLsizei size, GLuint *buffer)) +SDL_PROC(void, glShadeModel, (GLenum mode)) +SDL_PROC_UNUSED(void, glStencilFunc, (GLenum func, GLint ref, GLuint mask)) +SDL_PROC_UNUSED(void, glStencilMask, (GLuint mask)) +SDL_PROC_UNUSED(void, glStencilOp, (GLenum fail, GLenum zfail, GLenum zpass)) +SDL_PROC_UNUSED(void, glTexCoord1d, (GLdouble s)) +SDL_PROC_UNUSED(void, glTexCoord1dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glTexCoord1f, (GLfloat s)) +SDL_PROC_UNUSED(void, glTexCoord1fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glTexCoord1i, (GLint s)) +SDL_PROC_UNUSED(void, glTexCoord1iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glTexCoord1s, (GLshort s)) +SDL_PROC_UNUSED(void, glTexCoord1sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glTexCoord2d, (GLdouble s, GLdouble t)) +SDL_PROC_UNUSED(void, glTexCoord2dv, (const GLdouble *v)) +SDL_PROC(void, glTexCoord2f, (GLfloat s, GLfloat t)) +SDL_PROC_UNUSED(void, glTexCoord2fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glTexCoord2i, (GLint s, GLint t)) +SDL_PROC_UNUSED(void, glTexCoord2iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glTexCoord2s, (GLshort s, GLshort t)) +SDL_PROC_UNUSED(void, glTexCoord2sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glTexCoord3d, (GLdouble s, GLdouble t, GLdouble r)) +SDL_PROC_UNUSED(void, glTexCoord3dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glTexCoord3f, (GLfloat s, GLfloat t, GLfloat r)) +SDL_PROC_UNUSED(void, glTexCoord3fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glTexCoord3i, (GLint s, GLint t, GLint r)) +SDL_PROC_UNUSED(void, glTexCoord3iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glTexCoord3s, (GLshort s, GLshort t, GLshort r)) +SDL_PROC_UNUSED(void, glTexCoord3sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glTexCoord4d, + (GLdouble s, GLdouble t, GLdouble r, GLdouble q)) +SDL_PROC_UNUSED(void, glTexCoord4dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glTexCoord4f, + (GLfloat s, GLfloat t, GLfloat r, GLfloat q)) +SDL_PROC_UNUSED(void, glTexCoord4fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glTexCoord4i, (GLint s, GLint t, GLint r, GLint q)) +SDL_PROC_UNUSED(void, glTexCoord4iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glTexCoord4s, + (GLshort s, GLshort t, GLshort r, GLshort q)) +SDL_PROC_UNUSED(void, glTexCoord4sv, (const GLshort *v)) +SDL_PROC(void, glTexCoordPointer, + (GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer)) +SDL_PROC(void, glTexEnvf, (GLenum target, GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glTexEnvfv, + (GLenum target, GLenum pname, const GLfloat *params)) +SDL_PROC_UNUSED(void, glTexEnvi, (GLenum target, GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glTexEnviv, + (GLenum target, GLenum pname, const GLint *params)) +SDL_PROC_UNUSED(void, glTexGend, (GLenum coord, GLenum pname, GLdouble param)) +SDL_PROC_UNUSED(void, glTexGendv, + (GLenum coord, GLenum pname, const GLdouble *params)) +SDL_PROC_UNUSED(void, glTexGenf, (GLenum coord, GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glTexGenfv, + (GLenum coord, GLenum pname, const GLfloat *params)) +SDL_PROC_UNUSED(void, glTexGeni, (GLenum coord, GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glTexGeniv, + (GLenum coord, GLenum pname, const GLint *params)) +SDL_PROC_UNUSED(void, glTexImage1D, + (GLenum target, GLint level, GLint internalformat, + GLsizei width, GLint border, GLenum format, GLenum type, + const GLvoid *pixels)) +SDL_PROC(void, glTexImage2D, + (GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + const GLvoid *pixels)) +SDL_PROC_UNUSED(void, glTexParameterf, + (GLenum target, GLenum pname, GLfloat param)) +SDL_PROC_UNUSED(void, glTexParameterfv, + (GLenum target, GLenum pname, const GLfloat *params)) +SDL_PROC(void, glTexParameteri, (GLenum target, GLenum pname, GLint param)) +SDL_PROC_UNUSED(void, glTexParameteriv, + (GLenum target, GLenum pname, const GLint *params)) +SDL_PROC_UNUSED(void, glTexSubImage1D, + (GLenum target, GLint level, GLint xoffset, GLsizei width, + GLenum format, GLenum type, const GLvoid *pixels)) +SDL_PROC(void, glTexSubImage2D, + (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, GLenum format, GLenum type, + const GLvoid *pixels)) +SDL_PROC_UNUSED(void, glTranslated, (GLdouble x, GLdouble y, GLdouble z)) +SDL_PROC_UNUSED(void, glTranslatef, (GLfloat x, GLfloat y, GLfloat z)) +SDL_PROC_UNUSED(void, glVertex2d, (GLdouble x, GLdouble y)) +SDL_PROC_UNUSED(void, glVertex2dv, (const GLdouble *v)) +SDL_PROC(void, glVertex2f, (GLfloat x, GLfloat y)) +SDL_PROC_UNUSED(void, glVertex2fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glVertex2i, (GLint x, GLint y)) +SDL_PROC_UNUSED(void, glVertex2iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glVertex2s, (GLshort x, GLshort y)) +SDL_PROC_UNUSED(void, glVertex2sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glVertex3d, (GLdouble x, GLdouble y, GLdouble z)) +SDL_PROC_UNUSED(void, glVertex3dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glVertex3f, (GLfloat x, GLfloat y, GLfloat z)) +SDL_PROC(void, glVertex3fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glVertex3i, (GLint x, GLint y, GLint z)) +SDL_PROC_UNUSED(void, glVertex3iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glVertex3s, (GLshort x, GLshort y, GLshort z)) +SDL_PROC_UNUSED(void, glVertex3sv, (const GLshort *v)) +SDL_PROC_UNUSED(void, glVertex4d, + (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) +SDL_PROC_UNUSED(void, glVertex4dv, (const GLdouble *v)) +SDL_PROC_UNUSED(void, glVertex4f, + (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) +SDL_PROC_UNUSED(void, glVertex4fv, (const GLfloat *v)) +SDL_PROC_UNUSED(void, glVertex4i, (GLint x, GLint y, GLint z, GLint w)) +SDL_PROC_UNUSED(void, glVertex4iv, (const GLint *v)) +SDL_PROC_UNUSED(void, glVertex4s, + (GLshort x, GLshort y, GLshort z, GLshort w)) +SDL_PROC_UNUSED(void, glVertex4sv, (const GLshort *v)) +SDL_PROC(void, glVertexPointer, + (GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer)) +SDL_PROC(void, glViewport, (GLint x, GLint y, GLsizei width, GLsizei height)) diff --git a/contrib/SDL-3.2.8/src/render/opengl/SDL_render_gl.c b/contrib/SDL-3.2.8/src/render/opengl/SDL_render_gl.c new file mode 100644 index 0000000..d534438 --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/opengl/SDL_render_gl.c @@ -0,0 +1,1844 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifdef SDL_VIDEO_RENDER_OGL +#include "../../video/SDL_sysvideo.h" // For SDL_RecreateWindow +#include +#include "../SDL_sysrender.h" +#include "SDL_shaders_gl.h" +#include "../../video/SDL_pixels_c.h" + +#ifdef SDL_PLATFORM_MACOS +#include +#endif + +#ifdef SDL_VIDEO_VITA_PVR_OGL +#include +#include +#endif + +/* To prevent unnecessary window recreation, + * these should match the defaults selected in SDL_GL_ResetAttributes + */ + +#define RENDERER_CONTEXT_MAJOR 2 +#define RENDERER_CONTEXT_MINOR 1 + +// OpenGL renderer implementation + +/* Details on optimizing the texture path on macOS: + http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/opengl_texturedata.html +*/ + +typedef struct GL_FBOList GL_FBOList; + +struct GL_FBOList +{ + Uint32 w, h; + GLuint FBO; + GL_FBOList *next; +}; + +typedef struct +{ + bool viewport_dirty; + SDL_Rect viewport; + SDL_Texture *texture; + SDL_Texture *target; + int drawablew; + int drawableh; + SDL_BlendMode blend; + GL_Shader shader; + const float *shader_params; + bool cliprect_enabled_dirty; + bool cliprect_enabled; + bool cliprect_dirty; + SDL_Rect cliprect; + bool texturing; + bool texturing_dirty; + bool vertex_array; + bool color_array; + bool texture_array; + bool color_dirty; + SDL_FColor color; + bool clear_color_dirty; + SDL_FColor clear_color; +} GL_DrawStateCache; + +typedef struct +{ + SDL_GLContext context; + + bool debug_enabled; + bool GL_ARB_debug_output_supported; + int errors; + char **error_messages; + GLDEBUGPROCARB next_error_callback; + GLvoid *next_error_userparam; + + GLenum textype; + + bool GL_ARB_texture_non_power_of_two_supported; + bool GL_ARB_texture_rectangle_supported; + bool GL_EXT_framebuffer_object_supported; + GL_FBOList *framebuffers; + + // OpenGL functions +#define SDL_PROC(ret, func, params) ret (APIENTRY *func) params; +#include "SDL_glfuncs.h" +#undef SDL_PROC + + // Multitexture support + bool GL_ARB_multitexture_supported; + PFNGLACTIVETEXTUREARBPROC glActiveTextureARB; + GLint num_texture_units; + + PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT; + PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT; + PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT; + PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT; + PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT; + + // Shader support + GL_ShaderContext *shaders; + + GL_DrawStateCache drawstate; +} GL_RenderData; + +typedef struct +{ + GLuint texture; + bool texture_external; + GLfloat texw; + GLfloat texh; + GLenum format; + GLenum formattype; + GL_Shader shader; + const float *shader_params; + void *pixels; + int pitch; + SDL_Rect locked_rect; + +#ifdef SDL_HAVE_YUV + // YUV texture support + bool yuv; + bool nv12; + GLuint utexture; + bool utexture_external; + GLuint vtexture; + bool vtexture_external; +#endif + + GL_FBOList *fbo; +} GL_TextureData; + +static const char *GL_TranslateError(GLenum error) +{ +#define GL_ERROR_TRANSLATE(e) \ + case e: \ + return #e; + switch (error) { + GL_ERROR_TRANSLATE(GL_INVALID_ENUM) + GL_ERROR_TRANSLATE(GL_INVALID_VALUE) + GL_ERROR_TRANSLATE(GL_INVALID_OPERATION) + GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY) + GL_ERROR_TRANSLATE(GL_NO_ERROR) + GL_ERROR_TRANSLATE(GL_STACK_OVERFLOW) + GL_ERROR_TRANSLATE(GL_STACK_UNDERFLOW) + GL_ERROR_TRANSLATE(GL_TABLE_TOO_LARGE) + default: + return "UNKNOWN"; + } +#undef GL_ERROR_TRANSLATE +} + +static void GL_ClearErrors(SDL_Renderer *renderer) +{ + GL_RenderData *data = (GL_RenderData *)renderer->internal; + + if (!data->debug_enabled) { + return; + } + if (data->GL_ARB_debug_output_supported) { + if (data->errors) { + int i; + for (i = 0; i < data->errors; ++i) { + SDL_free(data->error_messages[i]); + } + SDL_free(data->error_messages); + + data->errors = 0; + data->error_messages = NULL; + } + } else if (data->glGetError) { + while (data->glGetError() != GL_NO_ERROR) { + // continue; + } + } +} + +static bool GL_CheckAllErrors(const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function) +{ + GL_RenderData *data = (GL_RenderData *)renderer->internal; + bool result = true; + + if (!data->debug_enabled) { + return true; + } + if (data->GL_ARB_debug_output_supported) { + if (data->errors) { + int i; + for (i = 0; i < data->errors; ++i) { + SDL_SetError("%s: %s (%d): %s %s", prefix, file, line, function, data->error_messages[i]); + result = false; + } + GL_ClearErrors(renderer); + } + } else { + // check gl errors (can return multiple errors) + for (;;) { + GLenum error = data->glGetError(); + if (error != GL_NO_ERROR) { + if (prefix == NULL || prefix[0] == '\0') { + prefix = "generic"; + } + SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error); + result = false; + } else { + break; + } + } + } + return result; +} + +#if 0 +#define GL_CheckError(prefix, renderer) +#else +#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION) +#endif + +static bool GL_LoadFunctions(GL_RenderData *data) +{ +#ifdef __SDL_NOGETPROCADDR__ +#define SDL_PROC(ret, func, params) data->func = func; +#else + bool result = true; +#define SDL_PROC(ret, func, params) \ + do { \ + data->func = (ret (APIENTRY *) params)SDL_GL_GetProcAddress(#func); \ + if (!data->func) { \ + result = SDL_SetError("Couldn't load GL function %s: %s", #func, SDL_GetError()); \ + } \ + } while (0); +#endif // __SDL_NOGETPROCADDR__ + +#include "SDL_glfuncs.h" +#undef SDL_PROC + return result; +} + +static bool GL_ActivateRenderer(SDL_Renderer *renderer) +{ + GL_RenderData *data = (GL_RenderData *)renderer->internal; + + if (SDL_GL_GetCurrentContext() != data->context) { + if (!SDL_GL_MakeCurrent(renderer->window, data->context)) { + return false; + } + } + + GL_ClearErrors(renderer); + + return true; +} + +static void APIENTRY GL_HandleDebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, const void *userParam) +{ + SDL_Renderer *renderer = (SDL_Renderer *)userParam; + GL_RenderData *data = (GL_RenderData *)renderer->internal; + + if (type == GL_DEBUG_TYPE_ERROR_ARB) { + // Record this error + int errors = data->errors + 1; + char **error_messages = (char **)SDL_realloc(data->error_messages, errors * sizeof(*data->error_messages)); + if (error_messages) { + data->errors = errors; + data->error_messages = error_messages; + data->error_messages[data->errors - 1] = SDL_strdup(message); + } + } + + // If there's another error callback, pass it along, otherwise log it + if (data->next_error_callback) { + data->next_error_callback(source, type, id, severity, length, message, data->next_error_userparam); + } else { + if (type == GL_DEBUG_TYPE_ERROR_ARB) { + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", message); + } else { + SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "%s", message); + } + } +} + +static GL_FBOList *GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h) +{ + GL_FBOList *result = data->framebuffers; + + while (result && ((result->w != w) || (result->h != h))) { + result = result->next; + } + + if (!result) { + result = (GL_FBOList *)SDL_malloc(sizeof(GL_FBOList)); + if (result) { + result->w = w; + result->h = h; + data->glGenFramebuffersEXT(1, &result->FBO); + result->next = data->framebuffers; + data->framebuffers = result; + } + } + return result; +} + +static void GL_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event) +{ + /* If the window x/y/w/h changed at all, assume the viewport has been + * changed behind our backs. x/y changes might seem weird but viewport + * resets have been observed on macOS at minimum! + */ + if (event->type == SDL_EVENT_WINDOW_RESIZED || + event->type == SDL_EVENT_WINDOW_MOVED) { + GL_RenderData *data = (GL_RenderData *)renderer->internal; + data->drawstate.viewport_dirty = true; + } +} + +static GLenum GetBlendFunc(SDL_BlendFactor factor) +{ + switch (factor) { + case SDL_BLENDFACTOR_ZERO: + return GL_ZERO; + case SDL_BLENDFACTOR_ONE: + return GL_ONE; + case SDL_BLENDFACTOR_SRC_COLOR: + return GL_SRC_COLOR; + case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR: + return GL_ONE_MINUS_SRC_COLOR; + case SDL_BLENDFACTOR_SRC_ALPHA: + return GL_SRC_ALPHA; + case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA: + return GL_ONE_MINUS_SRC_ALPHA; + case SDL_BLENDFACTOR_DST_COLOR: + return GL_DST_COLOR; + case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR: + return GL_ONE_MINUS_DST_COLOR; + case SDL_BLENDFACTOR_DST_ALPHA: + return GL_DST_ALPHA; + case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA: + return GL_ONE_MINUS_DST_ALPHA; + default: + return GL_INVALID_ENUM; + } +} + +static GLenum GetBlendEquation(SDL_BlendOperation operation) +{ + switch (operation) { + case SDL_BLENDOPERATION_ADD: + return GL_FUNC_ADD; + case SDL_BLENDOPERATION_SUBTRACT: + return GL_FUNC_SUBTRACT; + case SDL_BLENDOPERATION_REV_SUBTRACT: + return GL_FUNC_REVERSE_SUBTRACT; + case SDL_BLENDOPERATION_MINIMUM: + return GL_MIN; + case SDL_BLENDOPERATION_MAXIMUM: + return GL_MAX; + default: + return GL_INVALID_ENUM; + } +} + +static bool GL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode) +{ + SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode); + SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode); + SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode); + SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode); + SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode); + SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode); + + if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM || + GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM || + GetBlendEquation(colorOperation) == GL_INVALID_ENUM || + GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM || + GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM || + GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) { + return false; + } + if (colorOperation != alphaOperation) { + return false; + } + return true; +} + +static bool convert_format(Uint32 pixel_format, GLint *internalFormat, GLenum *format, GLenum *type) +{ + switch (pixel_format) { + case SDL_PIXELFORMAT_ARGB8888: + case SDL_PIXELFORMAT_XRGB8888: + *internalFormat = GL_RGBA8; + *format = GL_BGRA; + *type = GL_UNSIGNED_BYTE; // previously GL_UNSIGNED_INT_8_8_8_8_REV, seeing if this is better in modern times. + break; + case SDL_PIXELFORMAT_ABGR8888: + case SDL_PIXELFORMAT_XBGR8888: + *internalFormat = GL_RGBA8; + *format = GL_RGBA; + *type = GL_UNSIGNED_BYTE; // previously GL_UNSIGNED_INT_8_8_8_8_REV, seeing if this is better in modern times. + break; + case SDL_PIXELFORMAT_YV12: + case SDL_PIXELFORMAT_IYUV: + case SDL_PIXELFORMAT_NV12: + case SDL_PIXELFORMAT_NV21: + *internalFormat = GL_LUMINANCE; + *format = GL_LUMINANCE; + *type = GL_UNSIGNED_BYTE; + break; +#ifdef SDL_PLATFORM_MACOS + case SDL_PIXELFORMAT_UYVY: + *internalFormat = GL_RGB8; + *format = GL_YCBCR_422_APPLE; + *type = GL_UNSIGNED_SHORT_8_8_APPLE; + break; +#endif + default: + return false; + } + return true; +} + +static bool GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props) +{ + GL_RenderData *renderdata = (GL_RenderData *)renderer->internal; + const GLenum textype = renderdata->textype; + GL_TextureData *data; + GLint internalFormat; + GLenum format, type; + int texture_w, texture_h; + GLenum scaleMode; + + GL_ActivateRenderer(renderer); + + renderdata->drawstate.texture = NULL; // we trash this state. + renderdata->drawstate.texturing_dirty = true; // we trash this state. + + if (texture->access == SDL_TEXTUREACCESS_TARGET && + !renderdata->GL_EXT_framebuffer_object_supported) { + return SDL_SetError("Render targets not supported by OpenGL"); + } + + if (!convert_format(texture->format, &internalFormat, &format, &type)) { + return SDL_SetError("Texture format %s not supported by OpenGL", + SDL_GetPixelFormatName(texture->format)); + } + + data = (GL_TextureData *)SDL_calloc(1, sizeof(*data)); + if (!data) { + return false; + } + + if (texture->access == SDL_TEXTUREACCESS_STREAMING) { + size_t size; + data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format); + size = (size_t)texture->h * data->pitch; + if (texture->format == SDL_PIXELFORMAT_YV12 || + texture->format == SDL_PIXELFORMAT_IYUV) { + // Need to add size for the U and V planes + size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2); + } + if (texture->format == SDL_PIXELFORMAT_NV12 || + texture->format == SDL_PIXELFORMAT_NV21) { + // Need to add size for the U/V plane + size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2); + } + data->pixels = SDL_calloc(1, size); + if (!data->pixels) { + SDL_free(data); + return false; + } + } + + if (texture->access == SDL_TEXTUREACCESS_TARGET) { + data->fbo = GL_GetFBO(renderdata, texture->w, texture->h); + } else { + data->fbo = NULL; + } + + data->texture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER, 0); + if (data->texture) { + data->texture_external = true; + } else { + GL_CheckError("", renderer); + renderdata->glGenTextures(1, &data->texture); + if (!GL_CheckError("glGenTextures()", renderer)) { + if (data->pixels) { + SDL_free(data->pixels); + } + SDL_free(data); + return false; + } + } + texture->internal = data; + + if (renderdata->GL_ARB_texture_non_power_of_two_supported) { + texture_w = texture->w; + texture_h = texture->h; + data->texw = 1.0f; + data->texh = 1.0f; + } else if (renderdata->GL_ARB_texture_rectangle_supported) { + texture_w = texture->w; + texture_h = texture->h; + data->texw = (GLfloat)texture_w; + data->texh = (GLfloat)texture_h; + } else { + texture_w = SDL_powerof2(texture->w); + texture_h = SDL_powerof2(texture->h); + data->texw = (GLfloat)(texture->w) / texture_w; + data->texh = (GLfloat)texture->h / texture_h; + } + SDL_PropertiesID props = SDL_GetTextureProperties(texture); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER, data->texture); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER, (Sint64) textype); + SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_OPENGL_TEX_W_FLOAT, data->texw); + SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_OPENGL_TEX_H_FLOAT, data->texh); + + data->format = format; + data->formattype = type; + scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? GL_NEAREST : GL_LINEAR; + renderdata->glEnable(textype); + renderdata->glBindTexture(textype, data->texture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, scaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, scaleMode); +#ifdef SDL_PLATFORM_MACOS +#ifndef GL_TEXTURE_STORAGE_HINT_APPLE +#define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC +#endif +#ifndef STORAGE_CACHED_APPLE +#define STORAGE_CACHED_APPLE 0x85BE +#endif +#ifndef STORAGE_SHARED_APPLE +#define STORAGE_SHARED_APPLE 0x85BF +#endif + if (texture->access == SDL_TEXTUREACCESS_STREAMING) { + renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE, + GL_STORAGE_SHARED_APPLE); + } else { + renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE, + GL_STORAGE_CACHED_APPLE); + } + if (texture->access == SDL_TEXTUREACCESS_STREAMING && texture->format == SDL_PIXELFORMAT_ARGB8888 && (texture->w % 8) == 0) { + renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE); + renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, + (data->pitch / SDL_BYTESPERPIXEL(texture->format))); + renderdata->glTexImage2D(textype, 0, internalFormat, texture_w, + texture_h, 0, format, type, data->pixels); + renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE); + } else +#endif + { + renderdata->glTexImage2D(textype, 0, internalFormat, texture_w, + texture_h, 0, format, type, NULL); + } + renderdata->glDisable(textype); + if (!GL_CheckError("glTexImage2D()", renderer)) { + return false; + } + +#ifdef SDL_HAVE_YUV + if (texture->format == SDL_PIXELFORMAT_YV12 || + texture->format == SDL_PIXELFORMAT_IYUV) { + data->yuv = true; + + data->utexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER, 0); + if (data->utexture) { + data->utexture_external = true; + } else { + renderdata->glGenTextures(1, &data->utexture); + } + data->vtexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER, 0); + if (data->vtexture) { + data->vtexture_external = true; + } else { + renderdata->glGenTextures(1, &data->vtexture); + } + + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, + scaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, + scaleMode); + renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w + 1) / 2, + (texture_h + 1) / 2, 0, format, type, NULL); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_U_NUMBER, data->utexture); + + renderdata->glBindTexture(textype, data->vtexture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, + scaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, + scaleMode); + renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w + 1) / 2, + (texture_h + 1) / 2, 0, format, type, NULL); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_V_NUMBER, data->vtexture); + } + + if (texture->format == SDL_PIXELFORMAT_NV12 || + texture->format == SDL_PIXELFORMAT_NV21) { + data->nv12 = true; + + data->utexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER, 0); + if (data->utexture) { + data->utexture_external = true; + } else { + renderdata->glGenTextures(1, &data->utexture); + } + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, + scaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, + scaleMode); + renderdata->glTexImage2D(textype, 0, GL_LUMINANCE_ALPHA, (texture_w + 1) / 2, + (texture_h + 1) / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_UV_NUMBER, data->utexture); + } +#endif + + if (texture->format == SDL_PIXELFORMAT_ABGR8888 || texture->format == SDL_PIXELFORMAT_ARGB8888) { + data->shader = SHADER_RGBA; + } else { + data->shader = SHADER_RGB; + } + +#ifdef SDL_HAVE_YUV + if (data->yuv || data->nv12) { + if (data->yuv) { + data->shader = SHADER_YUV; + } else if (texture->format == SDL_PIXELFORMAT_NV12) { + if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) { + data->shader = SHADER_NV12_RG; + } else { + data->shader = SHADER_NV12_RA; + } + } else { + if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) { + data->shader = SHADER_NV21_RG; + } else { + data->shader = SHADER_NV21_RA; + } + } + data->shader_params = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8); + if (!data->shader_params) { + return SDL_SetError("Unsupported YUV colorspace"); + } + } +#endif // SDL_HAVE_YUV + + return GL_CheckError("", renderer); +} + +static bool GL_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, const void *pixels, int pitch) +{ + GL_RenderData *renderdata = (GL_RenderData *)renderer->internal; + const GLenum textype = renderdata->textype; + GL_TextureData *data = (GL_TextureData *)texture->internal; + const int texturebpp = SDL_BYTESPERPIXEL(texture->format); + + SDL_assert_release(texturebpp != 0); // otherwise, division by zero later. + + GL_ActivateRenderer(renderer); + + renderdata->drawstate.texture = NULL; // we trash this state. + + renderdata->glBindTexture(textype, data->texture); + renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, (pitch / texturebpp)); + renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w, + rect->h, data->format, data->formattype, + pixels); +#ifdef SDL_HAVE_YUV + if (data->yuv) { + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2)); + + // Skip to the correct offset into the next texture + pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch); + if (texture->format == SDL_PIXELFORMAT_YV12) { + renderdata->glBindTexture(textype, data->vtexture); + } else { + renderdata->glBindTexture(textype, data->utexture); + } + renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2, + (rect->w + 1) / 2, (rect->h + 1) / 2, + data->format, data->formattype, pixels); + + // Skip to the correct offset into the next texture + pixels = (const void *)((const Uint8 *)pixels + ((rect->h + 1) / 2) * ((pitch + 1) / 2)); + if (texture->format == SDL_PIXELFORMAT_YV12) { + renderdata->glBindTexture(textype, data->utexture); + } else { + renderdata->glBindTexture(textype, data->vtexture); + } + renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2, + (rect->w + 1) / 2, (rect->h + 1) / 2, + data->format, data->formattype, pixels); + } + + if (data->nv12) { + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2)); + + // Skip to the correct offset into the next texture + pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch); + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2, + (rect->w + 1) / 2, (rect->h + 1) / 2, + GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixels); + } +#endif + return GL_CheckError("glTexSubImage2D()", renderer); +} + +#ifdef SDL_HAVE_YUV +static bool GL_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *Uplane, int Upitch, + const Uint8 *Vplane, int Vpitch) +{ + GL_RenderData *renderdata = (GL_RenderData *)renderer->internal; + const GLenum textype = renderdata->textype; + GL_TextureData *data = (GL_TextureData *)texture->internal; + + GL_ActivateRenderer(renderer); + + renderdata->drawstate.texture = NULL; // we trash this state. + + renderdata->glBindTexture(textype, data->texture); + renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch); + renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w, + rect->h, data->format, data->formattype, + Yplane); + + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Upitch); + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2, + (rect->w + 1) / 2, (rect->h + 1) / 2, + data->format, data->formattype, Uplane); + + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Vpitch); + renderdata->glBindTexture(textype, data->vtexture); + renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2, + (rect->w + 1) / 2, (rect->h + 1) / 2, + data->format, data->formattype, Vplane); + + return GL_CheckError("glTexSubImage2D()", renderer); +} + +static bool GL_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *UVplane, int UVpitch) +{ + GL_RenderData *renderdata = (GL_RenderData *)renderer->internal; + const GLenum textype = renderdata->textype; + GL_TextureData *data = (GL_TextureData *)texture->internal; + + GL_ActivateRenderer(renderer); + + renderdata->drawstate.texture = NULL; // we trash this state. + + renderdata->glBindTexture(textype, data->texture); + renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch); + renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w, + rect->h, data->format, data->formattype, + Yplane); + + renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, UVpitch / 2); + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2, + (rect->w + 1) / 2, (rect->h + 1) / 2, + GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, UVplane); + + return GL_CheckError("glTexSubImage2D()", renderer); +} +#endif + +static bool GL_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, void **pixels, int *pitch) +{ + GL_TextureData *data = (GL_TextureData *)texture->internal; + + data->locked_rect = *rect; + *pixels = + (void *)((Uint8 *)data->pixels + rect->y * data->pitch + + rect->x * SDL_BYTESPERPIXEL(texture->format)); + *pitch = data->pitch; + return true; +} + +static void GL_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture) +{ + GL_TextureData *data = (GL_TextureData *)texture->internal; + const SDL_Rect *rect; + void *pixels; + + rect = &data->locked_rect; + pixels = + (void *)((Uint8 *)data->pixels + rect->y * data->pitch + + rect->x * SDL_BYTESPERPIXEL(texture->format)); + GL_UpdateTexture(renderer, texture, rect, pixels, data->pitch); +} + +static void GL_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode) +{ + GL_RenderData *renderdata = (GL_RenderData *)renderer->internal; + const GLenum textype = renderdata->textype; + GL_TextureData *data = (GL_TextureData *)texture->internal; + GLenum glScaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? GL_NEAREST : GL_LINEAR; + + renderdata->glBindTexture(textype, data->texture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode); + +#ifdef SDL_HAVE_YUV + if (texture->format == SDL_PIXELFORMAT_YV12 || + texture->format == SDL_PIXELFORMAT_IYUV) { + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode); + + renderdata->glBindTexture(textype, data->vtexture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode); + } + + if (texture->format == SDL_PIXELFORMAT_NV12 || + texture->format == SDL_PIXELFORMAT_NV21) { + renderdata->glBindTexture(textype, data->utexture); + renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode); + renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode); + } +#endif +} + +static bool GL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture) +{ + GL_RenderData *data = (GL_RenderData *)renderer->internal; + GL_TextureData *texturedata; + GLenum status; + + GL_ActivateRenderer(renderer); + + if (!data->GL_EXT_framebuffer_object_supported) { + return SDL_SetError("Render targets not supported by OpenGL"); + } + + data->drawstate.viewport_dirty = true; + + if (!texture) { + data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + return true; + } + + texturedata = (GL_TextureData *)texture->internal; + data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, texturedata->fbo->FBO); + // TODO: check if texture pixel format allows this operation + data->glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, data->textype, texturedata->texture, 0); + // Check FBO status + status = data->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { + return SDL_SetError("glFramebufferTexture2DEXT() failed"); + } + return true; +} + +/* !!! FIXME: all these Queue* calls set up the vertex buffer the way the immediate mode + !!! FIXME: renderer wants it, but this might want to operate differently if we move to + !!! FIXME: VBOs at some point. */ +static bool GL_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd) +{ + return true; // nothing to do in this backend. +} + +static bool GL_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count) +{ + GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(GLfloat), 0, &cmd->data.draw.first); + int i; + + if (!verts) { + return false; + } + + cmd->data.draw.count = count; + for (i = 0; i < count; i++) { + *(verts++) = 0.5f + points[i].x; + *(verts++) = 0.5f + points[i].y; + } + + return true; +} + +static bool GL_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count) +{ + int i; + GLfloat prevx, prevy; + const size_t vertlen = (sizeof(GLfloat) * 2) * count; + GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first); + + if (!verts) { + return false; + } + cmd->data.draw.count = count; + + // 0.5f offset to hit the center of the pixel. + prevx = 0.5f + points->x; + prevy = 0.5f + points->y; + *(verts++) = prevx; + *(verts++) = prevy; + + /* bump the end of each line segment out a quarter of a pixel, to provoke + the diamond-exit rule. Without this, you won't just drop the last + pixel of the last line segment, but you might also drop pixels at the + edge of any given line segment along the way too. */ + for (i = 1; i < count; i++) { + const GLfloat xstart = prevx; + const GLfloat ystart = prevy; + const GLfloat xend = points[i].x + 0.5f; // 0.5f to hit pixel center. + const GLfloat yend = points[i].y + 0.5f; + // bump a little in the direction we are moving in. + const GLfloat deltax = xend - xstart; + const GLfloat deltay = yend - ystart; + const GLfloat angle = SDL_atan2f(deltay, deltax); + prevx = xend + (SDL_cosf(angle) * 0.25f); + prevy = yend + (SDL_sinf(angle) * 0.25f); + *(verts++) = prevx; + *(verts++) = prevy; + } + + return true; +} + +static bool GL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, + const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride, + int num_vertices, const void *indices, int num_indices, int size_indices, + float scale_x, float scale_y) +{ + GL_TextureData *texturedata = NULL; + int i; + int count = indices ? num_indices : num_vertices; + GLfloat *verts; + size_t sz = 2 * sizeof(GLfloat) + 4 * sizeof(GLfloat) + (texture ? 2 : 0) * sizeof(GLfloat); + const float color_scale = cmd->data.draw.color_scale; + + verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first); + if (!verts) { + return false; + } + + if (texture) { + texturedata = (GL_TextureData *)texture->internal; + } + + cmd->data.draw.count = count; + size_indices = indices ? size_indices : 0; + + for (i = 0; i < count; i++) { + int j; + float *xy_; + SDL_FColor *col_; + if (size_indices == 4) { + j = ((const Uint32 *)indices)[i]; + } else if (size_indices == 2) { + j = ((const Uint16 *)indices)[i]; + } else if (size_indices == 1) { + j = ((const Uint8 *)indices)[i]; + } else { + j = i; + } + + xy_ = (float *)((char *)xy + j * xy_stride); + + *(verts++) = xy_[0] * scale_x; + *(verts++) = xy_[1] * scale_y; + + col_ = (SDL_FColor *)((char *)color + j * color_stride); + *(verts++) = col_->r * color_scale; + *(verts++) = col_->g * color_scale; + *(verts++) = col_->b * color_scale; + *(verts++) = col_->a; + + if (texture) { + float *uv_ = (float *)((char *)uv + j * uv_stride); + *(verts++) = uv_[0] * texturedata->texw; + *(verts++) = uv_[1] * texturedata->texh; + } + } + return true; +} + +static bool SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader shader, const float *shader_params) +{ + const SDL_BlendMode blend = cmd->data.draw.blend; + bool vertex_array; + bool color_array; + bool texture_array; + + if (data->drawstate.viewport_dirty) { + const bool istarget = data->drawstate.target != NULL; + const SDL_Rect *viewport = &data->drawstate.viewport; + data->glMatrixMode(GL_PROJECTION); + data->glLoadIdentity(); + data->glViewport(viewport->x, + istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h), + viewport->w, viewport->h); + if (viewport->w && viewport->h) { + data->glOrtho((GLdouble)0, (GLdouble)viewport->w, + (GLdouble)(istarget ? 0 : viewport->h), + (GLdouble)(istarget ? viewport->h : 0), + 0.0, 1.0); + } + data->glMatrixMode(GL_MODELVIEW); + data->drawstate.viewport_dirty = false; + } + + if (data->drawstate.cliprect_enabled_dirty) { + if (!data->drawstate.cliprect_enabled) { + data->glDisable(GL_SCISSOR_TEST); + } else { + data->glEnable(GL_SCISSOR_TEST); + } + data->drawstate.cliprect_enabled_dirty = false; + } + + if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) { + const SDL_Rect *viewport = &data->drawstate.viewport; + const SDL_Rect *rect = &data->drawstate.cliprect; + data->glScissor(viewport->x + rect->x, + data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h, + rect->w, rect->h); + data->drawstate.cliprect_dirty = false; + } + + if (blend != data->drawstate.blend) { + if (blend == SDL_BLENDMODE_NONE) { + data->glDisable(GL_BLEND); + } else { + data->glEnable(GL_BLEND); + data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)), + GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)), + GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)), + GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend))); + data->glBlendEquation(GetBlendEquation(SDL_GetBlendModeColorOperation(blend))); + } + data->drawstate.blend = blend; + } + + if (data->shaders && + (shader != data->drawstate.shader || shader_params != data->drawstate.shader_params)) { + GL_SelectShader(data->shaders, shader, shader_params); + data->drawstate.shader = shader; + data->drawstate.shader_params = shader_params; + } + + if (data->drawstate.texturing_dirty || ((cmd->data.draw.texture != NULL) != data->drawstate.texturing)) { + if (!cmd->data.draw.texture) { + data->glDisable(data->textype); + data->drawstate.texturing = false; + } else { + data->glEnable(data->textype); + data->drawstate.texturing = true; + } + data->drawstate.texturing_dirty = false; + } + + vertex_array = cmd->command == SDL_RENDERCMD_DRAW_POINTS || cmd->command == SDL_RENDERCMD_DRAW_LINES || cmd->command == SDL_RENDERCMD_GEOMETRY; + color_array = cmd->command == SDL_RENDERCMD_GEOMETRY; + texture_array = cmd->data.draw.texture != NULL; + + if (vertex_array != data->drawstate.vertex_array) { + if (vertex_array) { + data->glEnableClientState(GL_VERTEX_ARRAY); + } else { + data->glDisableClientState(GL_VERTEX_ARRAY); + } + data->drawstate.vertex_array = vertex_array; + } + + if (color_array != data->drawstate.color_array) { + if (color_array) { + data->glEnableClientState(GL_COLOR_ARRAY); + } else { + data->glDisableClientState(GL_COLOR_ARRAY); + } + data->drawstate.color_array = color_array; + } + + /* This is a little awkward but should avoid texcoord arrays getting into + a bad state if the application is manually binding textures */ + if (texture_array != data->drawstate.texture_array) { + if (texture_array) { + data->glEnableClientState(GL_TEXTURE_COORD_ARRAY); + } else { + data->glDisableClientState(GL_TEXTURE_COORD_ARRAY); + } + data->drawstate.texture_array = texture_array; + } + + return true; +} + +static bool SetTextureAddressMode(GL_RenderData *data, GLenum textype, SDL_TextureAddressMode addressMode) +{ + switch (addressMode) { + case SDL_TEXTURE_ADDRESS_CLAMP: + data->glTexParameteri(textype, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + data->glTexParameteri(textype, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + break; + case SDL_TEXTURE_ADDRESS_WRAP: + data->glTexParameteri(textype, GL_TEXTURE_WRAP_S, GL_REPEAT); + data->glTexParameteri(textype, GL_TEXTURE_WRAP_T, GL_REPEAT); + break; + default: + return SDL_SetError("Unknown texture address mode: %d", addressMode); + } + return true; +} + +static bool SetCopyState(GL_RenderData *data, const SDL_RenderCommand *cmd) +{ + SDL_Texture *texture = cmd->data.draw.texture; + const GL_TextureData *texturedata = (GL_TextureData *)texture->internal; + + SetDrawState(data, cmd, texturedata->shader, texturedata->shader_params); + + if (texture != data->drawstate.texture) { + const GLenum textype = data->textype; +#ifdef SDL_HAVE_YUV + if (texturedata->yuv) { + if (data->GL_ARB_multitexture_supported) { + data->glActiveTextureARB(GL_TEXTURE2_ARB); + } + data->glBindTexture(textype, texturedata->vtexture); + + if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) { + return false; + } + + if (data->GL_ARB_multitexture_supported) { + data->glActiveTextureARB(GL_TEXTURE1_ARB); + } + data->glBindTexture(textype, texturedata->utexture); + + if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) { + return false; + } + } + if (texturedata->nv12) { + if (data->GL_ARB_multitexture_supported) { + data->glActiveTextureARB(GL_TEXTURE1_ARB); + } + data->glBindTexture(textype, texturedata->utexture); + + if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) { + return false; + } + } +#endif + if (data->GL_ARB_multitexture_supported) { + data->glActiveTextureARB(GL_TEXTURE0_ARB); + } + data->glBindTexture(textype, texturedata->texture); + + if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) { + return false; + } + + data->drawstate.texture = texture; + } + + return true; +} + +static void GL_InvalidateCachedState(SDL_Renderer *renderer) +{ + GL_DrawStateCache *cache = &((GL_RenderData *)renderer->internal)->drawstate; + cache->viewport_dirty = true; + cache->texture = NULL; + cache->drawablew = 0; + cache->drawableh = 0; + cache->blend = SDL_BLENDMODE_INVALID; + cache->shader = SHADER_INVALID; + cache->cliprect_enabled_dirty = true; + cache->cliprect_dirty = true; + cache->texturing_dirty = true; + cache->vertex_array = false; // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively. + cache->color_array = false; // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively. + cache->texture_array = false; // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively. + cache->color_dirty = true; + cache->clear_color_dirty = true; +} + +static bool GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize) +{ + // !!! FIXME: it'd be nice to use a vertex buffer instead of immediate mode... + GL_RenderData *data = (GL_RenderData *)renderer->internal; + + if (!GL_ActivateRenderer(renderer)) { + return false; + } + + data->drawstate.target = renderer->target; + if (!data->drawstate.target) { + int w, h; + SDL_GetWindowSizeInPixels(renderer->window, &w, &h); + if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) { + data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc. + data->drawstate.cliprect_dirty = true; + data->drawstate.drawablew = w; + data->drawstate.drawableh = h; + } + } + +#ifdef SDL_PLATFORM_MACOS + // On macOS on older systems, the OpenGL view change and resize events aren't + // necessarily synchronized, so just always reset it. + // Workaround for: https://discourse.libsdl.org/t/sdl-2-0-22-prerelease/35306/6 + data->drawstate.viewport_dirty = true; +#endif + + while (cmd) { + switch (cmd->command) { + case SDL_RENDERCMD_SETDRAWCOLOR: + { + const float r = cmd->data.color.color.r * cmd->data.color.color_scale; + const float g = cmd->data.color.color.g * cmd->data.color.color_scale; + const float b = cmd->data.color.color.b * cmd->data.color.color_scale; + const float a = cmd->data.color.color.a; + if (data->drawstate.color_dirty || + (r != data->drawstate.color.r) || + (g != data->drawstate.color.g) || + (b != data->drawstate.color.b) || + (a != data->drawstate.color.a)) { + data->glColor4f(r, g, b, a); + data->drawstate.color.r = r; + data->drawstate.color.g = g; + data->drawstate.color.b = b; + data->drawstate.color.a = a; + data->drawstate.color_dirty = false; + } + break; + } + + case SDL_RENDERCMD_SETVIEWPORT: + { + SDL_Rect *viewport = &data->drawstate.viewport; + if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) { + SDL_copyp(viewport, &cmd->data.viewport.rect); + data->drawstate.viewport_dirty = true; + data->drawstate.cliprect_dirty = true; + } + break; + } + + case SDL_RENDERCMD_SETCLIPRECT: + { + const SDL_Rect *rect = &cmd->data.cliprect.rect; + if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) { + data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled; + data->drawstate.cliprect_enabled_dirty = true; + } + + if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) { + SDL_copyp(&data->drawstate.cliprect, rect); + data->drawstate.cliprect_dirty = true; + } + break; + } + + case SDL_RENDERCMD_CLEAR: + { + const float r = cmd->data.color.color.r * cmd->data.color.color_scale; + const float g = cmd->data.color.color.g * cmd->data.color.color_scale; + const float b = cmd->data.color.color.b * cmd->data.color.color_scale; + const float a = cmd->data.color.color.a; + if (data->drawstate.clear_color_dirty || + (r != data->drawstate.clear_color.r) || + (g != data->drawstate.clear_color.g) || + (b != data->drawstate.clear_color.b) || + (a != data->drawstate.clear_color.a)) { + data->glClearColor(r, g, b, a); + data->drawstate.clear_color.r = r; + data->drawstate.clear_color.g = g; + data->drawstate.clear_color.b = b; + data->drawstate.clear_color.a = a; + data->drawstate.clear_color_dirty = false; + } + + if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) { + data->glDisable(GL_SCISSOR_TEST); + data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled; + } + + data->glClear(GL_COLOR_BUFFER_BIT); + break; + } + + case SDL_RENDERCMD_FILL_RECTS: // unused + break; + + case SDL_RENDERCMD_COPY: // unused + break; + + case SDL_RENDERCMD_COPY_EX: // unused + break; + + case SDL_RENDERCMD_DRAW_LINES: + { + if (SetDrawState(data, cmd, SHADER_SOLID, NULL)) { + size_t count = cmd->data.draw.count; + const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first); + + // SetDrawState handles glEnableClientState. + data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts); + + if (count > 2) { + // joined lines cannot be grouped + data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count); + } else { + // let's group non joined lines + SDL_RenderCommand *finalcmd = cmd; + SDL_RenderCommand *nextcmd = cmd->next; + SDL_BlendMode thisblend = cmd->data.draw.blend; + + while (nextcmd) { + const SDL_RenderCommandType nextcmdtype = nextcmd->command; + if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) { + break; // can't go any further on this draw call, different render command up next. + } else if (nextcmd->data.draw.count != 2) { + break; // can't go any further on this draw call, those are joined lines + } else if (nextcmd->data.draw.blend != thisblend) { + break; // can't go any further on this draw call, different blendmode copy up next. + } else { + finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command. + count += nextcmd->data.draw.count; + } + nextcmd = nextcmd->next; + } + + data->glDrawArrays(GL_LINES, 0, (GLsizei)count); + cmd = finalcmd; // skip any copy commands we just combined in here. + } + } + break; + } + + case SDL_RENDERCMD_DRAW_POINTS: + case SDL_RENDERCMD_GEOMETRY: + { + /* as long as we have the same copy command in a row, with the + same texture, we can combine them all into a single draw call. */ + SDL_Texture *thistexture = cmd->data.draw.texture; + SDL_BlendMode thisblend = cmd->data.draw.blend; + const SDL_RenderCommandType thiscmdtype = cmd->command; + SDL_RenderCommand *finalcmd = cmd; + SDL_RenderCommand *nextcmd = cmd->next; + size_t count = cmd->data.draw.count; + int ret; + while (nextcmd) { + const SDL_RenderCommandType nextcmdtype = nextcmd->command; + if (nextcmdtype != thiscmdtype) { + break; // can't go any further on this draw call, different render command up next. + } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) { + break; // can't go any further on this draw call, different texture/blendmode copy up next. + } else { + finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command. + count += nextcmd->data.draw.count; + } + nextcmd = nextcmd->next; + } + + if (thistexture) { + ret = SetCopyState(data, cmd); + } else { + ret = SetDrawState(data, cmd, SHADER_SOLID, NULL); + } + + if (ret) { + const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first); + int op = GL_TRIANGLES; // SDL_RENDERCMD_GEOMETRY + if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) { + op = GL_POINTS; + } + + if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) { + // SetDrawState handles glEnableClientState. + data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts); + } else { + // SetDrawState handles glEnableClientState. + if (thistexture) { + data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 8, verts + 0); + data->glColorPointer(4, GL_FLOAT, sizeof(float) * 8, verts + 2); + data->glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 8, verts + 6); + } else { + data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 6, verts + 0); + data->glColorPointer(4, GL_FLOAT, sizeof(float) * 6, verts + 2); + } + } + + data->glDrawArrays(op, 0, (GLsizei)count); + + // Restore previously set color when we're done. + if (thiscmdtype != SDL_RENDERCMD_DRAW_POINTS) { + const float r = data->drawstate.color.r; + const float g = data->drawstate.color.g; + const float b = data->drawstate.color.b; + const float a = data->drawstate.color.a; + data->glColor4f(r, g, b, a); + } + } + + cmd = finalcmd; // skip any copy commands we just combined in here. + break; + } + + case SDL_RENDERCMD_NO_OP: + break; + } + + cmd = cmd->next; + } + + /* Turn off vertex array state when we're done, in case external code + relies on it being off. */ + if (data->drawstate.vertex_array) { + data->glDisableClientState(GL_VERTEX_ARRAY); + data->drawstate.vertex_array = false; + } + if (data->drawstate.color_array) { + data->glDisableClientState(GL_COLOR_ARRAY); + data->drawstate.color_array = false; + } + if (data->drawstate.texture_array) { + data->glDisableClientState(GL_TEXTURE_COORD_ARRAY); + data->drawstate.texture_array = false; + } + + return GL_CheckError("", renderer); +} + +static SDL_Surface *GL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect) +{ + GL_RenderData *data = (GL_RenderData *)renderer->internal; + SDL_PixelFormat format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ARGB8888; + GLint internalFormat; + GLenum targetFormat, type; + SDL_Surface *surface; + + GL_ActivateRenderer(renderer); + + if (!convert_format(format, &internalFormat, &targetFormat, &type)) { + SDL_SetError("Texture format %s not supported by OpenGL", SDL_GetPixelFormatName(format)); + return NULL; + } + + surface = SDL_CreateSurface(rect->w, rect->h, format); + if (!surface) { + return NULL; + } + + int y = rect->y; + if (!renderer->target) { + int w, h; + SDL_GetRenderOutputSize(renderer, &w, &h); + y = (h - y) - rect->h; + } + + data->glPixelStorei(GL_PACK_ALIGNMENT, 1); + data->glPixelStorei(GL_PACK_ROW_LENGTH, (surface->pitch / SDL_BYTESPERPIXEL(format))); + data->glReadPixels(rect->x, y, rect->w, rect->h, targetFormat, type, surface->pixels); + + if (!GL_CheckError("glReadPixels()", renderer)) { + SDL_DestroySurface(surface); + return NULL; + } + + // Flip the rows to be top-down if necessary + if (!renderer->target) { + SDL_FlipSurface(surface, SDL_FLIP_VERTICAL); + } + return surface; +} + +static bool GL_RenderPresent(SDL_Renderer *renderer) +{ + GL_ActivateRenderer(renderer); + + return SDL_GL_SwapWindow(renderer->window); +} + +static void GL_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture) +{ + GL_RenderData *renderdata = (GL_RenderData *)renderer->internal; + GL_TextureData *data = (GL_TextureData *)texture->internal; + + GL_ActivateRenderer(renderer); + + if (renderdata->drawstate.texture == texture) { + renderdata->drawstate.texture = NULL; + } + if (renderdata->drawstate.target == texture) { + renderdata->drawstate.target = NULL; + } + + if (!data) { + return; + } + if (data->texture && !data->texture_external) { + renderdata->glDeleteTextures(1, &data->texture); + } +#ifdef SDL_HAVE_YUV + if (data->yuv) { + if (!data->utexture_external) { + renderdata->glDeleteTextures(1, &data->utexture); + } + if (!data->vtexture_external) { + renderdata->glDeleteTextures(1, &data->vtexture); + } + } + if (data->nv12) { + if (!data->utexture_external) { + renderdata->glDeleteTextures(1, &data->utexture); + } + } +#endif + SDL_free(data->pixels); + SDL_free(data); + texture->internal = NULL; +} + +static void GL_DestroyRenderer(SDL_Renderer *renderer) +{ + GL_RenderData *data = (GL_RenderData *)renderer->internal; + + if (data) { + if (data->context) { + // make sure we delete the right resources! + GL_ActivateRenderer(renderer); + } + + GL_ClearErrors(renderer); + if (data->GL_ARB_debug_output_supported) { + PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB"); + + // Uh oh, we don't have a safe way of removing ourselves from the callback chain, if it changed after we set our callback. + // For now, just always replace the callback with the original one + glDebugMessageCallbackARBFunc(data->next_error_callback, data->next_error_userparam); + } + if (data->shaders) { + GL_DestroyShaderContext(data->shaders); + } + if (data->context) { + while (data->framebuffers) { + GL_FBOList *nextnode = data->framebuffers->next; + // delete the framebuffer object + data->glDeleteFramebuffersEXT(1, &data->framebuffers->FBO); + GL_CheckError("", renderer); + SDL_free(data->framebuffers); + data->framebuffers = nextnode; + } + SDL_GL_DestroyContext(data->context); + } + SDL_free(data); + } +} + +static bool GL_SetVSync(SDL_Renderer *renderer, const int vsync) +{ + int interval = 0; + + if (!SDL_GL_SetSwapInterval(vsync)) { + return false; + } + + if (!SDL_GL_GetSwapInterval(&interval)) { + return false; + } + + if (interval != vsync) { + return SDL_Unsupported(); + } + return true; +} + +static bool GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props) +{ + GL_RenderData *data = NULL; + GLint value; + SDL_WindowFlags window_flags; + int profile_mask = 0, major = 0, minor = 0; + bool changed_window = false; + const char *hint; + bool non_power_of_two_supported = false; + + SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask); + SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major); + SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor); + +#ifndef SDL_VIDEO_VITA_PVR_OGL + SDL_SyncWindow(window); + window_flags = SDL_GetWindowFlags(window); + if (!(window_flags & SDL_WINDOW_OPENGL) || + profile_mask == SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) { + + changed_window = true; + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR); + + if (!SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL)) { + goto error; + } + } +#endif + + SDL_SetupRendererColorspace(renderer, create_props); + + if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) { + SDL_SetError("Unsupported output colorspace"); + goto error; + } + + data = (GL_RenderData *)SDL_calloc(1, sizeof(*data)); + if (!data) { + goto error; + } + + renderer->WindowEvent = GL_WindowEvent; + renderer->SupportsBlendMode = GL_SupportsBlendMode; + renderer->CreateTexture = GL_CreateTexture; + renderer->UpdateTexture = GL_UpdateTexture; +#ifdef SDL_HAVE_YUV + renderer->UpdateTextureYUV = GL_UpdateTextureYUV; + renderer->UpdateTextureNV = GL_UpdateTextureNV; +#endif + renderer->LockTexture = GL_LockTexture; + renderer->UnlockTexture = GL_UnlockTexture; + renderer->SetTextureScaleMode = GL_SetTextureScaleMode; + renderer->SetRenderTarget = GL_SetRenderTarget; + renderer->QueueSetViewport = GL_QueueNoOp; + renderer->QueueSetDrawColor = GL_QueueNoOp; + renderer->QueueDrawPoints = GL_QueueDrawPoints; + renderer->QueueDrawLines = GL_QueueDrawLines; + renderer->QueueGeometry = GL_QueueGeometry; + renderer->InvalidateCachedState = GL_InvalidateCachedState; + renderer->RunCommandQueue = GL_RunCommandQueue; + renderer->RenderReadPixels = GL_RenderReadPixels; + renderer->RenderPresent = GL_RenderPresent; + renderer->DestroyTexture = GL_DestroyTexture; + renderer->DestroyRenderer = GL_DestroyRenderer; + renderer->SetVSync = GL_SetVSync; + renderer->internal = data; + GL_InvalidateCachedState(renderer); + renderer->window = window; + + renderer->name = GL_RenderDriver.name; + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888); + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888); + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888); + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR8888); + + data->context = SDL_GL_CreateContext(window); + if (!data->context) { + goto error; + } + if (!SDL_GL_MakeCurrent(window, data->context)) { + goto error; + } + + if (!GL_LoadFunctions(data)) { + goto error; + } + +#ifdef SDL_PLATFORM_MACOS + // Enable multi-threaded rendering + /* Disabled until Ryan finishes his VBO/PBO code... + CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine); + */ +#endif + + // Check for debug output support + if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) && + (value & SDL_GL_CONTEXT_DEBUG_FLAG)) { + data->debug_enabled = true; + } + if (data->debug_enabled && SDL_GL_ExtensionSupported("GL_ARB_debug_output")) { + PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB"); + + data->GL_ARB_debug_output_supported = true; + data->glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION_ARB, (GLvoid **)(char *)&data->next_error_callback); + data->glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM_ARB, &data->next_error_userparam); + glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer); + + // Make sure our callback is called when errors actually happen + data->glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); + } + + hint = SDL_GetHint("GL_ARB_texture_non_power_of_two"); + if (!hint || *hint != '0') { + bool isGL2 = false; + const char *verstr = (const char *)data->glGetString(GL_VERSION); + if (verstr) { + char verbuf[16]; + char *ptr; + SDL_strlcpy(verbuf, verstr, sizeof(verbuf)); + ptr = SDL_strchr(verbuf, '.'); + if (ptr) { + *ptr = '\0'; + if (SDL_atoi(verbuf) >= 2) { + isGL2 = true; + } + } + } + if (isGL2 || SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) { + non_power_of_two_supported = true; + } + } + + data->textype = GL_TEXTURE_2D; + if (non_power_of_two_supported) { + data->GL_ARB_texture_non_power_of_two_supported = true; + data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value); + SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value); + } else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") || + SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) { + data->GL_ARB_texture_rectangle_supported = true; + data->textype = GL_TEXTURE_RECTANGLE_ARB; + data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value); + SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value); + } else { + data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value); + SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value); + } + + // Check for multitexture support + if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) { + data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)SDL_GL_GetProcAddress("glActiveTextureARB"); + if (data->glActiveTextureARB) { + data->GL_ARB_multitexture_supported = true; + data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units); + } + } + + // Check for shader support + data->shaders = GL_CreateShaderContext(); + SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s", + data->shaders ? "ENABLED" : "DISABLED"); +#ifdef SDL_HAVE_YUV + // We support YV12 textures using 3 textures and a shader + if (data->shaders && data->num_texture_units >= 3) { + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12); + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV); + } + + // We support NV12 textures using 2 textures and a shader + if (data->shaders && data->num_texture_units >= 2) { + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12); + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21); + } +#endif +#ifdef SDL_PLATFORM_MACOS + SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_UYVY); +#endif + + if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) { + data->GL_EXT_framebuffer_object_supported = true; + data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) + SDL_GL_GetProcAddress("glGenFramebuffersEXT"); + data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) + SDL_GL_GetProcAddress("glDeleteFramebuffersEXT"); + data->glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) + SDL_GL_GetProcAddress("glFramebufferTexture2DEXT"); + data->glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) + SDL_GL_GetProcAddress("glBindFramebufferEXT"); + data->glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) + SDL_GL_GetProcAddress("glCheckFramebufferStatusEXT"); + } else { + SDL_SetError("Can't create render targets, GL_EXT_framebuffer_object not available"); + goto error; + } + + // Set up parameters for rendering + data->glMatrixMode(GL_MODELVIEW); + data->glLoadIdentity(); + data->glDisable(GL_DEPTH_TEST); + data->glDisable(GL_CULL_FACE); + data->glDisable(GL_SCISSOR_TEST); + data->glDisable(data->textype); + data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + data->glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + // This ended up causing video discrepancies between OpenGL and Direct3D + // data->glEnable(GL_LINE_SMOOTH); + + data->drawstate.color.r = 1.0f; + data->drawstate.color.g = 1.0f; + data->drawstate.color.b = 1.0f; + data->drawstate.color.a = 1.0f; + data->drawstate.clear_color.r = 1.0f; + data->drawstate.clear_color.g = 1.0f; + data->drawstate.clear_color.b = 1.0f; + data->drawstate.clear_color.a = 1.0f; + + return true; + +error: + if (changed_window) { + // Uh oh, better try to put it back... + char *error = SDL_strdup(SDL_GetError()); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor); + SDL_RecreateWindow(window, window_flags); + SDL_SetError("%s", error); + SDL_free(error); + } + return false; +} + +SDL_RenderDriver GL_RenderDriver = { + GL_CreateRenderer, "opengl" +}; + +#endif // SDL_VIDEO_RENDER_OGL diff --git a/contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c b/contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c new file mode 100644 index 0000000..b09b12e --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c @@ -0,0 +1,545 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifdef SDL_VIDEO_RENDER_OGL + +#include +#include "SDL_shaders_gl.h" + +// OpenGL shader implementation + +// #define DEBUG_SHADERS + +typedef struct +{ + GLhandleARB program; + GLhandleARB vert_shader; + GLhandleARB frag_shader; +} GL_ShaderData; + +struct GL_ShaderContext +{ + GLenum (*glGetError)(void); + + PFNGLATTACHOBJECTARBPROC glAttachObjectARB; + PFNGLCOMPILESHADERARBPROC glCompileShaderARB; + PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; + PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; + PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; + PFNGLGETINFOLOGARBPROC glGetInfoLogARB; + PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; + PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; + PFNGLLINKPROGRAMARBPROC glLinkProgramARB; + PFNGLSHADERSOURCEARBPROC glShaderSourceARB; + PFNGLUNIFORM1IARBPROC glUniform1iARB; + PFNGLUNIFORM1FARBPROC glUniform1fARB; + PFNGLUNIFORM3FARBPROC glUniform3fARB; + PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; + + bool GL_ARB_texture_rectangle_supported; + + GL_ShaderData shaders[NUM_SHADERS]; + const float *shader_params[NUM_SHADERS]; +}; + +/* *INDENT-OFF* */ // clang-format off + +#define COLOR_VERTEX_SHADER \ +"varying vec4 v_color;\n" \ +"\n" \ +"void main()\n" \ +"{\n" \ +" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" \ +" v_color = gl_Color;\n" \ +"}" \ + +#define TEXTURE_VERTEX_SHADER \ +"varying vec4 v_color;\n" \ +"varying vec2 v_texCoord;\n" \ +"\n" \ +"void main()\n" \ +"{\n" \ +" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" \ +" v_color = gl_Color;\n" \ +" v_texCoord = vec2(gl_MultiTexCoord0);\n" \ +"}" \ + +#define YUV_SHADER_PROLOGUE \ +"varying vec4 v_color;\n" \ +"varying vec2 v_texCoord;\n" \ +"uniform sampler2D tex0; // Y \n" \ +"uniform sampler2D tex1; // U \n" \ +"uniform sampler2D tex2; // V \n" \ +"uniform vec3 Yoffset;\n" \ +"uniform vec3 Rcoeff;\n" \ +"uniform vec3 Gcoeff;\n" \ +"uniform vec3 Bcoeff;\n" \ +"\n" \ + +#define YUV_SHADER_BODY \ +"\n" \ +"void main()\n" \ +"{\n" \ +" vec2 tcoord;\n" \ +" vec3 yuv, rgb;\n" \ +"\n" \ +" // Get the Y value \n" \ +" tcoord = v_texCoord;\n" \ +" yuv.x = texture2D(tex0, tcoord).r;\n" \ +"\n" \ +" // Get the U and V values \n" \ +" tcoord *= UVCoordScale;\n" \ +" yuv.y = texture2D(tex1, tcoord).r;\n" \ +" yuv.z = texture2D(tex2, tcoord).r;\n" \ +"\n" \ +" // Do the color transform \n" \ +" yuv += Yoffset;\n" \ +" rgb.r = dot(yuv, Rcoeff);\n" \ +" rgb.g = dot(yuv, Gcoeff);\n" \ +" rgb.b = dot(yuv, Bcoeff);\n" \ +"\n" \ +" // That was easy. :) \n" \ +" gl_FragColor = vec4(rgb, 1.0) * v_color;\n" \ +"}" \ + +#define NV12_SHADER_PROLOGUE \ +"varying vec4 v_color;\n" \ +"varying vec2 v_texCoord;\n" \ +"uniform sampler2D tex0; // Y \n" \ +"uniform sampler2D tex1; // U/V \n" \ +"uniform vec3 Yoffset;\n" \ +"uniform vec3 Rcoeff;\n" \ +"uniform vec3 Gcoeff;\n" \ +"uniform vec3 Bcoeff;\n" \ +"\n" \ + +#define NV12_RA_SHADER_BODY \ +"\n" \ +"void main()\n" \ +"{\n" \ +" vec2 tcoord;\n" \ +" vec3 yuv, rgb;\n" \ +"\n" \ +" // Get the Y value \n" \ +" tcoord = v_texCoord;\n" \ +" yuv.x = texture2D(tex0, tcoord).r;\n" \ +"\n" \ +" // Get the U and V values \n" \ +" tcoord *= UVCoordScale;\n" \ +" yuv.yz = texture2D(tex1, tcoord).ra;\n" \ +"\n" \ +" // Do the color transform \n" \ +" yuv += Yoffset;\n" \ +" rgb.r = dot(yuv, Rcoeff);\n" \ +" rgb.g = dot(yuv, Gcoeff);\n" \ +" rgb.b = dot(yuv, Bcoeff);\n" \ +"\n" \ +" // That was easy. :) \n" \ +" gl_FragColor = vec4(rgb, 1.0) * v_color;\n" \ +"}" \ + +#define NV12_RG_SHADER_BODY \ +"\n" \ +"void main()\n" \ +"{\n" \ +" vec2 tcoord;\n" \ +" vec3 yuv, rgb;\n" \ +"\n" \ +" // Get the Y value \n" \ +" tcoord = v_texCoord;\n" \ +" yuv.x = texture2D(tex0, tcoord).r;\n" \ +"\n" \ +" // Get the U and V values \n" \ +" tcoord *= UVCoordScale;\n" \ +" yuv.yz = texture2D(tex1, tcoord).rg;\n" \ +"\n" \ +" // Do the color transform \n" \ +" yuv += Yoffset;\n" \ +" rgb.r = dot(yuv, Rcoeff);\n" \ +" rgb.g = dot(yuv, Gcoeff);\n" \ +" rgb.b = dot(yuv, Bcoeff);\n" \ +"\n" \ +" // That was easy. :) \n" \ +" gl_FragColor = vec4(rgb, 1.0) * v_color;\n" \ +"}" \ + +#define NV21_RA_SHADER_BODY \ +"\n" \ +"void main()\n" \ +"{\n" \ +" vec2 tcoord;\n" \ +" vec3 yuv, rgb;\n" \ +"\n" \ +" // Get the Y value \n" \ +" tcoord = v_texCoord;\n" \ +" yuv.x = texture2D(tex0, tcoord).r;\n" \ +"\n" \ +" // Get the U and V values \n" \ +" tcoord *= UVCoordScale;\n" \ +" yuv.yz = texture2D(tex1, tcoord).ar;\n" \ +"\n" \ +" // Do the color transform \n" \ +" yuv += Yoffset;\n" \ +" rgb.r = dot(yuv, Rcoeff);\n" \ +" rgb.g = dot(yuv, Gcoeff);\n" \ +" rgb.b = dot(yuv, Bcoeff);\n" \ +"\n" \ +" // That was easy. :) \n" \ +" gl_FragColor = vec4(rgb, 1.0) * v_color;\n" \ +"}" \ + +#define NV21_RG_SHADER_BODY \ +"\n" \ +"void main()\n" \ +"{\n" \ +" vec2 tcoord;\n" \ +" vec3 yuv, rgb;\n" \ +"\n" \ +" // Get the Y value \n" \ +" tcoord = v_texCoord;\n" \ +" yuv.x = texture2D(tex0, tcoord).r;\n" \ +"\n" \ +" // Get the U and V values \n" \ +" tcoord *= UVCoordScale;\n" \ +" yuv.yz = texture2D(tex1, tcoord).gr;\n" \ +"\n" \ +" // Do the color transform \n" \ +" yuv += Yoffset;\n" \ +" rgb.r = dot(yuv, Rcoeff);\n" \ +" rgb.g = dot(yuv, Gcoeff);\n" \ +" rgb.b = dot(yuv, Bcoeff);\n" \ +"\n" \ +" // That was easy. :) \n" \ +" gl_FragColor = vec4(rgb, 1.0) * v_color;\n" \ +"}" \ + +/* + * NOTE: Always use sampler2D, etc here. We'll #define them to the + * texture_rectangle versions if we choose to use that extension. + */ +static const char *shader_source[NUM_SHADERS][2] = { + // SHADER_NONE + { NULL, NULL }, + + // SHADER_SOLID + { + // vertex shader + COLOR_VERTEX_SHADER, + // fragment shader +"varying vec4 v_color;\n" +"\n" +"void main()\n" +"{\n" +" gl_FragColor = v_color;\n" +"}" + }, + + // SHADER_RGB + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader +"varying vec4 v_color;\n" +"varying vec2 v_texCoord;\n" +"uniform sampler2D tex0;\n" +"\n" +"void main()\n" +"{\n" +" gl_FragColor = texture2D(tex0, v_texCoord);\n" +" gl_FragColor.a = 1.0;\n" +" gl_FragColor *= v_color;\n" +"}" + }, + + // SHADER_RGBA + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader +"varying vec4 v_color;\n" +"varying vec2 v_texCoord;\n" +"uniform sampler2D tex0;\n" +"\n" +"void main()\n" +"{\n" +" gl_FragColor = texture2D(tex0, v_texCoord) * v_color;\n" +"}" + }, +#ifdef SDL_HAVE_YUV + // SHADER_YUV + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader + YUV_SHADER_PROLOGUE + YUV_SHADER_BODY + }, + // SHADER_NV12_RA + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader + NV12_SHADER_PROLOGUE + NV12_RA_SHADER_BODY + }, + // SHADER_NV12_RG + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader + NV12_SHADER_PROLOGUE + NV12_RG_SHADER_BODY + }, + // SHADER_NV21_RA + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader + NV12_SHADER_PROLOGUE + NV21_RA_SHADER_BODY + }, + // SHADER_NV21_RG + { + // vertex shader + TEXTURE_VERTEX_SHADER, + // fragment shader + NV12_SHADER_PROLOGUE + NV21_RG_SHADER_BODY + }, +#endif // SDL_HAVE_YUV +}; + +/* *INDENT-ON* */ // clang-format on + +static bool CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const char *defines, const char *source) +{ + GLint status; + const char *sources[2]; + + sources[0] = defines; + sources[1] = source; + + ctx->glShaderSourceARB(shader, SDL_arraysize(sources), sources, NULL); + ctx->glCompileShaderARB(shader); + ctx->glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status); + if (status == 0) { + bool isstack; + GLint length; + char *info; + + ctx->glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length); + info = SDL_small_alloc(char, length + 1, &isstack); + if (info) { + ctx->glGetInfoLogARB(shader, length, NULL, info); + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Failed to compile shader:"); + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", defines); + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", source); + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", info); + SDL_small_free(info, isstack); + } + return false; + } else { + return true; + } +} + +static bool CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_ShaderData *data) +{ + const int num_tmus_bound = 4; + const char *vert_defines = ""; + const char *frag_defines = ""; + int i; + GLint location; + + if (index == SHADER_NONE) { + return true; + } + + ctx->glGetError(); + + // Make sure we use the correct sampler type for our texture type + if (ctx->GL_ARB_texture_rectangle_supported) { + frag_defines = + "#define sampler2D sampler2DRect\n" + "#define texture2D texture2DRect\n" + "#define UVCoordScale 0.5\n"; + } else { + frag_defines = + "#define UVCoordScale 1.0\n"; + } + + // Create one program object to rule them all + data->program = ctx->glCreateProgramObjectARB(); + + // Create the vertex shader + data->vert_shader = ctx->glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); + if (!CompileShader(ctx, data->vert_shader, vert_defines, shader_source[index][0])) { + return false; + } + + // Create the fragment shader + data->frag_shader = ctx->glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); + if (!CompileShader(ctx, data->frag_shader, frag_defines, shader_source[index][1])) { + return false; + } + + // ... and in the darkness bind them + ctx->glAttachObjectARB(data->program, data->vert_shader); + ctx->glAttachObjectARB(data->program, data->frag_shader); + ctx->glLinkProgramARB(data->program); + + // Set up some uniform variables + ctx->glUseProgramObjectARB(data->program); + for (i = 0; i < num_tmus_bound; ++i) { + char tex_name[10]; + (void)SDL_snprintf(tex_name, SDL_arraysize(tex_name), "tex%d", i); + location = ctx->glGetUniformLocationARB(data->program, tex_name); + if (location >= 0) { + ctx->glUniform1iARB(location, i); + } + } + ctx->glUseProgramObjectARB(0); + + return ctx->glGetError() == GL_NO_ERROR; +} + +static void DestroyShaderProgram(GL_ShaderContext *ctx, GL_ShaderData *data) +{ + ctx->glDeleteObjectARB(data->vert_shader); + ctx->glDeleteObjectARB(data->frag_shader); + ctx->glDeleteObjectARB(data->program); +} + +GL_ShaderContext *GL_CreateShaderContext(void) +{ + GL_ShaderContext *ctx; + bool shaders_supported; + int i; + + ctx = (GL_ShaderContext *)SDL_calloc(1, sizeof(*ctx)); + if (!ctx) { + return NULL; + } + + if (!SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two") && + (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") || + SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle"))) { + ctx->GL_ARB_texture_rectangle_supported = true; + } + + // Check for shader support + shaders_supported = false; + if (SDL_GL_ExtensionSupported("GL_ARB_shader_objects") && + SDL_GL_ExtensionSupported("GL_ARB_shading_language_100") && + SDL_GL_ExtensionSupported("GL_ARB_vertex_shader") && + SDL_GL_ExtensionSupported("GL_ARB_fragment_shader")) { + ctx->glGetError = (GLenum(*)(void))SDL_GL_GetProcAddress("glGetError"); + ctx->glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)SDL_GL_GetProcAddress("glAttachObjectARB"); + ctx->glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)SDL_GL_GetProcAddress("glCompileShaderARB"); + ctx->glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glCreateProgramObjectARB"); + ctx->glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)SDL_GL_GetProcAddress("glCreateShaderObjectARB"); + ctx->glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)SDL_GL_GetProcAddress("glDeleteObjectARB"); + ctx->glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)SDL_GL_GetProcAddress("glGetInfoLogARB"); + ctx->glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)SDL_GL_GetProcAddress("glGetObjectParameterivARB"); + ctx->glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)SDL_GL_GetProcAddress("glGetUniformLocationARB"); + ctx->glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)SDL_GL_GetProcAddress("glLinkProgramARB"); + ctx->glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)SDL_GL_GetProcAddress("glShaderSourceARB"); + ctx->glUniform1iARB = (PFNGLUNIFORM1IARBPROC)SDL_GL_GetProcAddress("glUniform1iARB"); + ctx->glUniform1fARB = (PFNGLUNIFORM1FARBPROC)SDL_GL_GetProcAddress("glUniform1fARB"); + ctx->glUniform3fARB = (PFNGLUNIFORM3FARBPROC)SDL_GL_GetProcAddress("glUniform3fARB"); + ctx->glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glUseProgramObjectARB"); + if (ctx->glGetError && + ctx->glAttachObjectARB && + ctx->glCompileShaderARB && + ctx->glCreateProgramObjectARB && + ctx->glCreateShaderObjectARB && + ctx->glDeleteObjectARB && + ctx->glGetInfoLogARB && + ctx->glGetObjectParameterivARB && + ctx->glGetUniformLocationARB && + ctx->glLinkProgramARB && + ctx->glShaderSourceARB && + ctx->glUniform1iARB && + ctx->glUniform1fARB && + ctx->glUniform3fARB && + ctx->glUseProgramObjectARB) { + shaders_supported = true; + } + } + + if (!shaders_supported) { + SDL_free(ctx); + return NULL; + } + + // Compile all the shaders + for (i = 0; i < NUM_SHADERS; ++i) { + if (!CompileShaderProgram(ctx, i, &ctx->shaders[i])) { + GL_DestroyShaderContext(ctx); + return NULL; + } + } + + // We're done! + return ctx; +} + +void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader, const float *shader_params) +{ + GLint location; + GLhandleARB program = ctx->shaders[shader].program; + + ctx->glUseProgramObjectARB(program); + + if (shader_params && shader_params != ctx->shader_params[shader]) { + // YUV shader params are Yoffset, 0, Rcoeff, 0, Gcoeff, 0, Bcoeff, 0 + location = ctx->glGetUniformLocationARB(program, "Yoffset"); + if (location >= 0) { + ctx->glUniform3fARB(location, shader_params[0], shader_params[1], shader_params[2]); + } + location = ctx->glGetUniformLocationARB(program, "Rcoeff"); + if (location >= 0) { + ctx->glUniform3fARB(location, shader_params[4], shader_params[5], shader_params[6]); + } + location = ctx->glGetUniformLocationARB(program, "Gcoeff"); + if (location >= 0) { + ctx->glUniform3fARB(location, shader_params[8], shader_params[9], shader_params[10]); + } + location = ctx->glGetUniformLocationARB(program, "Bcoeff"); + if (location >= 0) { + ctx->glUniform3fARB(location, shader_params[12], shader_params[13], shader_params[14]); + } + ctx->shader_params[shader] = shader_params; + } +} + +void GL_DestroyShaderContext(GL_ShaderContext *ctx) +{ + int i; + + for (i = 0; i < NUM_SHADERS; ++i) { + DestroyShaderProgram(ctx, &ctx->shaders[i]); + } + SDL_free(ctx); +} + +#endif // SDL_VIDEO_RENDER_OGL diff --git a/contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h b/contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h new file mode 100644 index 0000000..374940a --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h @@ -0,0 +1,52 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef SDL_shaders_gl_h_ +#define SDL_shaders_gl_h_ + +#include "SDL_internal.h" + +// OpenGL shader implementation + +typedef enum +{ + SHADER_INVALID = -1, + SHADER_NONE, + SHADER_SOLID, + SHADER_RGB, + SHADER_RGBA, +#ifdef SDL_HAVE_YUV + SHADER_YUV, + SHADER_NV12_RA, + SHADER_NV12_RG, + SHADER_NV21_RA, + SHADER_NV21_RG, +#endif + NUM_SHADERS +} GL_Shader; + +typedef struct GL_ShaderContext GL_ShaderContext; + +extern GL_ShaderContext *GL_CreateShaderContext(void); +extern void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader, const float *shader_params); +extern void GL_DestroyShaderContext(GL_ShaderContext *ctx); + +#endif // SDL_shaders_gl_h_ -- cgit v1.2.3