diff --git a/meson.build b/meson.build index 558c2da3..e8cfda83 100644 --- a/meson.build +++ b/meson.build @@ -117,6 +117,7 @@ if is_libretro '-DMPG123_NO_LARGENAME', '-DPGL_PREFIX_TYPES', '-DPGL_PREFIX_GLSL', + '-DGL_GLES_PROTOTYPES=0', ] if host_endian == 'big' @@ -635,6 +636,8 @@ if is_libretro 'src/display/gl/gl-fun.cpp', 'src/display/gl/gl-meta.cpp', 'src/display/gl/glstate.cpp', + 'src/display/gl/pgl-enum.cpp', + 'src/display/gl/pgl-fun.cpp', 'src/display/gl/scene.cpp', 'src/display/gl/shader.cpp', 'src/display/gl/texpool.cpp', diff --git a/src/display/gl/pgl-enum.cpp b/src/display/gl/pgl-enum.cpp new file mode 100644 index 00000000..24bba7d0 --- /dev/null +++ b/src/display/gl/pgl-enum.cpp @@ -0,0 +1,843 @@ +/* + ** pgl-enum.cpp + ** + ** This file is part of mkxp. + ** + ** Copyright (C) 2014 - 2021 Amaryllis Kulla + ** + ** mkxp is free software: you can redistribute it and/or modify + ** it under the terms of the GNU General Public License as published by + ** the Free Software Foundation, either version 2 of the License, or + ** (at your option) any later version. + ** + ** mkxp is distributed in the hope that it will be useful, + ** but WITHOUT ANY WARRANTY; without even the implied warranty of + ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + ** GNU General Public License for more details. + ** + ** You should have received a copy of the GNU General Public License + ** along with mkxp. If not, see . + */ + +#include +#define MKXPZ_NO_GL_TYPES +#include +#include + +std::unordered_map mkxp_pgl_enum_map = { +{GL_NO_ERROR, +#undef GL_NO_ERROR +GL_NO_ERROR}, + +{GL_INVALID_ENUM, +#undef GL_INVALID_ENUM +GL_INVALID_ENUM}, + +{GL_INVALID_VALUE, +#undef GL_INVALID_VALUE +GL_INVALID_VALUE}, + +{GL_INVALID_OPERATION, +#undef GL_INVALID_OPERATION +GL_INVALID_OPERATION}, + +{GL_INVALID_FRAMEBUFFER_OPERATION, +#undef GL_INVALID_FRAMEBUFFER_OPERATION +GL_INVALID_FRAMEBUFFER_OPERATION}, + +{GL_OUT_OF_MEMORY, +#undef GL_OUT_OF_MEMORY +GL_OUT_OF_MEMORY}, + +{GL_ARRAY_BUFFER, +#undef GL_ARRAY_BUFFER +GL_ARRAY_BUFFER}, + +{GL_COPY_READ_BUFFER, +#undef GL_COPY_READ_BUFFER +GL_COPY_READ_BUFFER}, + +{GL_COPY_WRITE_BUFFER, +#undef GL_COPY_WRITE_BUFFER +GL_COPY_WRITE_BUFFER}, + +{GL_ELEMENT_ARRAY_BUFFER, +#undef GL_ELEMENT_ARRAY_BUFFER +GL_ELEMENT_ARRAY_BUFFER}, + +{GL_PIXEL_PACK_BUFFER, +#undef GL_PIXEL_PACK_BUFFER +GL_PIXEL_PACK_BUFFER}, + +{GL_PIXEL_UNPACK_BUFFER, +#undef GL_PIXEL_UNPACK_BUFFER +GL_PIXEL_UNPACK_BUFFER}, + +{GL_TRANSFORM_FEEDBACK_BUFFER, +#undef GL_TRANSFORM_FEEDBACK_BUFFER +GL_TRANSFORM_FEEDBACK_BUFFER}, + +{GL_UNIFORM_BUFFER, +#undef GL_UNIFORM_BUFFER +GL_UNIFORM_BUFFER}, + +{GL_FRAMEBUFFER, +#undef GL_FRAMEBUFFER +GL_FRAMEBUFFER}, + +{GL_DRAW_FRAMEBUFFER, +#undef GL_DRAW_FRAMEBUFFER +GL_DRAW_FRAMEBUFFER}, + +{GL_READ_FRAMEBUFFER, +#undef GL_READ_FRAMEBUFFER +GL_READ_FRAMEBUFFER}, + +{GL_COLOR_ATTACHMENT0, +#undef GL_COLOR_ATTACHMENT0 +GL_COLOR_ATTACHMENT0}, + +{GL_COLOR_ATTACHMENT1, +#undef GL_COLOR_ATTACHMENT1 +GL_COLOR_ATTACHMENT1}, + +{GL_COLOR_ATTACHMENT2, +#undef GL_COLOR_ATTACHMENT2 +GL_COLOR_ATTACHMENT2}, + +{GL_COLOR_ATTACHMENT3, +#undef GL_COLOR_ATTACHMENT3 +GL_COLOR_ATTACHMENT3}, + +{GL_COLOR_ATTACHMENT4, +#undef GL_COLOR_ATTACHMENT4 +GL_COLOR_ATTACHMENT4}, + +{GL_COLOR_ATTACHMENT5, +#undef GL_COLOR_ATTACHMENT5 +GL_COLOR_ATTACHMENT5}, + +{GL_COLOR_ATTACHMENT6, +#undef GL_COLOR_ATTACHMENT6 +GL_COLOR_ATTACHMENT6}, + +{GL_COLOR_ATTACHMENT7, +#undef GL_COLOR_ATTACHMENT7 +GL_COLOR_ATTACHMENT7}, + +{GL_DEPTH_ATTACHMENT, +#undef GL_DEPTH_ATTACHMENT +GL_DEPTH_ATTACHMENT}, + +{GL_STENCIL_ATTACHMENT, +#undef GL_STENCIL_ATTACHMENT +GL_STENCIL_ATTACHMENT}, + +{GL_DEPTH_STENCIL_ATTACHMENT, +#undef GL_DEPTH_STENCIL_ATTACHMENT +GL_DEPTH_STENCIL_ATTACHMENT}, + +{GL_RENDERBUFFER, +#undef GL_RENDERBUFFER +GL_RENDERBUFFER}, + +{GL_STREAM_DRAW, +#undef GL_STREAM_DRAW +GL_STREAM_DRAW}, + +{GL_STREAM_READ, +#undef GL_STREAM_READ +GL_STREAM_READ}, + +{GL_STREAM_COPY, +#undef GL_STREAM_COPY +GL_STREAM_COPY}, + +{GL_STATIC_DRAW, +#undef GL_STATIC_DRAW +GL_STATIC_DRAW}, + +{GL_STATIC_READ, +#undef GL_STATIC_READ +GL_STATIC_READ}, + +{GL_STATIC_COPY, +#undef GL_STATIC_COPY +GL_STATIC_COPY}, + +{GL_DYNAMIC_DRAW, +#undef GL_DYNAMIC_DRAW +GL_DYNAMIC_DRAW}, + +{GL_DYNAMIC_READ, +#undef GL_DYNAMIC_READ +GL_DYNAMIC_READ}, + +{GL_DYNAMIC_COPY, +#undef GL_DYNAMIC_COPY +GL_DYNAMIC_COPY}, + +{GL_POINTS, +#undef GL_POINTS +GL_POINTS}, + +{GL_LINES, +#undef GL_LINES +GL_LINES}, + +{GL_LINE_STRIP, +#undef GL_LINE_STRIP +GL_LINE_STRIP}, + +{GL_LINE_LOOP, +#undef GL_LINE_LOOP +GL_LINE_LOOP}, + +{GL_TRIANGLES, +#undef GL_TRIANGLES +GL_TRIANGLES}, + +{GL_TRIANGLE_STRIP, +#undef GL_TRIANGLE_STRIP +GL_TRIANGLE_STRIP}, + +{GL_TRIANGLE_FAN, +#undef GL_TRIANGLE_FAN +GL_TRIANGLE_FAN}, + +{GL_LESS, +#undef GL_LESS +GL_LESS}, + +{GL_LEQUAL, +#undef GL_LEQUAL +GL_LEQUAL}, + +{GL_GREATER, +#undef GL_GREATER +GL_GREATER}, + +{GL_GEQUAL, +#undef GL_GEQUAL +GL_GEQUAL}, + +{GL_EQUAL, +#undef GL_EQUAL +GL_EQUAL}, + +{GL_NOTEQUAL, +#undef GL_NOTEQUAL +GL_NOTEQUAL}, + +{GL_ALWAYS, +#undef GL_ALWAYS +GL_ALWAYS}, + +{GL_NEVER, +#undef GL_NEVER +GL_NEVER}, + +{GL_ZERO, +#undef GL_ZERO +GL_ZERO}, + +{GL_ONE, +#undef GL_ONE +GL_ONE}, + +{GL_SRC_COLOR, +#undef GL_SRC_COLOR +GL_SRC_COLOR}, + +{GL_ONE_MINUS_SRC_COLOR, +#undef GL_ONE_MINUS_SRC_COLOR +GL_ONE_MINUS_SRC_COLOR}, + +{GL_DST_COLOR, +#undef GL_DST_COLOR +GL_DST_COLOR}, + +{GL_ONE_MINUS_DST_COLOR, +#undef GL_ONE_MINUS_DST_COLOR +GL_ONE_MINUS_DST_COLOR}, + +{GL_SRC_ALPHA, +#undef GL_SRC_ALPHA +GL_SRC_ALPHA}, + +{GL_ONE_MINUS_SRC_ALPHA, +#undef GL_ONE_MINUS_SRC_ALPHA +GL_ONE_MINUS_SRC_ALPHA}, + +{GL_DST_ALPHA, +#undef GL_DST_ALPHA +GL_DST_ALPHA}, + +{GL_ONE_MINUS_DST_ALPHA, +#undef GL_ONE_MINUS_DST_ALPHA +GL_ONE_MINUS_DST_ALPHA}, + +{GL_CONSTANT_COLOR, +#undef GL_CONSTANT_COLOR +GL_CONSTANT_COLOR}, + +{GL_ONE_MINUS_CONSTANT_COLOR, +#undef GL_ONE_MINUS_CONSTANT_COLOR +GL_ONE_MINUS_CONSTANT_COLOR}, + +{GL_CONSTANT_ALPHA, +#undef GL_CONSTANT_ALPHA +GL_CONSTANT_ALPHA}, + +{GL_ONE_MINUS_CONSTANT_ALPHA, +#undef GL_ONE_MINUS_CONSTANT_ALPHA +GL_ONE_MINUS_CONSTANT_ALPHA}, + +{GL_SRC_ALPHA_SATURATE, +#undef GL_SRC_ALPHA_SATURATE +GL_SRC_ALPHA_SATURATE}, + +{GL_FUNC_ADD, +#undef GL_FUNC_ADD +GL_FUNC_ADD}, + +{GL_FUNC_SUBTRACT, +#undef GL_FUNC_SUBTRACT +GL_FUNC_SUBTRACT}, + +{GL_FUNC_REVERSE_SUBTRACT, +#undef GL_FUNC_REVERSE_SUBTRACT +GL_FUNC_REVERSE_SUBTRACT}, + +{GL_MIN, +#undef GL_MIN +GL_MIN}, + +{GL_MAX, +#undef GL_MAX +GL_MAX}, + +{GL_TEXTURE_2D, +#undef GL_TEXTURE_2D +GL_TEXTURE_2D}, + +{GL_TEXTURE_3D, +#undef GL_TEXTURE_3D +GL_TEXTURE_3D}, + +{GL_TEXTURE_2D_ARRAY, +#undef GL_TEXTURE_2D_ARRAY +GL_TEXTURE_2D_ARRAY}, + +{GL_TEXTURE_CUBE_MAP, +#undef GL_TEXTURE_CUBE_MAP +GL_TEXTURE_CUBE_MAP}, + +{GL_TEXTURE_CUBE_MAP_POSITIVE_X, +#undef GL_TEXTURE_CUBE_MAP_POSITIVE_X +GL_TEXTURE_CUBE_MAP_POSITIVE_X}, + +{GL_TEXTURE_CUBE_MAP_NEGATIVE_X, +#undef GL_TEXTURE_CUBE_MAP_NEGATIVE_X +GL_TEXTURE_CUBE_MAP_NEGATIVE_X}, + +{GL_TEXTURE_CUBE_MAP_POSITIVE_Y, +#undef GL_TEXTURE_CUBE_MAP_POSITIVE_Y +GL_TEXTURE_CUBE_MAP_POSITIVE_Y}, + +{GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, +#undef GL_TEXTURE_CUBE_MAP_NEGATIVE_Y +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y}, + +{GL_TEXTURE_CUBE_MAP_POSITIVE_Z, +#undef GL_TEXTURE_CUBE_MAP_POSITIVE_Z +GL_TEXTURE_CUBE_MAP_POSITIVE_Z}, + +{GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, +#undef GL_TEXTURE_CUBE_MAP_NEGATIVE_Z +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z}, + +{GL_TEXTURE_BASE_LEVEL, +#undef GL_TEXTURE_BASE_LEVEL +GL_TEXTURE_BASE_LEVEL}, + +{GL_TEXTURE_COMPARE_FUNC, +#undef GL_TEXTURE_COMPARE_FUNC +GL_TEXTURE_COMPARE_FUNC}, + +{GL_TEXTURE_COMPARE_MODE, +#undef GL_TEXTURE_COMPARE_MODE +GL_TEXTURE_COMPARE_MODE}, + +{GL_TEXTURE_MIN_FILTER, +#undef GL_TEXTURE_MIN_FILTER +GL_TEXTURE_MIN_FILTER}, + +{GL_TEXTURE_MAG_FILTER, +#undef GL_TEXTURE_MAG_FILTER +GL_TEXTURE_MAG_FILTER}, + +{GL_TEXTURE_MIN_LOD, +#undef GL_TEXTURE_MIN_LOD +GL_TEXTURE_MIN_LOD}, + +{GL_TEXTURE_MAX_LOD, +#undef GL_TEXTURE_MAX_LOD +GL_TEXTURE_MAX_LOD}, + +{GL_TEXTURE_MAX_LEVEL, +#undef GL_TEXTURE_MAX_LEVEL +GL_TEXTURE_MAX_LEVEL}, + +{GL_TEXTURE_SWIZZLE_R, +#undef GL_TEXTURE_SWIZZLE_R +GL_TEXTURE_SWIZZLE_R}, + +{GL_TEXTURE_SWIZZLE_G, +#undef GL_TEXTURE_SWIZZLE_G +GL_TEXTURE_SWIZZLE_G}, + +{GL_TEXTURE_SWIZZLE_B, +#undef GL_TEXTURE_SWIZZLE_B +GL_TEXTURE_SWIZZLE_B}, + +{GL_TEXTURE_SWIZZLE_A, +#undef GL_TEXTURE_SWIZZLE_A +GL_TEXTURE_SWIZZLE_A}, + +{GL_TEXTURE_WRAP_S, +#undef GL_TEXTURE_WRAP_S +GL_TEXTURE_WRAP_S}, + +{GL_TEXTURE_WRAP_T, +#undef GL_TEXTURE_WRAP_T +GL_TEXTURE_WRAP_T}, + +{GL_TEXTURE_WRAP_R, +#undef GL_TEXTURE_WRAP_R +GL_TEXTURE_WRAP_R}, + +{GL_REPEAT, +#undef GL_REPEAT +GL_REPEAT}, + +{GL_CLAMP_TO_EDGE, +#undef GL_CLAMP_TO_EDGE +GL_CLAMP_TO_EDGE}, + +{GL_MIRRORED_REPEAT, +#undef GL_MIRRORED_REPEAT +GL_MIRRORED_REPEAT}, + +{GL_NEAREST, +#undef GL_NEAREST +GL_NEAREST}, + +{GL_LINEAR, +#undef GL_LINEAR +GL_LINEAR}, + +{GL_NEAREST_MIPMAP_NEAREST, +#undef GL_NEAREST_MIPMAP_NEAREST +GL_NEAREST_MIPMAP_NEAREST}, + +{GL_NEAREST_MIPMAP_LINEAR, +#undef GL_NEAREST_MIPMAP_LINEAR +GL_NEAREST_MIPMAP_LINEAR}, + +{GL_LINEAR_MIPMAP_NEAREST, +#undef GL_LINEAR_MIPMAP_NEAREST +GL_LINEAR_MIPMAP_NEAREST}, + +{GL_LINEAR_MIPMAP_LINEAR, +#undef GL_LINEAR_MIPMAP_LINEAR +GL_LINEAR_MIPMAP_LINEAR}, + +{GL_ALPHA, +#undef GL_ALPHA +GL_ALPHA}, + +{GL_LUMINANCE, +#undef GL_LUMINANCE +GL_LUMINANCE}, + +{GL_LUMINANCE_ALPHA, +#undef GL_LUMINANCE_ALPHA +GL_LUMINANCE_ALPHA}, + +{GL_RED, +#undef GL_RED +GL_RED}, + +{GL_RG, +#undef GL_RG +GL_RG}, + +{GL_RGB, +#undef GL_RGB +GL_RGB}, + +{GL_RGBA, +#undef GL_RGBA +GL_RGBA}, + +{GL_DEPTH_COMPONENT16, +#undef GL_DEPTH_COMPONENT16 +GL_DEPTH_COMPONENT16}, + +{GL_DEPTH_COMPONENT24, +#undef GL_DEPTH_COMPONENT24 +GL_DEPTH_COMPONENT24}, + +{GL_DEPTH_COMPONENT32F, +#undef GL_DEPTH_COMPONENT32F +GL_DEPTH_COMPONENT32F}, + +{GL_DEPTH24_STENCIL8, +#undef GL_DEPTH24_STENCIL8 +GL_DEPTH24_STENCIL8}, + +{GL_DEPTH32F_STENCIL8, +#undef GL_DEPTH32F_STENCIL8 +GL_DEPTH32F_STENCIL8}, + +{GL_STENCIL_INDEX8, +#undef GL_STENCIL_INDEX8 +GL_STENCIL_INDEX8}, + +{GL_UNPACK_ALIGNMENT, +#undef GL_UNPACK_ALIGNMENT +GL_UNPACK_ALIGNMENT}, + +{GL_PACK_ALIGNMENT, +#undef GL_PACK_ALIGNMENT +GL_PACK_ALIGNMENT}, + +{GL_TEXTURE0, +#undef GL_TEXTURE0 +GL_TEXTURE0}, + +{GL_TEXTURE1, +#undef GL_TEXTURE1 +GL_TEXTURE1}, + +{GL_TEXTURE2, +#undef GL_TEXTURE2 +GL_TEXTURE2}, + +{GL_TEXTURE3, +#undef GL_TEXTURE3 +GL_TEXTURE3}, + +{GL_TEXTURE4, +#undef GL_TEXTURE4 +GL_TEXTURE4}, + +{GL_TEXTURE5, +#undef GL_TEXTURE5 +GL_TEXTURE5}, + +{GL_TEXTURE6, +#undef GL_TEXTURE6 +GL_TEXTURE6}, + +{GL_TEXTURE7, +#undef GL_TEXTURE7 +GL_TEXTURE7}, + +{GL_CULL_FACE, +#undef GL_CULL_FACE +GL_CULL_FACE}, + +{GL_DEPTH_TEST, +#undef GL_DEPTH_TEST +GL_DEPTH_TEST}, + +{GL_BLEND, +#undef GL_BLEND +GL_BLEND}, + +{GL_POLYGON_OFFSET_FILL, +#undef GL_POLYGON_OFFSET_FILL +GL_POLYGON_OFFSET_FILL}, + +{GL_SCISSOR_TEST, +#undef GL_SCISSOR_TEST +GL_SCISSOR_TEST}, + +{GL_STENCIL_TEST, +#undef GL_STENCIL_TEST +GL_STENCIL_TEST}, + +{GL_FRONT, +#undef GL_FRONT +GL_FRONT}, + +{GL_BACK, +#undef GL_BACK +GL_BACK}, + +{GL_FRONT_AND_BACK, +#undef GL_FRONT_AND_BACK +GL_FRONT_AND_BACK}, + +{GL_CCW, +#undef GL_CCW +GL_CCW}, + +{GL_CW, +#undef GL_CW +GL_CW}, + +{GL_INVERT, +#undef GL_INVERT +GL_INVERT}, + +{GL_KEEP, +#undef GL_KEEP +GL_KEEP}, + +{GL_REPLACE, +#undef GL_REPLACE +GL_REPLACE}, + +{GL_INCR, +#undef GL_INCR +GL_INCR}, + +{GL_INCR_WRAP, +#undef GL_INCR_WRAP +GL_INCR_WRAP}, + +{GL_DECR, +#undef GL_DECR +GL_DECR}, + +{GL_DECR_WRAP, +#undef GL_DECR_WRAP +GL_DECR_WRAP}, + +{GL_UNSIGNED_BYTE, +#undef GL_UNSIGNED_BYTE +GL_UNSIGNED_BYTE}, + +{GL_BYTE, +#undef GL_BYTE +GL_BYTE}, + +{GL_UNSIGNED_SHORT, +#undef GL_UNSIGNED_SHORT +GL_UNSIGNED_SHORT}, + +{GL_SHORT, +#undef GL_SHORT +GL_SHORT}, + +{GL_UNSIGNED_INT, +#undef GL_UNSIGNED_INT +GL_UNSIGNED_INT}, + +{GL_INT, +#undef GL_INT +GL_INT}, + +{GL_FLOAT, +#undef GL_FLOAT +GL_FLOAT}, + +{GL_VENDOR, +#undef GL_VENDOR +GL_VENDOR}, + +{GL_RENDERER, +#undef GL_RENDERER +GL_RENDERER}, + +{GL_VERSION, +#undef GL_VERSION +GL_VERSION}, + +{GL_SHADING_LANGUAGE_VERSION, +#undef GL_SHADING_LANGUAGE_VERSION +GL_SHADING_LANGUAGE_VERSION}, + +{GL_POLYGON_OFFSET_FACTOR, +#undef GL_POLYGON_OFFSET_FACTOR +GL_POLYGON_OFFSET_FACTOR}, + +{GL_POLYGON_OFFSET_UNITS, +#undef GL_POLYGON_OFFSET_UNITS +GL_POLYGON_OFFSET_UNITS}, + +{GL_DEPTH_CLEAR_VALUE, +#undef GL_DEPTH_CLEAR_VALUE +GL_DEPTH_CLEAR_VALUE}, + +{GL_DEPTH_RANGE, +#undef GL_DEPTH_RANGE +GL_DEPTH_RANGE}, + +{GL_STENCIL_REF, +#undef GL_STENCIL_REF +GL_STENCIL_REF}, + +{GL_STENCIL_VALUE_MASK, +#undef GL_STENCIL_VALUE_MASK +GL_STENCIL_VALUE_MASK}, + +{GL_STENCIL_FUNC, +#undef GL_STENCIL_FUNC +GL_STENCIL_FUNC}, + +{GL_STENCIL_FAIL, +#undef GL_STENCIL_FAIL +GL_STENCIL_FAIL}, + +{GL_STENCIL_PASS_DEPTH_FAIL, +#undef GL_STENCIL_PASS_DEPTH_FAIL +GL_STENCIL_PASS_DEPTH_FAIL}, + +{GL_STENCIL_PASS_DEPTH_PASS, +#undef GL_STENCIL_PASS_DEPTH_PASS +GL_STENCIL_PASS_DEPTH_PASS}, + +{GL_STENCIL_BACK_REF, +#undef GL_STENCIL_BACK_REF +GL_STENCIL_BACK_REF}, + +{GL_STENCIL_BACK_VALUE_MASK, +#undef GL_STENCIL_BACK_VALUE_MASK +GL_STENCIL_BACK_VALUE_MASK}, + +{GL_STENCIL_BACK_FUNC, +#undef GL_STENCIL_BACK_FUNC +GL_STENCIL_BACK_FUNC}, + +{GL_STENCIL_BACK_FAIL, +#undef GL_STENCIL_BACK_FAIL +GL_STENCIL_BACK_FAIL}, + +{GL_STENCIL_BACK_PASS_DEPTH_FAIL, +#undef GL_STENCIL_BACK_PASS_DEPTH_FAIL +GL_STENCIL_BACK_PASS_DEPTH_FAIL}, + +{GL_STENCIL_BACK_PASS_DEPTH_PASS, +#undef GL_STENCIL_BACK_PASS_DEPTH_PASS +GL_STENCIL_BACK_PASS_DEPTH_PASS}, + +{GL_BLEND_SRC_RGB, +#undef GL_BLEND_SRC_RGB +GL_BLEND_SRC_RGB}, + +{GL_BLEND_SRC_ALPHA, +#undef GL_BLEND_SRC_ALPHA +GL_BLEND_SRC_ALPHA}, + +{GL_BLEND_DST_RGB, +#undef GL_BLEND_DST_RGB +GL_BLEND_DST_RGB}, + +{GL_BLEND_DST_ALPHA, +#undef GL_BLEND_DST_ALPHA +GL_BLEND_DST_ALPHA}, + +{GL_BLEND_EQUATION_RGB, +#undef GL_BLEND_EQUATION_RGB +GL_BLEND_EQUATION_RGB}, + +{GL_BLEND_EQUATION_ALPHA, +#undef GL_BLEND_EQUATION_ALPHA +GL_BLEND_EQUATION_ALPHA}, + +{GL_CULL_FACE_MODE, +#undef GL_CULL_FACE_MODE +GL_CULL_FACE_MODE}, + +{GL_FRONT_FACE, +#undef GL_FRONT_FACE +GL_FRONT_FACE}, + +{GL_DEPTH_FUNC, +#undef GL_DEPTH_FUNC +GL_DEPTH_FUNC}, + +{GL_MAJOR_VERSION, +#undef GL_MAJOR_VERSION +GL_MAJOR_VERSION}, + +{GL_MINOR_VERSION, +#undef GL_MINOR_VERSION +GL_MINOR_VERSION}, + +{GL_TEXTURE_BINDING_2D, +#undef GL_TEXTURE_BINDING_2D +GL_TEXTURE_BINDING_2D}, + +{GL_TEXTURE_BINDING_2D_ARRAY, +#undef GL_TEXTURE_BINDING_2D_ARRAY +GL_TEXTURE_BINDING_2D_ARRAY}, + +{GL_TEXTURE_BINDING_3D, +#undef GL_TEXTURE_BINDING_3D +GL_TEXTURE_BINDING_3D}, + +{GL_TEXTURE_BINDING_CUBE_MAP, +#undef GL_TEXTURE_BINDING_CUBE_MAP +GL_TEXTURE_BINDING_CUBE_MAP}, + +{GL_ARRAY_BUFFER_BINDING, +#undef GL_ARRAY_BUFFER_BINDING +GL_ARRAY_BUFFER_BINDING}, + +{GL_ELEMENT_ARRAY_BUFFER_BINDING, +#undef GL_ELEMENT_ARRAY_BUFFER_BINDING +GL_ELEMENT_ARRAY_BUFFER_BINDING}, + +{GL_VERTEX_ARRAY_BINDING, +#undef GL_VERTEX_ARRAY_BINDING +GL_VERTEX_ARRAY_BINDING}, + +{GL_CURRENT_PROGRAM, +#undef GL_CURRENT_PROGRAM +GL_CURRENT_PROGRAM}, + +{GL_VIEWPORT, +#undef GL_VIEWPORT +GL_VIEWPORT}, + +{GL_SCISSOR_BOX, +#undef GL_SCISSOR_BOX +GL_SCISSOR_BOX}, + +{GL_VERTEX_SHADER, +#undef GL_VERTEX_SHADER +GL_VERTEX_SHADER}, + +{GL_FRAGMENT_SHADER, +#undef GL_FRAGMENT_SHADER +GL_FRAGMENT_SHADER}, + +{GL_INFO_LOG_LENGTH, +#undef GL_INFO_LOG_LENGTH +GL_INFO_LOG_LENGTH}, + +{GL_COMPILE_STATUS, +#undef GL_COMPILE_STATUS +GL_COMPILE_STATUS}, + +{GL_LINK_STATUS, +#undef GL_LINK_STATUS +GL_LINK_STATUS}, + +{GL_COLOR_BUFFER_BIT, +#undef GL_COLOR_BUFFER_BIT +GL_COLOR_BUFFER_BIT}, + +{GL_DEPTH_BUFFER_BIT, +#undef GL_DEPTH_BUFFER_BIT +GL_DEPTH_BUFFER_BIT}, + +{GL_STENCIL_BUFFER_BIT, +#undef GL_STENCIL_BUFFER_BIT +GL_STENCIL_BUFFER_BIT}, +}; diff --git a/src/display/gl/pgl-fun.cpp b/src/display/gl/pgl-fun.cpp new file mode 100644 index 00000000..fad8a119 --- /dev/null +++ b/src/display/gl/pgl-fun.cpp @@ -0,0 +1,420 @@ +/* + ** pgl-fun.cpp + ** + ** This file is part of mkxp. + ** + ** Copyright (C) 2014 - 2021 Amaryllis Kulla + ** + ** mkxp is free software: you can redistribute it and/or modify + ** it under the terms of the GNU General Public License as published by + ** the Free Software Foundation, either version 2 of the License, or + ** (at your option) any later version. + ** + ** mkxp is distributed in the hope that it will be useful, + ** but WITHOUT ANY WARRANTY; without even the implied warranty of + ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + ** GNU General Public License for more details. + ** + ** You should have received a copy of the GNU General Public License + ** along with mkxp. If not, see . + */ + +#include +#include +#include +#include + +extern std::unordered_map mkxp_pgl_enum_map; +static inline GLenum enumconv(GLenum x) { + const auto it = mkxp_pgl_enum_map.find(x); + return it == mkxp_pgl_enum_map.end() ? -1 : it->second; +} + +static KHRONOS_APIENTRY void _glViewport(int x, int y, GLsizei width, GLsizei height) { + glViewport(x, y, width, height); +} + +static KHRONOS_APIENTRY GLubyte *_glGetString(GLenum name) { + return glGetString(enumconv(name)); +} + +static KHRONOS_APIENTRY void _glGetBooleanv(GLenum pname, GLboolean* data) { + glGetBooleanv(enumconv(pname), data); +} + +static KHRONOS_APIENTRY void _glGetFloatv(GLenum pname, GLfloat* data) { + return glGetFloatv(enumconv(pname), data); +} + +static KHRONOS_APIENTRY void _glGetIntegerv(GLenum pname, GLint* data) { + glGetIntegerv(enumconv(pname), data); +} + +static KHRONOS_APIENTRY GLboolean _glIsEnabled(GLenum cap) { + return glIsEnabled(enumconv(cap)); +} + +static KHRONOS_APIENTRY GLboolean _glIsProgram(GLuint program) { + return glIsProgram(program); +} + +static KHRONOS_APIENTRY void _glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + glClearColor(red, green, blue, alpha); +} + +static KHRONOS_APIENTRY void _glClearDepth(GLclampf depth) { + glClearDepth(depth); +} + +static KHRONOS_APIENTRY void _glDepthFunc(GLenum func) { + glDepthFunc(enumconv(func)); +} + +static KHRONOS_APIENTRY void _glDepthRange(GLclampf nearVal, GLclampf farVal) { + glDepthRange(nearVal, farVal); +} + +static KHRONOS_APIENTRY void _glDepthMask(GLboolean flag) { + glDepthMask(flag); +} + +static KHRONOS_APIENTRY void _glBlendFunc(GLenum sfactor, GLenum dfactor) { + glBlendFunc(enumconv(sfactor), enumconv(dfactor)); +} + +static KHRONOS_APIENTRY void _glBlendEquation(GLenum mode) { + glBlendEquation(enumconv(mode)); +} + +static KHRONOS_APIENTRY void _glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { + glBlendFuncSeparate(enumconv(srcRGB), enumconv(dstRGB), enumconv(srcAlpha), enumconv(dstAlpha)); +} + +static KHRONOS_APIENTRY void _glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { + glBlendEquationSeparate(enumconv(modeRGB), enumconv(modeAlpha)); +} + +static KHRONOS_APIENTRY void _glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + glBlendColor(red, green, blue, alpha); +} + +static KHRONOS_APIENTRY void _glClear(GLbitfield mask) { + glClear(GL_COLOR_BUFFER_BIT); +} + +static KHRONOS_APIENTRY void _glProvokingVertex(GLenum provokeMode) { + glProvokingVertex(enumconv(provokeMode)); +} + +static KHRONOS_APIENTRY void _glEnable(GLenum cap) { + glEnable(enumconv(cap)); +} + +static KHRONOS_APIENTRY void _glDisable(GLenum cap) { + glDisable(enumconv(cap)); +} + +static KHRONOS_APIENTRY void _glCullFace(GLenum mode) { + glCullFace(enumconv(mode)); +} + +static KHRONOS_APIENTRY void _glFrontFace(GLenum mode) { + glFrontFace(enumconv(mode)); +} + +static KHRONOS_APIENTRY void _glPolygonMode(GLenum face, GLenum mode) { + glPolygonMode(enumconv(face), enumconv(mode)); +} + +static KHRONOS_APIENTRY void _glPointSize(GLfloat size) { + glPointSize(size); +} + +static KHRONOS_APIENTRY void _glPointParameteri(GLenum pname, GLint param) { + glPointParameteri(enumconv(pname), param); +} + +static KHRONOS_APIENTRY void _glLineWidth(GLfloat width) { + glLineWidth(width); +} + +static KHRONOS_APIENTRY void _glLogicOp(GLenum opcode) { + glLogicOp(enumconv(opcode)); +} + +static KHRONOS_APIENTRY void _glPolygonOffset(GLfloat factor, GLfloat units) { + glPolygonOffset(factor, units); +} + +static KHRONOS_APIENTRY void _glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { + glScissor(x, y, width, height); +} + +static KHRONOS_APIENTRY void _glStencilFunc(GLenum func, GLint ref, GLuint mask) { + glStencilFunc(enumconv(func), ref, mask); +} + +static KHRONOS_APIENTRY void _glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { + glStencilFuncSeparate(enumconv(face), enumconv(func), ref, mask); +} + +static KHRONOS_APIENTRY void _glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) { + glStencilOp(enumconv(sfail), enumconv(dpfail), enumconv(dppass)); +} + +static KHRONOS_APIENTRY void _glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) { + glStencilOpSeparate(enumconv(face), enumconv(sfail), enumconv(dpfail), enumconv(dppass)); +} + +static KHRONOS_APIENTRY void _glClearStencil(GLint s) { + glClearStencil(s); +} + +static KHRONOS_APIENTRY void _glStencilMask(GLuint mask) { + glStencilMask(mask); +} + +static KHRONOS_APIENTRY void _glStencilMaskSeparate(GLenum face, GLuint mask) { + glStencilMaskSeparate(enumconv(face), mask); +} + +static KHRONOS_APIENTRY void _glGenTextures(GLsizei n, GLuint* textures) { + glGenTextures(n, textures); +} + +static KHRONOS_APIENTRY void _glDeleteTextures(GLsizei n, const GLuint* textures) { + glDeleteTextures(n, textures); +} + +static KHRONOS_APIENTRY void _glBindTexture(GLenum target, GLuint texture) { + glBindTexture(enumconv(target), texture); +} + +static KHRONOS_APIENTRY void _glTexParameteri(GLenum target, GLenum pname, GLint param) { + glTexParameteri(enumconv(target), enumconv(pname), param); +} + +static KHRONOS_APIENTRY void _glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { + glTexParameterfv(enumconv(target), enumconv(pname), params); +} + +static KHRONOS_APIENTRY void _glTextureParameteri(GLuint texture, GLenum pname, GLint param) { + glTextureParameteri(texture, enumconv(pname), param); +} + +static KHRONOS_APIENTRY void _glPixelStorei(GLenum pname, GLint param) { + glPixelStorei(enumconv(pname), param); +} + +static KHRONOS_APIENTRY void _glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* data) { + glTexImage1D(enumconv(target), level, internalFormat, width, border, enumconv(format), enumconv(type), data); +} + +static KHRONOS_APIENTRY void _glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* data) { + glTexImage2D(enumconv(target), level, internalFormat, width, height, border, enumconv(format), enumconv(type), data); +} + +static KHRONOS_APIENTRY void _glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* data) { + glTexImage3D(enumconv(target), level, internalFormat, width, height, depth, border, enumconv(format), enumconv(type), data); +} + +static KHRONOS_APIENTRY void _glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid* data) { + glTexSubImage1D(enumconv(target), level, xoffset, width, enumconv(format), enumconv(type), data); +} + +static KHRONOS_APIENTRY void _glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* data) { + glTexSubImage2D(enumconv(target), level, xoffset, yoffset, width, height, enumconv(format), enumconv(type), data); +} + +static KHRONOS_APIENTRY void _glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* data) { + glTexSubImage3D(enumconv(target), level, xoffset, yoffset, zoffset, width, height, depth, enumconv(format), enumconv(type), data); +} + +static KHRONOS_APIENTRY void _glGenVertexArrays(GLsizei n, GLuint* arrays) { + glGenVertexArrays(n, arrays); +} + +static KHRONOS_APIENTRY void _glDeleteVertexArrays(GLsizei n, const GLuint* arrays) { + glDeleteVertexArrays(n, arrays); +} + +static KHRONOS_APIENTRY void _glBindVertexArray(GLuint array) { + glBindVertexArray(array); +} + +static KHRONOS_APIENTRY void _glGenBuffers(GLsizei n, GLuint* buffers) { + glGenBuffers(n, buffers); +} + +static KHRONOS_APIENTRY void _glDeleteBuffers(GLsizei n, const GLuint* buffers) { + glDeleteBuffers(n, buffers); +} + +static KHRONOS_APIENTRY void _glBindBuffer(GLenum target, GLuint buffer) { + glBindBuffer(enumconv(target), buffer); +} + +static KHRONOS_APIENTRY void _glBufferData(GLenum target, GLsizei size, const GLvoid* data, GLenum usage) { + glBufferData(enumconv(target), size, data, enumconv(usage)); +} + +static KHRONOS_APIENTRY void _glBufferSubData(GLenum target, GLsizei offset, GLsizei size, const GLvoid* data) { + glBufferSubData(enumconv(target), offset, size, data); +} + +static KHRONOS_APIENTRY void* _glMapBuffer(GLenum target, GLenum access) { + return glMapBuffer(enumconv(target), enumconv(access)); +} + +static KHRONOS_APIENTRY void _glVertexAttribDivisor(GLuint index, GLuint divisor) { + glVertexAttribDivisor(index, divisor); +} + +static KHRONOS_APIENTRY void _glEnableVertexAttribArray(GLuint index) { + glEnableVertexAttribArray(index); +} + +static KHRONOS_APIENTRY void _glDisableVertexAttribArray(GLuint index) { + glDisableVertexAttribArray(index); +} + +static KHRONOS_APIENTRY void _glDrawArrays(GLenum mode, GLint first, GLsizei count) { + glDrawArrays(enumconv(mode), first, count); +} + +static KHRONOS_APIENTRY void _glMultiDrawArrays(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) { + glMultiDrawArrays(enumconv(mode), first, count, drawcount); +} + +static KHRONOS_APIENTRY void _glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { + glDrawElements(enumconv(mode), count, enumconv(type), indices); +} + +static KHRONOS_APIENTRY void _glMultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei drawcount) { + glMultiDrawElements(enumconv(mode), count, enumconv(type), indices, drawcount); +} + +static KHRONOS_APIENTRY void _glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount) { + glDrawArraysInstanced(enumconv(mode), first, count, primcount); +} + +static KHRONOS_APIENTRY void _glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance) { + glDrawArraysInstancedBaseInstance(enumconv(mode), first, count, primcount, baseinstance); +} + +static KHRONOS_APIENTRY void _glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei primcount) { + glDrawElementsInstanced(enumconv(mode), count, enumconv(type), indices, primcount); +} + +static KHRONOS_APIENTRY void _glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei primcount, GLuint baseinstance) { + glDrawElementsInstancedBaseInstance(enumconv(mode), count, enumconv(type), indices, primcount, baseinstance); +} + +static KHRONOS_APIENTRY void _glNamedBufferData(GLuint buffer, GLsizei size, const GLvoid* data, GLenum usage) { + glNamedBufferData(buffer, size, data, enumconv(usage)); +} + +static KHRONOS_APIENTRY void _glNamedBufferSubData(GLuint buffer, GLsizei offset, GLsizei size, const GLvoid* data) { + glNamedBufferSubData(buffer, offset, size, data); +} + +static KHRONOS_APIENTRY void* _glMapNamedBuffer(GLuint buffer, GLenum access) { + return glMapNamedBuffer(buffer, enumconv(access)); +} + +static KHRONOS_APIENTRY void _glCreateTextures(GLenum target, GLsizei n, GLuint* textures) { + glCreateTextures(enumconv(target), n, textures); +} + +static KHRONOS_APIENTRY void _glDeleteProgram(GLuint program) { + glDeleteProgram(program); +} + +static KHRONOS_APIENTRY void _glUseProgram(GLuint program) { + glUseProgram(program); +} + +#define BIND_PROC(x) {"gl" #x, (void *)_gl##x} + +void *mkxp_pgl_get_proc_address(const char *proc_name) { + static std::unordered_map proc_map = { + BIND_PROC(Viewport), + BIND_PROC(GetString), + BIND_PROC(GetBooleanv), + BIND_PROC(GetFloatv), + BIND_PROC(GetIntegerv), + BIND_PROC(IsEnabled), + BIND_PROC(IsProgram), + BIND_PROC(ClearColor), + BIND_PROC(ClearDepth), + BIND_PROC(DepthFunc), + BIND_PROC(DepthRange), + BIND_PROC(DepthMask), + BIND_PROC(BlendFunc), + BIND_PROC(BlendEquation), + BIND_PROC(BlendFuncSeparate), + BIND_PROC(BlendEquationSeparate), + BIND_PROC(BlendColor), + BIND_PROC(Clear), + BIND_PROC(ProvokingVertex), + BIND_PROC(Enable), + BIND_PROC(Disable), + BIND_PROC(CullFace), + BIND_PROC(FrontFace), + BIND_PROC(PolygonMode), + BIND_PROC(PointSize), + BIND_PROC(PointParameteri), + BIND_PROC(LineWidth), + BIND_PROC(LogicOp), + BIND_PROC(PolygonOffset), + BIND_PROC(Scissor), + BIND_PROC(StencilFunc), + BIND_PROC(StencilFuncSeparate), + BIND_PROC(StencilOp), + BIND_PROC(StencilOpSeparate), + BIND_PROC(ClearStencil), + BIND_PROC(StencilMask), + BIND_PROC(StencilMaskSeparate), + BIND_PROC(GenTextures), + BIND_PROC(DeleteTextures), + BIND_PROC(BindTexture), + BIND_PROC(TexParameteri), + BIND_PROC(TexParameterfv), + BIND_PROC(TextureParameteri), + BIND_PROC(PixelStorei), + BIND_PROC(TexImage1D), + BIND_PROC(TexImage2D), + BIND_PROC(TexImage3D), + BIND_PROC(TexSubImage1D), + BIND_PROC(TexSubImage2D), + BIND_PROC(TexSubImage3D), + BIND_PROC(GenVertexArrays), + BIND_PROC(DeleteVertexArrays), + BIND_PROC(BindVertexArray), + BIND_PROC(GenBuffers), + BIND_PROC(DeleteBuffers), + BIND_PROC(BindBuffer), + BIND_PROC(BufferData), + BIND_PROC(BufferSubData), + BIND_PROC(MapBuffer), + BIND_PROC(VertexAttribDivisor), + BIND_PROC(EnableVertexAttribArray), + BIND_PROC(DisableVertexAttribArray), + BIND_PROC(DrawArrays), + BIND_PROC(MultiDrawArrays), + BIND_PROC(DrawElements), + BIND_PROC(MultiDrawElements), + BIND_PROC(DrawArraysInstanced), + BIND_PROC(DrawArraysInstancedBaseInstance), + BIND_PROC(DrawElementsInstanced), + BIND_PROC(DrawElementsInstancedBaseInstance), + BIND_PROC(NamedBufferData), + BIND_PROC(NamedBufferSubData), + BIND_PROC(MapNamedBuffer), + BIND_PROC(CreateTextures), + BIND_PROC(DeleteProgram), + BIND_PROC(UseProgram), + }; + const auto it = proc_map.find(proc_name); + return it == proc_map.end() ? NULL : it->second; +} diff --git a/subprojects/opengl-registry.wrap b/subprojects/opengl-registry.wrap index 6ddd9544..60f40f10 100644 --- a/subprojects/opengl-registry.wrap +++ b/subprojects/opengl-registry.wrap @@ -3,3 +3,4 @@ url = https://github.com/KhronosGroup/OpenGL-Registry revision = b53ca669bea4715b6d5fa53c459f47a1fecd7944 depth = 1 patch_directory = opengl-registry +diff_files = opengl-registry-types.patch diff --git a/subprojects/packagefiles/opengl-registry-types.patch b/subprojects/packagefiles/opengl-registry-types.patch new file mode 100644 index 00000000..3cebdf72 --- /dev/null +++ b/subprojects/packagefiles/opengl-registry-types.patch @@ -0,0 +1,39 @@ +# Prevents OpenGL types from being defined in gl3.h if MKXPZ_NO_GL_TYPES is defined. + +--- a/api/GLES3/gl3.h ++++ b/api/GLES3/gl3.h +@@ -40,13 +40,16 @@ extern "C" { + #ifndef GL_ES_VERSION_2_0 + #define GL_ES_VERSION_2_0 1 + #include ++#ifndef MKXPZ_NO_GL_TYPES + typedef khronos_int8_t GLbyte; + typedef khronos_float_t GLclampf; + typedef khronos_int32_t GLfixed; + typedef khronos_int16_t GLshort; + typedef khronos_uint16_t GLushort; + typedef void GLvoid; ++#endif // MKXPZ_NO_GL_TYPES + typedef struct __GLsync *GLsync; ++#ifndef MKXPZ_NO_GL_TYPES + typedef khronos_int64_t GLint64; + typedef khronos_uint64_t GLuint64; + typedef unsigned int GLenum; +@@ -60,6 +63,7 @@ typedef int GLint; + typedef unsigned char GLboolean; + typedef int GLsizei; + typedef khronos_uint8_t GLubyte; ++#endif // MKXPZ_NO_GL_TYPES + #define GL_DEPTH_BUFFER_BIT 0x00000100 + #define GL_STENCIL_BUFFER_BIT 0x00000400 + #define GL_COLOR_BUFFER_BIT 0x00004000 +@@ -651,7 +655,9 @@ GL_APICALL void GL_APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei + + #ifndef GL_ES_VERSION_3_0 + #define GL_ES_VERSION_3_0 1 ++#ifndef MKXPZ_NO_GL_TYPES + typedef khronos_uint16_t GLhalf; ++#endif // MKXPZ_NO_GL_TYPES + #define GL_READ_BUFFER 0x0C02 + #define GL_UNPACK_ROW_LENGTH 0x0CF2 + #define GL_UNPACK_SKIP_ROWS 0x0CF3