SDL_render_gl.c 71 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975
  1. /*
  2. Simple DirectMedia Layer
  3. Copyright (C) 1997-2024 Sam Lantinga <[email protected]>
  4. This software is provided 'as-is', without any express or implied
  5. warranty. In no event will the authors be held liable for any damages
  6. arising from the use of this software.
  7. Permission is granted to anyone to use this software for any purpose,
  8. including commercial applications, and to alter it and redistribute it
  9. freely, subject to the following restrictions:
  10. 1. The origin of this software must not be misrepresented; you must not
  11. claim that you wrote the original software. If you use this software
  12. in a product, an acknowledgment in the product documentation would be
  13. appreciated but is not required.
  14. 2. Altered source versions must be plainly marked as such, and must not be
  15. misrepresented as being the original software.
  16. 3. This notice may not be removed or altered from any source distribution.
  17. */
  18. #include "../../SDL_internal.h"
  19. #if SDL_VIDEO_RENDER_OGL
  20. #include "SDL_hints.h"
  21. #include "../../video/SDL_sysvideo.h" /* For SDL_GL_SwapWindowWithResult */
  22. #include "SDL_opengl.h"
  23. #include "../SDL_sysrender.h"
  24. #include "SDL_shaders_gl.h"
  25. #include "../../SDL_utils_c.h"
  26. #ifdef __MACOSX__
  27. #include <OpenGL/OpenGL.h>
  28. #endif
  29. #ifdef SDL_VIDEO_VITA_PVR_OGL
  30. #include <GL/gl.h>
  31. #include <GL/glext.h>
  32. #endif
  33. /* To prevent unnecessary window recreation,
  34. * these should match the defaults selected in SDL_GL_ResetAttributes
  35. */
  36. #define RENDERER_CONTEXT_MAJOR 2
  37. #define RENDERER_CONTEXT_MINOR 1
  38. /* OpenGL renderer implementation */
  39. /* Details on optimizing the texture path on Mac OS X:
  40. http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/opengl_texturedata.html
  41. */
  42. static const float inv255f = 1.0f / 255.0f;
  43. typedef struct GL_FBOList GL_FBOList;
  44. struct GL_FBOList
  45. {
  46. Uint32 w, h;
  47. GLuint FBO;
  48. GL_FBOList *next;
  49. };
  50. typedef struct
  51. {
  52. SDL_bool viewport_dirty;
  53. SDL_Rect viewport;
  54. SDL_Texture *texture;
  55. SDL_Texture *target;
  56. int drawablew;
  57. int drawableh;
  58. SDL_BlendMode blend;
  59. GL_Shader shader;
  60. SDL_bool cliprect_enabled_dirty;
  61. SDL_bool cliprect_enabled;
  62. SDL_bool cliprect_dirty;
  63. SDL_Rect cliprect;
  64. SDL_bool texturing;
  65. SDL_bool vertex_array;
  66. SDL_bool color_array;
  67. SDL_bool texture_array;
  68. Uint32 color;
  69. Uint32 clear_color;
  70. } GL_DrawStateCache;
  71. typedef struct
  72. {
  73. SDL_GLContext context;
  74. SDL_bool debug_enabled;
  75. SDL_bool GL_ARB_debug_output_supported;
  76. int errors;
  77. char **error_messages;
  78. GLDEBUGPROCARB next_error_callback;
  79. GLvoid *next_error_userparam;
  80. GLenum textype;
  81. SDL_bool GL_ARB_texture_non_power_of_two_supported;
  82. SDL_bool GL_ARB_texture_rectangle_supported;
  83. SDL_bool GL_EXT_framebuffer_object_supported;
  84. GL_FBOList *framebuffers;
  85. /* OpenGL functions */
  86. #define SDL_PROC(ret, func, params) ret (APIENTRY *func) params;
  87. #include "SDL_glfuncs.h"
  88. #undef SDL_PROC
  89. /* Multitexture support */
  90. SDL_bool GL_ARB_multitexture_supported;
  91. PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
  92. GLint num_texture_units;
  93. PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
  94. PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
  95. PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
  96. PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
  97. PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
  98. /* Shader support */
  99. GL_ShaderContext *shaders;
  100. GL_DrawStateCache drawstate;
  101. } GL_RenderData;
  102. typedef struct
  103. {
  104. GLuint texture;
  105. GLfloat texw;
  106. GLfloat texh;
  107. GLenum format;
  108. GLenum formattype;
  109. GL_Shader shader;
  110. void *pixels;
  111. int pitch;
  112. SDL_Rect locked_rect;
  113. #if SDL_HAVE_YUV
  114. /* YUV texture support */
  115. SDL_bool yuv;
  116. SDL_bool nv12;
  117. GLuint utexture;
  118. GLuint vtexture;
  119. #endif
  120. GL_FBOList *fbo;
  121. } GL_TextureData;
  122. SDL_FORCE_INLINE const char *
  123. GL_TranslateError(GLenum error)
  124. {
  125. #define GL_ERROR_TRANSLATE(e) \
  126. case e: \
  127. return #e;
  128. switch (error) {
  129. GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
  130. GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
  131. GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
  132. GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
  133. GL_ERROR_TRANSLATE(GL_NO_ERROR)
  134. GL_ERROR_TRANSLATE(GL_STACK_OVERFLOW)
  135. GL_ERROR_TRANSLATE(GL_STACK_UNDERFLOW)
  136. GL_ERROR_TRANSLATE(GL_TABLE_TOO_LARGE)
  137. default:
  138. return "UNKNOWN";
  139. }
  140. #undef GL_ERROR_TRANSLATE
  141. }
  142. SDL_FORCE_INLINE void
  143. GL_ClearErrors(SDL_Renderer *renderer)
  144. {
  145. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  146. if (!data->debug_enabled) {
  147. return;
  148. }
  149. if (data->GL_ARB_debug_output_supported) {
  150. if (data->errors) {
  151. int i;
  152. for (i = 0; i < data->errors; ++i) {
  153. SDL_free(data->error_messages[i]);
  154. }
  155. SDL_free(data->error_messages);
  156. data->errors = 0;
  157. data->error_messages = NULL;
  158. }
  159. } else if (data->glGetError) {
  160. while (data->glGetError() != GL_NO_ERROR) {
  161. /* continue; */
  162. }
  163. }
  164. }
  165. SDL_FORCE_INLINE int
  166. GL_CheckAllErrors(const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)
  167. {
  168. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  169. int ret = 0;
  170. if (!data->debug_enabled) {
  171. return 0;
  172. }
  173. if (data->GL_ARB_debug_output_supported) {
  174. if (data->errors) {
  175. int i;
  176. for (i = 0; i < data->errors; ++i) {
  177. SDL_SetError("%s: %s (%d): %s %s", prefix, file, line, function, data->error_messages[i]);
  178. ret = -1;
  179. }
  180. GL_ClearErrors(renderer);
  181. }
  182. } else {
  183. /* check gl errors (can return multiple errors) */
  184. for (;;) {
  185. GLenum error = data->glGetError();
  186. if (error != GL_NO_ERROR) {
  187. if (prefix == NULL || prefix[0] == '\0') {
  188. prefix = "generic";
  189. }
  190. SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
  191. ret = -1;
  192. } else {
  193. break;
  194. }
  195. }
  196. }
  197. return ret;
  198. }
  199. #if 0
  200. #define GL_CheckError(prefix, renderer)
  201. #else
  202. #define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION)
  203. #endif
  204. static int GL_LoadFunctions(GL_RenderData *data)
  205. {
  206. #ifdef __SDL_NOGETPROCADDR__
  207. #define SDL_PROC(ret, func, params) data->func = func;
  208. #else
  209. int retval = 0;
  210. #define SDL_PROC(ret, func, params) \
  211. do { \
  212. data->func = SDL_GL_GetProcAddress(#func); \
  213. if (!data->func) { \
  214. retval = SDL_SetError("Couldn't load GL function %s: %s", #func, SDL_GetError()); \
  215. } \
  216. } while (0);
  217. #endif /* __SDL_NOGETPROCADDR__ */
  218. #include "SDL_glfuncs.h"
  219. #undef SDL_PROC
  220. return retval;
  221. }
  222. static int GL_ActivateRenderer(SDL_Renderer *renderer)
  223. {
  224. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  225. if (SDL_GL_GetCurrentContext() != data->context) {
  226. if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
  227. return -1;
  228. }
  229. }
  230. GL_ClearErrors(renderer);
  231. return 0;
  232. }
  233. static void APIENTRY GL_HandleDebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, const void *userParam)
  234. {
  235. SDL_Renderer *renderer = (SDL_Renderer *)userParam;
  236. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  237. if (type == GL_DEBUG_TYPE_ERROR_ARB) {
  238. /* Record this error */
  239. int errors = data->errors + 1;
  240. char **error_messages = SDL_realloc(data->error_messages, errors * sizeof(*data->error_messages));
  241. if (error_messages) {
  242. data->errors = errors;
  243. data->error_messages = error_messages;
  244. data->error_messages[data->errors - 1] = SDL_strdup(message);
  245. }
  246. }
  247. /* If there's another error callback, pass it along, otherwise log it */
  248. if (data->next_error_callback) {
  249. data->next_error_callback(source, type, id, severity, length, message, data->next_error_userparam);
  250. } else {
  251. if (type == GL_DEBUG_TYPE_ERROR_ARB) {
  252. SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", message);
  253. } else {
  254. SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "%s", message);
  255. }
  256. }
  257. }
  258. static GL_FBOList *GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h)
  259. {
  260. GL_FBOList *result = data->framebuffers;
  261. while (result && ((result->w != w) || (result->h != h))) {
  262. result = result->next;
  263. }
  264. if (!result) {
  265. result = SDL_malloc(sizeof(GL_FBOList));
  266. if (result) {
  267. result->w = w;
  268. result->h = h;
  269. data->glGenFramebuffersEXT(1, &result->FBO);
  270. result->next = data->framebuffers;
  271. data->framebuffers = result;
  272. }
  273. }
  274. return result;
  275. }
  276. static void GL_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
  277. {
  278. /* If the window x/y/w/h changed at all, assume the viewport has been
  279. * changed behind our backs. x/y changes might seem weird but viewport
  280. * resets have been observed on macOS at minimum!
  281. */
  282. if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED ||
  283. event->event == SDL_WINDOWEVENT_MOVED) {
  284. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  285. data->drawstate.viewport_dirty = SDL_TRUE;
  286. }
  287. }
  288. static int GL_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
  289. {
  290. SDL_GL_GetDrawableSize(renderer->window, w, h);
  291. return 0;
  292. }
  293. static GLenum GetBlendFunc(SDL_BlendFactor factor)
  294. {
  295. switch (factor) {
  296. case SDL_BLENDFACTOR_ZERO:
  297. return GL_ZERO;
  298. case SDL_BLENDFACTOR_ONE:
  299. return GL_ONE;
  300. case SDL_BLENDFACTOR_SRC_COLOR:
  301. return GL_SRC_COLOR;
  302. case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
  303. return GL_ONE_MINUS_SRC_COLOR;
  304. case SDL_BLENDFACTOR_SRC_ALPHA:
  305. return GL_SRC_ALPHA;
  306. case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
  307. return GL_ONE_MINUS_SRC_ALPHA;
  308. case SDL_BLENDFACTOR_DST_COLOR:
  309. return GL_DST_COLOR;
  310. case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
  311. return GL_ONE_MINUS_DST_COLOR;
  312. case SDL_BLENDFACTOR_DST_ALPHA:
  313. return GL_DST_ALPHA;
  314. case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
  315. return GL_ONE_MINUS_DST_ALPHA;
  316. default:
  317. return GL_INVALID_ENUM;
  318. }
  319. }
  320. static GLenum GetBlendEquation(SDL_BlendOperation operation)
  321. {
  322. switch (operation) {
  323. case SDL_BLENDOPERATION_ADD:
  324. return GL_FUNC_ADD;
  325. case SDL_BLENDOPERATION_SUBTRACT:
  326. return GL_FUNC_SUBTRACT;
  327. case SDL_BLENDOPERATION_REV_SUBTRACT:
  328. return GL_FUNC_REVERSE_SUBTRACT;
  329. case SDL_BLENDOPERATION_MINIMUM:
  330. return GL_MIN;
  331. case SDL_BLENDOPERATION_MAXIMUM:
  332. return GL_MAX;
  333. default:
  334. return GL_INVALID_ENUM;
  335. }
  336. }
  337. static SDL_bool GL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
  338. {
  339. SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
  340. SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
  341. SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
  342. SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
  343. SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
  344. SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
  345. if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
  346. GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
  347. GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
  348. GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
  349. GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
  350. GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
  351. return SDL_FALSE;
  352. }
  353. if (colorOperation != alphaOperation) {
  354. return SDL_FALSE;
  355. }
  356. return SDL_TRUE;
  357. }
  358. SDL_FORCE_INLINE SDL_bool
  359. convert_format(GL_RenderData *renderdata, Uint32 pixel_format,
  360. GLint *internalFormat, GLenum *format, GLenum *type)
  361. {
  362. switch (pixel_format) {
  363. case SDL_PIXELFORMAT_ARGB8888:
  364. case SDL_PIXELFORMAT_RGB888:
  365. *internalFormat = GL_RGBA8;
  366. *format = GL_BGRA;
  367. *type = GL_UNSIGNED_INT_8_8_8_8_REV;
  368. break;
  369. case SDL_PIXELFORMAT_ABGR8888:
  370. case SDL_PIXELFORMAT_BGR888:
  371. *internalFormat = GL_RGBA8;
  372. *format = GL_RGBA;
  373. *type = GL_UNSIGNED_INT_8_8_8_8_REV;
  374. break;
  375. case SDL_PIXELFORMAT_YV12:
  376. case SDL_PIXELFORMAT_IYUV:
  377. case SDL_PIXELFORMAT_NV12:
  378. case SDL_PIXELFORMAT_NV21:
  379. *internalFormat = GL_LUMINANCE;
  380. *format = GL_LUMINANCE;
  381. *type = GL_UNSIGNED_BYTE;
  382. break;
  383. #ifdef __MACOSX__
  384. case SDL_PIXELFORMAT_UYVY:
  385. *internalFormat = GL_RGB8;
  386. *format = GL_YCBCR_422_APPLE;
  387. *type = GL_UNSIGNED_SHORT_8_8_APPLE;
  388. break;
  389. #endif
  390. default:
  391. return SDL_FALSE;
  392. }
  393. return SDL_TRUE;
  394. }
  395. static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
  396. {
  397. GL_RenderData *renderdata = (GL_RenderData *)renderer->driverdata;
  398. const GLenum textype = renderdata->textype;
  399. GL_TextureData *data;
  400. GLint internalFormat;
  401. GLenum format, type;
  402. int texture_w, texture_h;
  403. GLenum scaleMode;
  404. GL_ActivateRenderer(renderer);
  405. renderdata->drawstate.texture = NULL; /* we trash this state. */
  406. renderdata->drawstate.texturing = SDL_FALSE; /* we trash this state. */
  407. if (texture->access == SDL_TEXTUREACCESS_TARGET &&
  408. !renderdata->GL_EXT_framebuffer_object_supported) {
  409. return SDL_SetError("Render targets not supported by OpenGL");
  410. }
  411. if (!convert_format(renderdata, texture->format, &internalFormat,
  412. &format, &type)) {
  413. return SDL_SetError("Texture format %s not supported by OpenGL",
  414. SDL_GetPixelFormatName(texture->format));
  415. }
  416. data = (GL_TextureData *)SDL_calloc(1, sizeof(*data));
  417. if (!data) {
  418. return SDL_OutOfMemory();
  419. }
  420. if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
  421. size_t size;
  422. data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
  423. size = (size_t)texture->h * data->pitch;
  424. if (texture->format == SDL_PIXELFORMAT_YV12 ||
  425. texture->format == SDL_PIXELFORMAT_IYUV) {
  426. /* Need to add size for the U and V planes */
  427. size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
  428. }
  429. if (texture->format == SDL_PIXELFORMAT_NV12 ||
  430. texture->format == SDL_PIXELFORMAT_NV21) {
  431. /* Need to add size for the U/V plane */
  432. size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
  433. }
  434. data->pixels = SDL_calloc(1, size);
  435. if (!data->pixels) {
  436. SDL_free(data);
  437. return SDL_OutOfMemory();
  438. }
  439. }
  440. if (texture->access == SDL_TEXTUREACCESS_TARGET) {
  441. data->fbo = GL_GetFBO(renderdata, texture->w, texture->h);
  442. } else {
  443. data->fbo = NULL;
  444. }
  445. GL_CheckError("", renderer);
  446. renderdata->glGenTextures(1, &data->texture);
  447. if (GL_CheckError("glGenTextures()", renderer) < 0) {
  448. if (data->pixels) {
  449. SDL_free(data->pixels);
  450. }
  451. SDL_free(data);
  452. return -1;
  453. }
  454. texture->driverdata = data;
  455. if (renderdata->GL_ARB_texture_non_power_of_two_supported) {
  456. texture_w = texture->w;
  457. texture_h = texture->h;
  458. data->texw = 1.0f;
  459. data->texh = 1.0f;
  460. } else if (renderdata->GL_ARB_texture_rectangle_supported) {
  461. texture_w = texture->w;
  462. texture_h = texture->h;
  463. data->texw = (GLfloat)texture_w;
  464. data->texh = (GLfloat)texture_h;
  465. } else {
  466. texture_w = SDL_powerof2(texture->w);
  467. texture_h = SDL_powerof2(texture->h);
  468. data->texw = (GLfloat)(texture->w) / texture_w;
  469. data->texh = (GLfloat)texture->h / texture_h;
  470. }
  471. data->format = format;
  472. data->formattype = type;
  473. scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
  474. renderdata->glEnable(textype);
  475. renderdata->glBindTexture(textype, data->texture);
  476. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, scaleMode);
  477. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, scaleMode);
  478. /* According to the spec, CLAMP_TO_EDGE is the default for TEXTURE_RECTANGLE
  479. and setting it causes an INVALID_ENUM error in the latest NVidia drivers.
  480. */
  481. if (textype != GL_TEXTURE_RECTANGLE_ARB) {
  482. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
  483. GL_CLAMP_TO_EDGE);
  484. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
  485. GL_CLAMP_TO_EDGE);
  486. }
  487. #ifdef __MACOSX__
  488. #ifndef GL_TEXTURE_STORAGE_HINT_APPLE
  489. #define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC
  490. #endif
  491. #ifndef STORAGE_CACHED_APPLE
  492. #define STORAGE_CACHED_APPLE 0x85BE
  493. #endif
  494. #ifndef STORAGE_SHARED_APPLE
  495. #define STORAGE_SHARED_APPLE 0x85BF
  496. #endif
  497. if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
  498. renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE,
  499. GL_STORAGE_SHARED_APPLE);
  500. } else {
  501. renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE,
  502. GL_STORAGE_CACHED_APPLE);
  503. }
  504. if (texture->access == SDL_TEXTUREACCESS_STREAMING && texture->format == SDL_PIXELFORMAT_ARGB8888 && (texture->w % 8) == 0) {
  505. renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
  506. renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  507. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
  508. (data->pitch / SDL_BYTESPERPIXEL(texture->format)));
  509. renderdata->glTexImage2D(textype, 0, internalFormat, texture_w,
  510. texture_h, 0, format, type, data->pixels);
  511. renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
  512. } else
  513. #endif
  514. {
  515. renderdata->glTexImage2D(textype, 0, internalFormat, texture_w,
  516. texture_h, 0, format, type, NULL);
  517. }
  518. renderdata->glDisable(textype);
  519. if (GL_CheckError("glTexImage2D()", renderer) < 0) {
  520. return -1;
  521. }
  522. #if SDL_HAVE_YUV
  523. if (texture->format == SDL_PIXELFORMAT_YV12 ||
  524. texture->format == SDL_PIXELFORMAT_IYUV) {
  525. data->yuv = SDL_TRUE;
  526. renderdata->glGenTextures(1, &data->utexture);
  527. renderdata->glGenTextures(1, &data->vtexture);
  528. renderdata->glBindTexture(textype, data->utexture);
  529. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
  530. scaleMode);
  531. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
  532. scaleMode);
  533. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
  534. GL_CLAMP_TO_EDGE);
  535. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
  536. GL_CLAMP_TO_EDGE);
  537. renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w + 1) / 2,
  538. (texture_h + 1) / 2, 0, format, type, NULL);
  539. renderdata->glBindTexture(textype, data->vtexture);
  540. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
  541. scaleMode);
  542. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
  543. scaleMode);
  544. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
  545. GL_CLAMP_TO_EDGE);
  546. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
  547. GL_CLAMP_TO_EDGE);
  548. renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w + 1) / 2,
  549. (texture_h + 1) / 2, 0, format, type, NULL);
  550. }
  551. if (texture->format == SDL_PIXELFORMAT_NV12 ||
  552. texture->format == SDL_PIXELFORMAT_NV21) {
  553. data->nv12 = SDL_TRUE;
  554. renderdata->glGenTextures(1, &data->utexture);
  555. renderdata->glBindTexture(textype, data->utexture);
  556. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
  557. scaleMode);
  558. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
  559. scaleMode);
  560. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
  561. GL_CLAMP_TO_EDGE);
  562. renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
  563. GL_CLAMP_TO_EDGE);
  564. renderdata->glTexImage2D(textype, 0, GL_LUMINANCE_ALPHA, (texture_w + 1) / 2,
  565. (texture_h + 1) / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
  566. }
  567. #endif
  568. if (texture->format == SDL_PIXELFORMAT_ABGR8888 || texture->format == SDL_PIXELFORMAT_ARGB8888) {
  569. data->shader = SHADER_RGBA;
  570. } else {
  571. data->shader = SHADER_RGB;
  572. }
  573. #if SDL_HAVE_YUV
  574. if (data->yuv || data->nv12) {
  575. switch (SDL_GetYUVConversionModeForResolution(texture->w, texture->h)) {
  576. case SDL_YUV_CONVERSION_JPEG:
  577. if (data->yuv) {
  578. data->shader = SHADER_YUV_JPEG;
  579. } else if (texture->format == SDL_PIXELFORMAT_NV12) {
  580. data->shader = SHADER_NV12_JPEG;
  581. } else {
  582. data->shader = SHADER_NV21_JPEG;
  583. }
  584. break;
  585. case SDL_YUV_CONVERSION_BT601:
  586. if (data->yuv) {
  587. data->shader = SHADER_YUV_BT601;
  588. } else if (texture->format == SDL_PIXELFORMAT_NV12) {
  589. if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
  590. data->shader = SHADER_NV12_RG_BT601;
  591. } else {
  592. data->shader = SHADER_NV12_RA_BT601;
  593. }
  594. } else {
  595. data->shader = SHADER_NV21_BT601;
  596. }
  597. break;
  598. case SDL_YUV_CONVERSION_BT709:
  599. if (data->yuv) {
  600. data->shader = SHADER_YUV_BT709;
  601. } else if (texture->format == SDL_PIXELFORMAT_NV12) {
  602. if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
  603. data->shader = SHADER_NV12_RG_BT709;
  604. } else {
  605. data->shader = SHADER_NV12_RA_BT709;
  606. }
  607. } else {
  608. data->shader = SHADER_NV21_BT709;
  609. }
  610. break;
  611. default:
  612. SDL_assert(!"unsupported YUV conversion mode");
  613. break;
  614. }
  615. }
  616. #endif /* SDL_HAVE_YUV */
  617. return GL_CheckError("", renderer);
  618. }
  619. static int GL_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
  620. const SDL_Rect *rect, const void *pixels, int pitch)
  621. {
  622. GL_RenderData *renderdata = (GL_RenderData *)renderer->driverdata;
  623. const GLenum textype = renderdata->textype;
  624. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  625. const int texturebpp = SDL_BYTESPERPIXEL(texture->format);
  626. SDL_assert_release(texturebpp != 0); /* otherwise, division by zero later. */
  627. GL_ActivateRenderer(renderer);
  628. renderdata->drawstate.texture = NULL; /* we trash this state. */
  629. renderdata->glBindTexture(textype, data->texture);
  630. renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  631. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, (pitch / texturebpp));
  632. renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
  633. rect->h, data->format, data->formattype,
  634. pixels);
  635. #if SDL_HAVE_YUV
  636. if (data->yuv) {
  637. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
  638. /* Skip to the correct offset into the next texture */
  639. pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
  640. if (texture->format == SDL_PIXELFORMAT_YV12) {
  641. renderdata->glBindTexture(textype, data->vtexture);
  642. } else {
  643. renderdata->glBindTexture(textype, data->utexture);
  644. }
  645. renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
  646. (rect->w + 1) / 2, (rect->h + 1) / 2,
  647. data->format, data->formattype, pixels);
  648. /* Skip to the correct offset into the next texture */
  649. pixels = (const void *)((const Uint8 *)pixels + ((rect->h + 1) / 2) * ((pitch + 1) / 2));
  650. if (texture->format == SDL_PIXELFORMAT_YV12) {
  651. renderdata->glBindTexture(textype, data->utexture);
  652. } else {
  653. renderdata->glBindTexture(textype, data->vtexture);
  654. }
  655. renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
  656. (rect->w + 1) / 2, (rect->h + 1) / 2,
  657. data->format, data->formattype, pixels);
  658. }
  659. if (data->nv12) {
  660. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
  661. /* Skip to the correct offset into the next texture */
  662. pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
  663. renderdata->glBindTexture(textype, data->utexture);
  664. renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
  665. (rect->w + 1) / 2, (rect->h + 1) / 2,
  666. GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixels);
  667. }
  668. #endif
  669. return GL_CheckError("glTexSubImage2D()", renderer);
  670. }
  671. #if SDL_HAVE_YUV
  672. static int GL_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
  673. const SDL_Rect *rect,
  674. const Uint8 *Yplane, int Ypitch,
  675. const Uint8 *Uplane, int Upitch,
  676. const Uint8 *Vplane, int Vpitch)
  677. {
  678. GL_RenderData *renderdata = (GL_RenderData *)renderer->driverdata;
  679. const GLenum textype = renderdata->textype;
  680. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  681. GL_ActivateRenderer(renderer);
  682. renderdata->drawstate.texture = NULL; /* we trash this state. */
  683. renderdata->glBindTexture(textype, data->texture);
  684. renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  685. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
  686. renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
  687. rect->h, data->format, data->formattype,
  688. Yplane);
  689. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Upitch);
  690. renderdata->glBindTexture(textype, data->utexture);
  691. renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
  692. (rect->w + 1) / 2, (rect->h + 1) / 2,
  693. data->format, data->formattype, Uplane);
  694. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Vpitch);
  695. renderdata->glBindTexture(textype, data->vtexture);
  696. renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
  697. (rect->w + 1) / 2, (rect->h + 1) / 2,
  698. data->format, data->formattype, Vplane);
  699. return GL_CheckError("glTexSubImage2D()", renderer);
  700. }
  701. static int GL_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
  702. const SDL_Rect *rect,
  703. const Uint8 *Yplane, int Ypitch,
  704. const Uint8 *UVplane, int UVpitch)
  705. {
  706. GL_RenderData *renderdata = (GL_RenderData *)renderer->driverdata;
  707. const GLenum textype = renderdata->textype;
  708. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  709. GL_ActivateRenderer(renderer);
  710. renderdata->drawstate.texture = NULL; /* we trash this state. */
  711. renderdata->glBindTexture(textype, data->texture);
  712. renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  713. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
  714. renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
  715. rect->h, data->format, data->formattype,
  716. Yplane);
  717. renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, UVpitch / 2);
  718. renderdata->glBindTexture(textype, data->utexture);
  719. renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
  720. (rect->w + 1) / 2, (rect->h + 1) / 2,
  721. GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, UVplane);
  722. return GL_CheckError("glTexSubImage2D()", renderer);
  723. }
  724. #endif
  725. static int GL_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
  726. const SDL_Rect *rect, void **pixels, int *pitch)
  727. {
  728. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  729. data->locked_rect = *rect;
  730. *pixels =
  731. (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
  732. rect->x * SDL_BYTESPERPIXEL(texture->format));
  733. *pitch = data->pitch;
  734. return 0;
  735. }
  736. static void GL_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
  737. {
  738. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  739. const SDL_Rect *rect;
  740. void *pixels;
  741. rect = &data->locked_rect;
  742. pixels =
  743. (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
  744. rect->x * SDL_BYTESPERPIXEL(texture->format));
  745. GL_UpdateTexture(renderer, texture, rect, pixels, data->pitch);
  746. }
  747. static void GL_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
  748. {
  749. GL_RenderData *renderdata = (GL_RenderData *)renderer->driverdata;
  750. const GLenum textype = renderdata->textype;
  751. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  752. GLenum glScaleMode = (scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
  753. renderdata->glBindTexture(textype, data->texture);
  754. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
  755. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
  756. #if SDL_HAVE_YUV
  757. if (texture->format == SDL_PIXELFORMAT_YV12 ||
  758. texture->format == SDL_PIXELFORMAT_IYUV) {
  759. renderdata->glBindTexture(textype, data->utexture);
  760. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
  761. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
  762. renderdata->glBindTexture(textype, data->vtexture);
  763. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
  764. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
  765. }
  766. if (texture->format == SDL_PIXELFORMAT_NV12 ||
  767. texture->format == SDL_PIXELFORMAT_NV21) {
  768. renderdata->glBindTexture(textype, data->utexture);
  769. renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
  770. renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
  771. }
  772. #endif
  773. }
  774. static int GL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
  775. {
  776. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  777. GL_TextureData *texturedata;
  778. GLenum status;
  779. GL_ActivateRenderer(renderer);
  780. if (!data->GL_EXT_framebuffer_object_supported) {
  781. return SDL_SetError("Render targets not supported by OpenGL");
  782. }
  783. data->drawstate.viewport_dirty = SDL_TRUE;
  784. if (!texture) {
  785. data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  786. return 0;
  787. }
  788. texturedata = (GL_TextureData *)texture->driverdata;
  789. data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, texturedata->fbo->FBO);
  790. /* TODO: check if texture pixel format allows this operation */
  791. data->glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, data->textype, texturedata->texture, 0);
  792. /* Check FBO status */
  793. status = data->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
  794. if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
  795. return SDL_SetError("glFramebufferTexture2DEXT() failed");
  796. }
  797. return 0;
  798. }
  799. /* !!! FIXME: all these Queue* calls set up the vertex buffer the way the immediate mode
  800. !!! FIXME: renderer wants it, but this might want to operate differently if we move to
  801. !!! FIXME: VBOs at some point. */
  802. static int GL_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
  803. {
  804. return 0; /* nothing to do in this backend. */
  805. }
  806. static int GL_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
  807. {
  808. GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(GLfloat), 0, &cmd->data.draw.first);
  809. int i;
  810. if (!verts) {
  811. return -1;
  812. }
  813. cmd->data.draw.count = count;
  814. for (i = 0; i < count; i++) {
  815. *(verts++) = 0.5f + points[i].x;
  816. *(verts++) = 0.5f + points[i].y;
  817. }
  818. return 0;
  819. }
  820. static int GL_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
  821. {
  822. int i;
  823. GLfloat prevx, prevy;
  824. const size_t vertlen = (sizeof(GLfloat) * 2) * count;
  825. GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
  826. if (!verts) {
  827. return -1;
  828. }
  829. cmd->data.draw.count = count;
  830. /* 0.5f offset to hit the center of the pixel. */
  831. prevx = 0.5f + points->x;
  832. prevy = 0.5f + points->y;
  833. *(verts++) = prevx;
  834. *(verts++) = prevy;
  835. /* bump the end of each line segment out a quarter of a pixel, to provoke
  836. the diamond-exit rule. Without this, you won't just drop the last
  837. pixel of the last line segment, but you might also drop pixels at the
  838. edge of any given line segment along the way too. */
  839. for (i = 1; i < count; i++) {
  840. const GLfloat xstart = prevx;
  841. const GLfloat ystart = prevy;
  842. const GLfloat xend = points[i].x + 0.5f; /* 0.5f to hit pixel center. */
  843. const GLfloat yend = points[i].y + 0.5f;
  844. /* bump a little in the direction we are moving in. */
  845. const GLfloat deltax = xend - xstart;
  846. const GLfloat deltay = yend - ystart;
  847. const GLfloat angle = SDL_atan2f(deltay, deltax);
  848. prevx = xend + (SDL_cosf(angle) * 0.25f);
  849. prevy = yend + (SDL_sinf(angle) * 0.25f);
  850. *(verts++) = prevx;
  851. *(verts++) = prevy;
  852. }
  853. return 0;
  854. }
  855. static int GL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
  856. const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
  857. int num_vertices, const void *indices, int num_indices, int size_indices,
  858. float scale_x, float scale_y)
  859. {
  860. GL_TextureData *texturedata = NULL;
  861. int i;
  862. int count = indices ? num_indices : num_vertices;
  863. GLfloat *verts;
  864. size_t sz = 2 * sizeof(GLfloat) + 4 * sizeof(Uint8) + (texture ? 2 : 0) * sizeof(GLfloat);
  865. verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first);
  866. if (!verts) {
  867. return -1;
  868. }
  869. if (texture) {
  870. texturedata = (GL_TextureData *)texture->driverdata;
  871. }
  872. cmd->data.draw.count = count;
  873. size_indices = indices ? size_indices : 0;
  874. for (i = 0; i < count; i++) {
  875. int j;
  876. float *xy_;
  877. if (size_indices == 4) {
  878. j = ((const Uint32 *)indices)[i];
  879. } else if (size_indices == 2) {
  880. j = ((const Uint16 *)indices)[i];
  881. } else if (size_indices == 1) {
  882. j = ((const Uint8 *)indices)[i];
  883. } else {
  884. j = i;
  885. }
  886. xy_ = (float *)((char *)xy + j * xy_stride);
  887. *(verts++) = xy_[0] * scale_x;
  888. *(verts++) = xy_[1] * scale_y;
  889. /* Not really a float, but it is still 4 bytes and will be cast to the
  890. right type in the graphics driver. */
  891. SDL_memcpy(verts, ((char *)color + j * color_stride), sizeof(*color));
  892. ++verts;
  893. if (texture) {
  894. float *uv_ = (float *)((char *)uv + j * uv_stride);
  895. *(verts++) = uv_[0] * texturedata->texw;
  896. *(verts++) = uv_[1] * texturedata->texh;
  897. }
  898. }
  899. return 0;
  900. }
  901. static int SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader shader)
  902. {
  903. const SDL_BlendMode blend = cmd->data.draw.blend;
  904. SDL_bool vertex_array;
  905. SDL_bool color_array;
  906. SDL_bool texture_array;
  907. if (data->drawstate.viewport_dirty) {
  908. const SDL_bool istarget = data->drawstate.target != NULL;
  909. const SDL_Rect *viewport = &data->drawstate.viewport;
  910. data->glMatrixMode(GL_PROJECTION);
  911. data->glLoadIdentity();
  912. data->glViewport(viewport->x,
  913. istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
  914. viewport->w, viewport->h);
  915. if (viewport->w && viewport->h) {
  916. data->glOrtho((GLdouble)0, (GLdouble)viewport->w,
  917. (GLdouble)istarget ? 0 : viewport->h,
  918. (GLdouble)istarget ? viewport->h : 0,
  919. 0.0, 1.0);
  920. }
  921. data->glMatrixMode(GL_MODELVIEW);
  922. data->drawstate.viewport_dirty = SDL_FALSE;
  923. }
  924. if (data->drawstate.cliprect_enabled_dirty) {
  925. if (!data->drawstate.cliprect_enabled) {
  926. data->glDisable(GL_SCISSOR_TEST);
  927. } else {
  928. data->glEnable(GL_SCISSOR_TEST);
  929. }
  930. data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
  931. }
  932. if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
  933. const SDL_Rect *viewport = &data->drawstate.viewport;
  934. const SDL_Rect *rect = &data->drawstate.cliprect;
  935. data->glScissor(viewport->x + rect->x,
  936. data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
  937. rect->w, rect->h);
  938. data->drawstate.cliprect_dirty = SDL_FALSE;
  939. }
  940. if (blend != data->drawstate.blend) {
  941. if (blend == SDL_BLENDMODE_NONE) {
  942. data->glDisable(GL_BLEND);
  943. } else {
  944. data->glEnable(GL_BLEND);
  945. data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
  946. GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
  947. GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
  948. GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
  949. data->glBlendEquation(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
  950. }
  951. data->drawstate.blend = blend;
  952. }
  953. if (data->shaders && (shader != data->drawstate.shader)) {
  954. GL_SelectShader(data->shaders, shader);
  955. data->drawstate.shader = shader;
  956. }
  957. if ((cmd->data.draw.texture != NULL) != data->drawstate.texturing) {
  958. if (!cmd->data.draw.texture) {
  959. data->glDisable(data->textype);
  960. data->drawstate.texturing = SDL_FALSE;
  961. } else {
  962. data->glEnable(data->textype);
  963. data->drawstate.texturing = SDL_TRUE;
  964. }
  965. }
  966. vertex_array = cmd->command == SDL_RENDERCMD_DRAW_POINTS || cmd->command == SDL_RENDERCMD_DRAW_LINES || cmd->command == SDL_RENDERCMD_GEOMETRY;
  967. color_array = cmd->command == SDL_RENDERCMD_GEOMETRY;
  968. texture_array = cmd->data.draw.texture != NULL;
  969. if (vertex_array != data->drawstate.vertex_array) {
  970. if (vertex_array) {
  971. data->glEnableClientState(GL_VERTEX_ARRAY);
  972. } else {
  973. data->glDisableClientState(GL_VERTEX_ARRAY);
  974. }
  975. data->drawstate.vertex_array = vertex_array;
  976. }
  977. if (color_array != data->drawstate.color_array) {
  978. if (color_array) {
  979. data->glEnableClientState(GL_COLOR_ARRAY);
  980. } else {
  981. data->glDisableClientState(GL_COLOR_ARRAY);
  982. }
  983. data->drawstate.color_array = color_array;
  984. }
  985. /* This is a little awkward but should avoid texcoord arrays getting into
  986. a bad state if SDL_GL_BindTexture/UnbindTexture are called. */
  987. if (texture_array != data->drawstate.texture_array) {
  988. if (texture_array) {
  989. data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  990. } else {
  991. data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  992. }
  993. data->drawstate.texture_array = texture_array;
  994. }
  995. return 0;
  996. }
  997. static int SetCopyState(GL_RenderData *data, const SDL_RenderCommand *cmd)
  998. {
  999. SDL_Texture *texture = cmd->data.draw.texture;
  1000. const GL_TextureData *texturedata = (GL_TextureData *)texture->driverdata;
  1001. SetDrawState(data, cmd, texturedata->shader);
  1002. if (texture != data->drawstate.texture) {
  1003. const GLenum textype = data->textype;
  1004. #if SDL_HAVE_YUV
  1005. if (texturedata->yuv) {
  1006. if (data->GL_ARB_multitexture_supported) {
  1007. data->glActiveTextureARB(GL_TEXTURE2_ARB);
  1008. }
  1009. data->glBindTexture(textype, texturedata->vtexture);
  1010. if (data->GL_ARB_multitexture_supported) {
  1011. data->glActiveTextureARB(GL_TEXTURE1_ARB);
  1012. }
  1013. data->glBindTexture(textype, texturedata->utexture);
  1014. }
  1015. if (texturedata->nv12) {
  1016. if (data->GL_ARB_multitexture_supported) {
  1017. data->glActiveTextureARB(GL_TEXTURE1_ARB);
  1018. }
  1019. data->glBindTexture(textype, texturedata->utexture);
  1020. }
  1021. #endif
  1022. if (data->GL_ARB_multitexture_supported) {
  1023. data->glActiveTextureARB(GL_TEXTURE0_ARB);
  1024. }
  1025. data->glBindTexture(textype, texturedata->texture);
  1026. data->drawstate.texture = texture;
  1027. }
  1028. return 0;
  1029. }
  1030. static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
  1031. {
  1032. /* !!! FIXME: it'd be nice to use a vertex buffer instead of immediate mode... */
  1033. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  1034. if (GL_ActivateRenderer(renderer) < 0) {
  1035. return -1;
  1036. }
  1037. data->drawstate.target = renderer->target;
  1038. if (!data->drawstate.target) {
  1039. int w, h;
  1040. SDL_GL_GetDrawableSize(renderer->window, &w, &h);
  1041. if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
  1042. data->drawstate.viewport_dirty = SDL_TRUE; // if the window dimensions changed, invalidate the current viewport, etc.
  1043. data->drawstate.cliprect_dirty = SDL_TRUE;
  1044. data->drawstate.drawablew = w;
  1045. data->drawstate.drawableh = h;
  1046. }
  1047. }
  1048. #ifdef __MACOSX__
  1049. // On macOS on older systems, the OpenGL view change and resize events aren't
  1050. // necessarily synchronized, so just always reset it.
  1051. // Workaround for: https://discourse.libsdl.org/t/sdl-2-0-22-prerelease/35306/6
  1052. data->drawstate.viewport_dirty = SDL_TRUE;
  1053. #endif
  1054. while (cmd) {
  1055. switch (cmd->command) {
  1056. case SDL_RENDERCMD_SETDRAWCOLOR:
  1057. {
  1058. const Uint8 r = cmd->data.color.r;
  1059. const Uint8 g = cmd->data.color.g;
  1060. const Uint8 b = cmd->data.color.b;
  1061. const Uint8 a = cmd->data.color.a;
  1062. const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
  1063. if (color != data->drawstate.color) {
  1064. data->glColor4ub((GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a);
  1065. data->drawstate.color = color;
  1066. }
  1067. break;
  1068. }
  1069. case SDL_RENDERCMD_SETVIEWPORT:
  1070. {
  1071. SDL_Rect *viewport = &data->drawstate.viewport;
  1072. if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
  1073. SDL_copyp(viewport, &cmd->data.viewport.rect);
  1074. data->drawstate.viewport_dirty = SDL_TRUE;
  1075. data->drawstate.cliprect_dirty = SDL_TRUE;
  1076. }
  1077. break;
  1078. }
  1079. case SDL_RENDERCMD_SETCLIPRECT:
  1080. {
  1081. const SDL_Rect *rect = &cmd->data.cliprect.rect;
  1082. if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
  1083. data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
  1084. data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
  1085. }
  1086. if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
  1087. SDL_copyp(&data->drawstate.cliprect, rect);
  1088. data->drawstate.cliprect_dirty = SDL_TRUE;
  1089. }
  1090. break;
  1091. }
  1092. case SDL_RENDERCMD_CLEAR:
  1093. {
  1094. const Uint8 r = cmd->data.color.r;
  1095. const Uint8 g = cmd->data.color.g;
  1096. const Uint8 b = cmd->data.color.b;
  1097. const Uint8 a = cmd->data.color.a;
  1098. const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
  1099. if (color != data->drawstate.clear_color) {
  1100. const GLfloat fr = ((GLfloat)r) * inv255f;
  1101. const GLfloat fg = ((GLfloat)g) * inv255f;
  1102. const GLfloat fb = ((GLfloat)b) * inv255f;
  1103. const GLfloat fa = ((GLfloat)a) * inv255f;
  1104. data->glClearColor(fr, fg, fb, fa);
  1105. data->drawstate.clear_color = color;
  1106. }
  1107. if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
  1108. data->glDisable(GL_SCISSOR_TEST);
  1109. data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
  1110. }
  1111. data->glClear(GL_COLOR_BUFFER_BIT);
  1112. break;
  1113. }
  1114. case SDL_RENDERCMD_FILL_RECTS: /* unused */
  1115. break;
  1116. case SDL_RENDERCMD_COPY: /* unused */
  1117. break;
  1118. case SDL_RENDERCMD_COPY_EX: /* unused */
  1119. break;
  1120. case SDL_RENDERCMD_DRAW_LINES:
  1121. {
  1122. if (SetDrawState(data, cmd, SHADER_SOLID) == 0) {
  1123. size_t count = cmd->data.draw.count;
  1124. const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
  1125. /* SetDrawState handles glEnableClientState. */
  1126. data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts);
  1127. if (count > 2) {
  1128. /* joined lines cannot be grouped */
  1129. data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count);
  1130. } else {
  1131. /* let's group non joined lines */
  1132. SDL_RenderCommand *finalcmd = cmd;
  1133. SDL_RenderCommand *nextcmd = cmd->next;
  1134. SDL_BlendMode thisblend = cmd->data.draw.blend;
  1135. while (nextcmd) {
  1136. const SDL_RenderCommandType nextcmdtype = nextcmd->command;
  1137. if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
  1138. break; /* can't go any further on this draw call, different render command up next. */
  1139. } else if (nextcmd->data.draw.count != 2) {
  1140. break; /* can't go any further on this draw call, those are joined lines */
  1141. } else if (nextcmd->data.draw.blend != thisblend) {
  1142. break; /* can't go any further on this draw call, different blendmode copy up next. */
  1143. } else {
  1144. finalcmd = nextcmd; /* we can combine copy operations here. Mark this one as the furthest okay command. */
  1145. count += nextcmd->data.draw.count;
  1146. }
  1147. nextcmd = nextcmd->next;
  1148. }
  1149. data->glDrawArrays(GL_LINES, 0, (GLsizei)count);
  1150. cmd = finalcmd; /* skip any copy commands we just combined in here. */
  1151. }
  1152. }
  1153. break;
  1154. }
  1155. case SDL_RENDERCMD_DRAW_POINTS:
  1156. case SDL_RENDERCMD_GEOMETRY:
  1157. {
  1158. /* as long as we have the same copy command in a row, with the
  1159. same texture, we can combine them all into a single draw call. */
  1160. SDL_Texture *thistexture = cmd->data.draw.texture;
  1161. SDL_BlendMode thisblend = cmd->data.draw.blend;
  1162. const SDL_RenderCommandType thiscmdtype = cmd->command;
  1163. SDL_RenderCommand *finalcmd = cmd;
  1164. SDL_RenderCommand *nextcmd = cmd->next;
  1165. size_t count = cmd->data.draw.count;
  1166. int ret;
  1167. while (nextcmd) {
  1168. const SDL_RenderCommandType nextcmdtype = nextcmd->command;
  1169. if (nextcmdtype != thiscmdtype) {
  1170. break; /* can't go any further on this draw call, different render command up next. */
  1171. } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
  1172. break; /* can't go any further on this draw call, different texture/blendmode copy up next. */
  1173. } else {
  1174. finalcmd = nextcmd; /* we can combine copy operations here. Mark this one as the furthest okay command. */
  1175. count += nextcmd->data.draw.count;
  1176. }
  1177. nextcmd = nextcmd->next;
  1178. }
  1179. if (thistexture) {
  1180. ret = SetCopyState(data, cmd);
  1181. } else {
  1182. ret = SetDrawState(data, cmd, SHADER_SOLID);
  1183. }
  1184. if (ret == 0) {
  1185. const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
  1186. int op = GL_TRIANGLES; /* SDL_RENDERCMD_GEOMETRY */
  1187. if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
  1188. op = GL_POINTS;
  1189. }
  1190. if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
  1191. /* SetDrawState handles glEnableClientState. */
  1192. data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts);
  1193. } else {
  1194. /* SetDrawState handles glEnableClientState. */
  1195. if (thistexture) {
  1196. data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 5, verts + 0);
  1197. data->glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(float) * 5, verts + 2);
  1198. data->glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 5, verts + 3);
  1199. } else {
  1200. data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 3, verts + 0);
  1201. data->glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(float) * 3, verts + 2);
  1202. }
  1203. }
  1204. data->glDrawArrays(op, 0, (GLsizei)count);
  1205. /* Restore previously set color when we're done. */
  1206. if (thiscmdtype != SDL_RENDERCMD_DRAW_POINTS) {
  1207. Uint32 color = data->drawstate.color;
  1208. GLubyte a = (GLubyte)((color >> 24) & 0xFF);
  1209. GLubyte r = (GLubyte)((color >> 16) & 0xFF);
  1210. GLubyte g = (GLubyte)((color >> 8) & 0xFF);
  1211. GLubyte b = (GLubyte)((color >> 0) & 0xFF);
  1212. data->glColor4ub(r, g, b, a);
  1213. }
  1214. }
  1215. cmd = finalcmd; /* skip any copy commands we just combined in here. */
  1216. break;
  1217. }
  1218. case SDL_RENDERCMD_NO_OP:
  1219. break;
  1220. }
  1221. cmd = cmd->next;
  1222. }
  1223. /* Turn off vertex array state when we're done, in case external code
  1224. relies on it being off. */
  1225. if (data->drawstate.vertex_array) {
  1226. data->glDisableClientState(GL_VERTEX_ARRAY);
  1227. data->drawstate.vertex_array = SDL_FALSE;
  1228. }
  1229. if (data->drawstate.color_array) {
  1230. data->glDisableClientState(GL_COLOR_ARRAY);
  1231. data->drawstate.color_array = SDL_FALSE;
  1232. }
  1233. if (data->drawstate.texture_array) {
  1234. data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  1235. data->drawstate.texture_array = SDL_FALSE;
  1236. }
  1237. return GL_CheckError("", renderer);
  1238. }
  1239. static int GL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
  1240. Uint32 pixel_format, void *pixels, int pitch)
  1241. {
  1242. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  1243. Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ARGB8888;
  1244. void *temp_pixels;
  1245. int temp_pitch;
  1246. GLint internalFormat;
  1247. GLenum format, type;
  1248. Uint8 *src, *dst, *tmp;
  1249. int w, h, length, rows;
  1250. int status;
  1251. GL_ActivateRenderer(renderer);
  1252. if (!convert_format(data, temp_format, &internalFormat, &format, &type)) {
  1253. return SDL_SetError("Texture format %s not supported by OpenGL",
  1254. SDL_GetPixelFormatName(temp_format));
  1255. }
  1256. if (rect->w == 0 || rect->h == 0) {
  1257. return 0; /* nothing to do. */
  1258. }
  1259. temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
  1260. temp_pixels = SDL_malloc((size_t)rect->h * temp_pitch);
  1261. if (!temp_pixels) {
  1262. return SDL_OutOfMemory();
  1263. }
  1264. SDL_GetRendererOutputSize(renderer, &w, &h);
  1265. data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
  1266. data->glPixelStorei(GL_PACK_ROW_LENGTH,
  1267. (temp_pitch / SDL_BYTESPERPIXEL(temp_format)));
  1268. data->glReadPixels(rect->x, renderer->target ? rect->y : (h - rect->y) - rect->h,
  1269. rect->w, rect->h, format, type, temp_pixels);
  1270. if (GL_CheckError("glReadPixels()", renderer) < 0) {
  1271. SDL_free(temp_pixels);
  1272. return -1;
  1273. }
  1274. /* Flip the rows to be top-down if necessary */
  1275. if (!renderer->target) {
  1276. SDL_bool isstack;
  1277. length = rect->w * SDL_BYTESPERPIXEL(temp_format);
  1278. src = (Uint8 *)temp_pixels + (rect->h - 1) * temp_pitch;
  1279. dst = (Uint8 *)temp_pixels;
  1280. tmp = SDL_small_alloc(Uint8, length, &isstack);
  1281. rows = rect->h / 2;
  1282. while (rows--) {
  1283. SDL_memcpy(tmp, dst, length);
  1284. SDL_memcpy(dst, src, length);
  1285. SDL_memcpy(src, tmp, length);
  1286. dst += temp_pitch;
  1287. src -= temp_pitch;
  1288. }
  1289. SDL_small_free(tmp, isstack);
  1290. }
  1291. status = SDL_ConvertPixels(rect->w, rect->h,
  1292. temp_format, temp_pixels, temp_pitch,
  1293. pixel_format, pixels, pitch);
  1294. SDL_free(temp_pixels);
  1295. return status;
  1296. }
  1297. static int GL_RenderPresent(SDL_Renderer *renderer)
  1298. {
  1299. GL_ActivateRenderer(renderer);
  1300. return SDL_GL_SwapWindowWithResult(renderer->window);
  1301. }
  1302. static void GL_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
  1303. {
  1304. GL_RenderData *renderdata = (GL_RenderData *)renderer->driverdata;
  1305. GL_TextureData *data = (GL_TextureData *)texture->driverdata;
  1306. GL_ActivateRenderer(renderer);
  1307. if (renderdata->drawstate.texture == texture) {
  1308. renderdata->drawstate.texture = NULL;
  1309. }
  1310. if (renderdata->drawstate.target == texture) {
  1311. renderdata->drawstate.target = NULL;
  1312. }
  1313. if (!data) {
  1314. return;
  1315. }
  1316. if (data->texture) {
  1317. renderdata->glDeleteTextures(1, &data->texture);
  1318. }
  1319. #if SDL_HAVE_YUV
  1320. if (data->yuv) {
  1321. renderdata->glDeleteTextures(1, &data->utexture);
  1322. renderdata->glDeleteTextures(1, &data->vtexture);
  1323. }
  1324. #endif
  1325. SDL_free(data->pixels);
  1326. SDL_free(data);
  1327. texture->driverdata = NULL;
  1328. }
  1329. static void GL_DestroyRenderer(SDL_Renderer *renderer)
  1330. {
  1331. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  1332. if (data) {
  1333. if (data->context) {
  1334. /* make sure we delete the right resources! */
  1335. GL_ActivateRenderer(renderer);
  1336. }
  1337. GL_ClearErrors(renderer);
  1338. if (data->GL_ARB_debug_output_supported) {
  1339. PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB");
  1340. /* Uh oh, we don't have a safe way of removing ourselves from the callback chain, if it changed after we set our callback. */
  1341. /* For now, just always replace the callback with the original one */
  1342. glDebugMessageCallbackARBFunc(data->next_error_callback, data->next_error_userparam);
  1343. }
  1344. if (data->shaders) {
  1345. GL_DestroyShaderContext(data->shaders);
  1346. }
  1347. if (data->context) {
  1348. while (data->framebuffers) {
  1349. GL_FBOList *nextnode = data->framebuffers->next;
  1350. /* delete the framebuffer object */
  1351. data->glDeleteFramebuffersEXT(1, &data->framebuffers->FBO);
  1352. GL_CheckError("", renderer);
  1353. SDL_free(data->framebuffers);
  1354. data->framebuffers = nextnode;
  1355. }
  1356. SDL_GL_DeleteContext(data->context);
  1357. }
  1358. SDL_free(data);
  1359. }
  1360. SDL_free(renderer);
  1361. }
  1362. static int GL_BindTexture(SDL_Renderer *renderer, SDL_Texture *texture, float *texw, float *texh)
  1363. {
  1364. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  1365. GL_TextureData *texturedata = (GL_TextureData *)texture->driverdata;
  1366. const GLenum textype = data->textype;
  1367. GL_ActivateRenderer(renderer);
  1368. data->glEnable(textype);
  1369. #if SDL_HAVE_YUV
  1370. if (texturedata->yuv) {
  1371. if (data->GL_ARB_multitexture_supported) {
  1372. data->glActiveTextureARB(GL_TEXTURE2_ARB);
  1373. }
  1374. data->glBindTexture(textype, texturedata->vtexture);
  1375. if (data->GL_ARB_multitexture_supported) {
  1376. data->glActiveTextureARB(GL_TEXTURE1_ARB);
  1377. }
  1378. data->glBindTexture(textype, texturedata->utexture);
  1379. if (data->GL_ARB_multitexture_supported) {
  1380. data->glActiveTextureARB(GL_TEXTURE0_ARB);
  1381. }
  1382. }
  1383. if (texturedata->nv12) {
  1384. if (data->GL_ARB_multitexture_supported) {
  1385. data->glActiveTextureARB(GL_TEXTURE1_ARB);
  1386. }
  1387. data->glBindTexture(textype, texturedata->utexture);
  1388. if (data->GL_ARB_multitexture_supported) {
  1389. data->glActiveTextureARB(GL_TEXTURE0_ARB);
  1390. }
  1391. }
  1392. #endif
  1393. data->glBindTexture(textype, texturedata->texture);
  1394. data->drawstate.texturing = SDL_TRUE;
  1395. data->drawstate.texture = texture;
  1396. if (texw) {
  1397. *texw = (float)texturedata->texw;
  1398. }
  1399. if (texh) {
  1400. *texh = (float)texturedata->texh;
  1401. }
  1402. return 0;
  1403. }
  1404. static int GL_UnbindTexture(SDL_Renderer *renderer, SDL_Texture *texture)
  1405. {
  1406. GL_RenderData *data = (GL_RenderData *)renderer->driverdata;
  1407. GL_TextureData *texturedata = (GL_TextureData *)texture->driverdata;
  1408. const GLenum textype = data->textype;
  1409. GL_ActivateRenderer(renderer);
  1410. #if SDL_HAVE_YUV
  1411. if (texturedata->yuv) {
  1412. if (data->GL_ARB_multitexture_supported) {
  1413. data->glActiveTextureARB(GL_TEXTURE2_ARB);
  1414. }
  1415. data->glBindTexture(textype, 0);
  1416. data->glDisable(textype);
  1417. if (data->GL_ARB_multitexture_supported) {
  1418. data->glActiveTextureARB(GL_TEXTURE1_ARB);
  1419. }
  1420. data->glBindTexture(textype, 0);
  1421. data->glDisable(textype);
  1422. if (data->GL_ARB_multitexture_supported) {
  1423. data->glActiveTextureARB(GL_TEXTURE0_ARB);
  1424. }
  1425. }
  1426. if (texturedata->nv12) {
  1427. if (data->GL_ARB_multitexture_supported) {
  1428. data->glActiveTextureARB(GL_TEXTURE1_ARB);
  1429. }
  1430. data->glBindTexture(textype, 0);
  1431. data->glDisable(textype);
  1432. if (data->GL_ARB_multitexture_supported) {
  1433. data->glActiveTextureARB(GL_TEXTURE0_ARB);
  1434. }
  1435. }
  1436. #endif
  1437. data->glBindTexture(textype, 0);
  1438. data->glDisable(textype);
  1439. data->drawstate.texturing = SDL_FALSE;
  1440. data->drawstate.texture = NULL;
  1441. return 0;
  1442. }
  1443. static int GL_SetVSync(SDL_Renderer *renderer, const int vsync)
  1444. {
  1445. int retval;
  1446. if (vsync) {
  1447. retval = SDL_GL_SetSwapInterval(1);
  1448. } else {
  1449. retval = SDL_GL_SetSwapInterval(0);
  1450. }
  1451. if (retval != 0) {
  1452. return retval;
  1453. }
  1454. if (SDL_GL_GetSwapInterval() != 0) {
  1455. renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
  1456. } else {
  1457. renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
  1458. }
  1459. return retval;
  1460. }
  1461. static SDL_bool GL_IsProbablyAccelerated(const GL_RenderData *data)
  1462. {
  1463. /*const char *vendor = (const char *) data->glGetString(GL_VENDOR);*/
  1464. const char *renderer = (const char *)data->glGetString(GL_RENDERER);
  1465. #if defined(__WINDOWS__) || defined(__WINGDK__)
  1466. if (SDL_strcmp(renderer, "GDI Generic") == 0) {
  1467. return SDL_FALSE; /* Microsoft's fallback software renderer. Fix your system! */
  1468. }
  1469. #endif
  1470. #ifdef __APPLE__
  1471. if (SDL_strcmp(renderer, "Apple Software Renderer") == 0) {
  1472. return SDL_FALSE; /* (a probably very old) Apple software-based OpenGL. */
  1473. }
  1474. #endif
  1475. if (SDL_strcmp(renderer, "Software Rasterizer") == 0) {
  1476. return SDL_FALSE; /* (a probably very old) Software Mesa, or some other generic thing. */
  1477. }
  1478. /* !!! FIXME: swrast? llvmpipe? softpipe? */
  1479. return SDL_TRUE;
  1480. }
  1481. static SDL_Renderer *GL_CreateRenderer(SDL_Window *window, Uint32 flags)
  1482. {
  1483. SDL_Renderer *renderer;
  1484. GL_RenderData *data;
  1485. GLint value;
  1486. Uint32 window_flags;
  1487. int profile_mask = 0, major = 0, minor = 0;
  1488. SDL_bool changed_window = SDL_FALSE;
  1489. const char *hint;
  1490. SDL_bool non_power_of_two_supported = SDL_FALSE;
  1491. SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
  1492. SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
  1493. SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
  1494. #ifndef SDL_VIDEO_VITA_PVR_OGL
  1495. window_flags = SDL_GetWindowFlags(window);
  1496. if (!(window_flags & SDL_WINDOW_OPENGL) ||
  1497. profile_mask == SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
  1498. changed_window = SDL_TRUE;
  1499. SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0);
  1500. SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
  1501. SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
  1502. if (SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL) < 0) {
  1503. goto error;
  1504. }
  1505. }
  1506. #endif
  1507. renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(*renderer));
  1508. if (!renderer) {
  1509. SDL_OutOfMemory();
  1510. goto error;
  1511. }
  1512. data = (GL_RenderData *)SDL_calloc(1, sizeof(*data));
  1513. if (!data) {
  1514. SDL_free(renderer);
  1515. SDL_OutOfMemory();
  1516. goto error;
  1517. }
  1518. renderer->WindowEvent = GL_WindowEvent;
  1519. renderer->GetOutputSize = GL_GetOutputSize;
  1520. renderer->SupportsBlendMode = GL_SupportsBlendMode;
  1521. renderer->CreateTexture = GL_CreateTexture;
  1522. renderer->UpdateTexture = GL_UpdateTexture;
  1523. #if SDL_HAVE_YUV
  1524. renderer->UpdateTextureYUV = GL_UpdateTextureYUV;
  1525. renderer->UpdateTextureNV = GL_UpdateTextureNV;
  1526. #endif
  1527. renderer->LockTexture = GL_LockTexture;
  1528. renderer->UnlockTexture = GL_UnlockTexture;
  1529. renderer->SetTextureScaleMode = GL_SetTextureScaleMode;
  1530. renderer->SetRenderTarget = GL_SetRenderTarget;
  1531. renderer->QueueSetViewport = GL_QueueSetViewport;
  1532. renderer->QueueSetDrawColor = GL_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
  1533. renderer->QueueDrawPoints = GL_QueueDrawPoints;
  1534. renderer->QueueDrawLines = GL_QueueDrawLines;
  1535. renderer->QueueGeometry = GL_QueueGeometry;
  1536. renderer->RunCommandQueue = GL_RunCommandQueue;
  1537. renderer->RenderReadPixels = GL_RenderReadPixels;
  1538. renderer->RenderPresent = GL_RenderPresent;
  1539. renderer->DestroyTexture = GL_DestroyTexture;
  1540. renderer->DestroyRenderer = GL_DestroyRenderer;
  1541. renderer->SetVSync = GL_SetVSync;
  1542. renderer->GL_BindTexture = GL_BindTexture;
  1543. renderer->GL_UnbindTexture = GL_UnbindTexture;
  1544. renderer->info = GL_RenderDriver.info;
  1545. renderer->info.flags = 0; /* will set some flags below. */
  1546. renderer->driverdata = data;
  1547. renderer->window = window;
  1548. data->context = SDL_GL_CreateContext(window);
  1549. if (!data->context) {
  1550. SDL_free(renderer);
  1551. SDL_free(data);
  1552. goto error;
  1553. }
  1554. if (SDL_GL_MakeCurrent(window, data->context) < 0) {
  1555. SDL_GL_DeleteContext(data->context);
  1556. SDL_free(renderer);
  1557. SDL_free(data);
  1558. goto error;
  1559. }
  1560. if (GL_LoadFunctions(data) < 0) {
  1561. SDL_GL_DeleteContext(data->context);
  1562. SDL_free(renderer);
  1563. SDL_free(data);
  1564. goto error;
  1565. }
  1566. if (GL_IsProbablyAccelerated(data)) {
  1567. renderer->info.flags |= SDL_RENDERER_ACCELERATED;
  1568. }
  1569. #ifdef __MACOSX__
  1570. /* Enable multi-threaded rendering */
  1571. /* Disabled until Ryan finishes his VBO/PBO code...
  1572. CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
  1573. */
  1574. #endif
  1575. if (flags & SDL_RENDERER_PRESENTVSYNC) {
  1576. SDL_GL_SetSwapInterval(1);
  1577. } else {
  1578. SDL_GL_SetSwapInterval(0);
  1579. }
  1580. if (SDL_GL_GetSwapInterval() != 0) {
  1581. renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
  1582. }
  1583. /* Check for debug output support */
  1584. if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) == 0 &&
  1585. (value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
  1586. data->debug_enabled = SDL_TRUE;
  1587. }
  1588. if (data->debug_enabled && SDL_GL_ExtensionSupported("GL_ARB_debug_output")) {
  1589. PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB");
  1590. data->GL_ARB_debug_output_supported = SDL_TRUE;
  1591. data->glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION_ARB, (GLvoid **)(char *)&data->next_error_callback);
  1592. data->glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM_ARB, &data->next_error_userparam);
  1593. glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer);
  1594. /* Make sure our callback is called when errors actually happen */
  1595. data->glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
  1596. }
  1597. hint = SDL_getenv("GL_ARB_texture_non_power_of_two");
  1598. if (!hint || *hint != '0') {
  1599. SDL_bool isGL2 = SDL_FALSE;
  1600. const char *verstr = (const char *)data->glGetString(GL_VERSION);
  1601. if (verstr) {
  1602. char verbuf[16];
  1603. char *ptr;
  1604. SDL_strlcpy(verbuf, verstr, sizeof(verbuf));
  1605. ptr = SDL_strchr(verbuf, '.');
  1606. if (ptr) {
  1607. *ptr = '\0';
  1608. if (SDL_atoi(verbuf) >= 2) {
  1609. isGL2 = SDL_TRUE;
  1610. }
  1611. }
  1612. }
  1613. if (isGL2 || SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
  1614. non_power_of_two_supported = SDL_TRUE;
  1615. }
  1616. }
  1617. data->textype = GL_TEXTURE_2D;
  1618. if (non_power_of_two_supported) {
  1619. data->GL_ARB_texture_non_power_of_two_supported = SDL_TRUE;
  1620. data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
  1621. renderer->info.max_texture_width = value;
  1622. renderer->info.max_texture_height = value;
  1623. } else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
  1624. SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
  1625. data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
  1626. data->textype = GL_TEXTURE_RECTANGLE_ARB;
  1627. data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);
  1628. renderer->info.max_texture_width = value;
  1629. renderer->info.max_texture_height = value;
  1630. } else {
  1631. data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
  1632. renderer->info.max_texture_width = value;
  1633. renderer->info.max_texture_height = value;
  1634. }
  1635. /* Check for multitexture support */
  1636. if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
  1637. data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)SDL_GL_GetProcAddress("glActiveTextureARB");
  1638. if (data->glActiveTextureARB) {
  1639. data->GL_ARB_multitexture_supported = SDL_TRUE;
  1640. data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
  1641. }
  1642. }
  1643. /* Check for shader support */
  1644. if (SDL_GetHintBoolean(SDL_HINT_RENDER_OPENGL_SHADERS, SDL_TRUE)) {
  1645. data->shaders = GL_CreateShaderContext();
  1646. }
  1647. SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
  1648. data->shaders ? "ENABLED" : "DISABLED");
  1649. #if SDL_HAVE_YUV
  1650. /* We support YV12 textures using 3 textures and a shader */
  1651. if (data->shaders && data->num_texture_units >= 3) {
  1652. renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
  1653. renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
  1654. }
  1655. /* We support NV12 textures using 2 textures and a shader */
  1656. if (data->shaders && data->num_texture_units >= 2) {
  1657. renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV12;
  1658. renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV21;
  1659. }
  1660. #endif
  1661. #ifdef __MACOSX__
  1662. renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_UYVY;
  1663. #endif
  1664. renderer->rect_index_order[0] = 0;
  1665. renderer->rect_index_order[1] = 1;
  1666. renderer->rect_index_order[2] = 3;
  1667. renderer->rect_index_order[3] = 1;
  1668. renderer->rect_index_order[4] = 3;
  1669. renderer->rect_index_order[5] = 2;
  1670. if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
  1671. data->GL_EXT_framebuffer_object_supported = SDL_TRUE;
  1672. data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)
  1673. SDL_GL_GetProcAddress("glGenFramebuffersEXT");
  1674. data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
  1675. SDL_GL_GetProcAddress("glDeleteFramebuffersEXT");
  1676. data->glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
  1677. SDL_GL_GetProcAddress("glFramebufferTexture2DEXT");
  1678. data->glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)
  1679. SDL_GL_GetProcAddress("glBindFramebufferEXT");
  1680. data->glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
  1681. SDL_GL_GetProcAddress("glCheckFramebufferStatusEXT");
  1682. renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
  1683. }
  1684. data->framebuffers = NULL;
  1685. /* Set up parameters for rendering */
  1686. data->glMatrixMode(GL_MODELVIEW);
  1687. data->glLoadIdentity();
  1688. data->glDisable(GL_DEPTH_TEST);
  1689. data->glDisable(GL_CULL_FACE);
  1690. data->glDisable(GL_SCISSOR_TEST);
  1691. data->glDisable(data->textype);
  1692. data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  1693. data->glColor4ub(255, 255, 255, 255);
  1694. /* This ended up causing video discrepancies between OpenGL and Direct3D */
  1695. /* data->glEnable(GL_LINE_SMOOTH); */
  1696. data->drawstate.blend = SDL_BLENDMODE_INVALID;
  1697. data->drawstate.shader = SHADER_INVALID;
  1698. data->drawstate.color = 0xFFFFFFFF;
  1699. data->drawstate.clear_color = 0xFFFFFFFF;
  1700. return renderer;
  1701. error:
  1702. if (changed_window) {
  1703. /* Uh oh, better try to put it back... */
  1704. SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
  1705. SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
  1706. SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
  1707. SDL_RecreateWindow(window, window_flags);
  1708. }
  1709. return NULL;
  1710. }
  1711. SDL_RenderDriver GL_RenderDriver = {
  1712. GL_CreateRenderer,
  1713. { "opengl",
  1714. (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
  1715. 4,
  1716. { SDL_PIXELFORMAT_ARGB8888,
  1717. SDL_PIXELFORMAT_ABGR8888,
  1718. SDL_PIXELFORMAT_RGB888,
  1719. SDL_PIXELFORMAT_BGR888 },
  1720. 0,
  1721. 0 }
  1722. };
  1723. #endif /* SDL_VIDEO_RENDER_OGL */
  1724. /* vi: set ts=4 sw=4 expandtab: */