| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <OpenGLESDispatch/GLESv3Dispatch.h> |
| |
| #include "GLESv3.h" |
| |
| #include <string> |
| #include <vector> |
| |
| // Stubs (common) |
| |
| static void glDeleteFencesNV(GLsizei, const GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glDisableDriverControlQCOM(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glDiscardFramebufferEXT(GLenum, GLsizei, const GLenum*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glEnableDriverControlQCOM(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glEndTilingQCOM(GLbitfield) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetBufferPointervQCOM(GLenum, GLvoid**) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetBuffersQCOM(GLuint*, GLint, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetFramebuffersQCOM(GLuint*, GLint, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetProgramBinarySourceQCOM(GLuint, GLenum, GLchar*, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetProgramsQCOM(GLuint*, GLint, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetRenderbuffersQCOM(GLuint*, GLint, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetShadersQCOM(GLuint*, GLint, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetTexLevelParameterivQCOM(GLuint, GLenum, GLint, GLenum, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetTexSubImageQCOM(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, |
| GLenum, GLenum, GLvoid*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glExtGetTexturesQCOM(GLuint*, GLint, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static GLboolean glExtIsProgramBinaryQCOM(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| return GL_FALSE; |
| } |
| |
| static void glExtTexObjectStateOverrideiQCOM(GLenum, GLenum, GLint) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glFinishFenceNV(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glFramebufferTexture2DMultisampleIMG(GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGenFencesNV(GLsizei, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetDriverControlsQCOM(GLint*, GLsizei, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetDriverControlStringQCOM(GLuint, GLsizei, GLsizei*, GLchar*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetFenceivNV(GLuint, GLenum, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static GLboolean glIsFenceNV(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| return GL_FALSE; |
| } |
| |
| static void* glMapBufferOES(GLenum, GLenum) { |
| printf("%s: not implemented\n", __func__); |
| return nullptr; |
| } |
| |
| static void glMultiDrawArraysEXT(GLenum, const GLint*, const GLsizei*, GLsizei) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glMultiDrawElementsEXT(GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glRenderbufferStorageMultisampleIMG(GLenum, GLsizei, GLenum, GLsizei, GLsizei) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glSetFenceNV(GLuint, GLenum) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glStartTilingQCOM(GLuint, GLuint, GLuint, GLuint, GLbitfield) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static GLboolean glTestFenceNV(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| return GL_FALSE; |
| } |
| |
| // Stubs (ES 3.1) |
| |
| static void glBeginPerfMonitorAMD(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glCoverageMaskNV(GLboolean) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glCoverageOperationNV(GLenum) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glDeletePerfMonitorsAMD(GLsizei, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glEndPerfMonitorAMD(GLuint) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGenPerfMonitorsAMD(GLsizei, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetPerfMonitorCounterDataAMD(GLuint, GLenum, GLsizei, GLuint*, GLint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetPerfMonitorCounterInfoAMD(GLuint, GLuint, GLenum, GLvoid*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetPerfMonitorCountersAMD(GLuint, GLint*, GLint*, GLsizei, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetPerfMonitorCounterStringAMD(GLuint, GLuint, GLsizei, GLsizei*, GLchar*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetPerfMonitorGroupsAMD(GLint*, GLsizei, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glGetPerfMonitorGroupStringAMD(GLuint, GLsizei, GLsizei*, GLchar*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void glSelectPerfMonitorCountersAMD(GLuint, GLboolean, GLuint, GLint, GLuint*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| // Non-stubs (common) |
| |
| static void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* indices, GLuint) { |
| s_gles3.glDrawElements(mode, count, type, indices); |
| } |
| |
| static void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) { |
| s_gles3.glDrawElements(mode, count, type, reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static GLint glFinishRoundTrip() { |
| s_gles3.glFinish(); |
| return 0; |
| } |
| |
| static void glGetCompressedTextureFormats(int count, GLint* formats) { |
| int nFormats; |
| s_gles3.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nFormats); |
| if (nFormats <= count) |
| s_gles3.glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats); |
| } |
| |
| // Non-stubs (ES 3.1) |
| |
| struct GlSync { |
| GlSync(GLESv3* ctx_, GLsync sync_) : sync(sync_), id(ctx_->sync_nextId++), ctx(ctx_) { |
| ctx->sync_map.emplace(id, this); |
| } |
| |
| ~GlSync() { |
| ctx->sync_map.erase(id); |
| } |
| |
| GLsync sync; |
| uint64_t id; |
| |
| private: |
| GLESv3* ctx; |
| }; |
| |
| static GLenum glClientWaitSyncAEMU(void* ctx_, uint64_t wait_on, GLbitfield flags, |
| GLuint64 timeout) { |
| GLESv3* ctx = static_cast<GLESv3*>(ctx_); |
| |
| std::map<uint64_t, GlSync*>::iterator it; |
| it = ctx->sync_map.find(wait_on); |
| if (it == ctx->sync_map.end()) |
| return GL_INVALID_VALUE; |
| |
| GlSync* sync = it->second; |
| return s_gles3.glClientWaitSync(sync->sync, flags, timeout); |
| } |
| |
| static void glCompressedTexImage2DOffsetAEMU(GLenum target, GLint level, GLenum internalformat, |
| GLsizei width, GLsizei height, GLint border, |
| GLsizei imageSize, GLuint offset) { |
| s_gles3.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, |
| reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glCompressedTexImage3DOffsetAEMU(GLenum target, GLint level, GLenum internalformat, |
| GLsizei width, GLsizei height, GLsizei depth, |
| GLint border, GLsizei imageSize, GLuint offset) { |
| s_gles3.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, |
| imageSize, reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glCompressedTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, |
| GLint yoffset, GLsizei width, GLsizei height, |
| GLenum format, GLsizei imageSize, GLuint offset) { |
| s_gles3.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, |
| imageSize, reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glCompressedTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, |
| GLint yoffset, GLint zoffset, GLsizei width, |
| GLsizei height, GLsizei depth, GLenum format, |
| GLsizei imageSize, GLuint offset) { |
| s_gles3.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, |
| format, imageSize, reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static GLuint glCreateShaderProgramvAEMU(GLenum type, GLsizei, const char* packedStrings, GLuint) { |
| return s_gles3.glCreateShaderProgramv(type, 1, &packedStrings); |
| } |
| |
| static void glDeleteSyncAEMU(void* ctx_, uint64_t to_delete) { |
| GLESv3* ctx = static_cast<GLESv3*>(ctx_); |
| |
| std::map<uint64_t, GlSync*>::iterator it; |
| it = ctx->sync_map.find(to_delete); |
| if (it == ctx->sync_map.end()) |
| return; |
| |
| GlSync* sync = it->second; |
| s_gles3.glDeleteSync(sync->sync); |
| delete sync; |
| } |
| |
| static void glDrawArraysIndirectDataAEMU(GLenum mode, const void* indirect, GLuint) { |
| s_gles3.glDrawArraysIndirect(mode, indirect); |
| } |
| |
| static void glDrawArraysIndirectOffsetAEMU(GLenum mode, GLuint offset) { |
| s_gles3.glDrawArraysIndirect(mode, reinterpret_cast<const void*>(offset)); |
| } |
| |
| static void glDrawElementsIndirectDataAEMU(GLenum mode, GLenum type, const void* indirect, GLuint) { |
| s_gles3.glDrawElementsIndirect(mode, type, indirect); |
| } |
| |
| static void glDrawElementsIndirectOffsetAEMU(GLenum mode, GLenum type, GLuint offset) { |
| s_gles3.glDrawElementsIndirect(mode, type, reinterpret_cast<const void*>(offset)); |
| } |
| |
| static void glDrawElementsInstancedDataAEMU(GLenum mode, GLsizei count, GLenum type, |
| const void* indices, GLsizei primcount, GLsizei) { |
| s_gles3.glDrawElementsInstanced(mode, count, type, indices, primcount); |
| } |
| |
| static void glDrawElementsInstancedOffsetAEMU(GLenum mode, GLsizei count, GLenum type, |
| GLuint offset, GLsizei primcount) { |
| s_gles3.glDrawElementsInstanced(mode, count, type, reinterpret_cast<const void*>(offset), |
| primcount); |
| } |
| |
| static void glDrawRangeElementsDataAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count, |
| GLenum type, const GLvoid* indices, GLsizei) { |
| s_gles3.glDrawRangeElements(mode, start, end, count, type, indices); |
| } |
| |
| static void glDrawRangeElementsOffsetAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count, |
| GLenum type, GLuint offset) { |
| s_gles3.glDrawRangeElements(mode, start, end, count, type, |
| reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static uint64_t glFenceSyncAEMU(void* ctx_, GLenum condition, GLbitfield flags) { |
| GLsync sync_ = s_gles3.glFenceSync(condition, flags); |
| if (sync_ == 0) |
| return 0U; |
| |
| GLESv3* ctx = static_cast<GLESv3*>(ctx_); |
| GlSync* sync = new (std::nothrow) GlSync(ctx, sync_); |
| if (!sync) { |
| s_gles3.glDeleteSync(sync_); |
| return 0U; |
| } |
| |
| return sync->id; |
| } |
| |
| static void glFlushMappedBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length, |
| GLbitfield access, void* guest_buffer) { |
| if (guest_buffer && length) { |
| void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access); |
| if (gpuPtr) { |
| memcpy(gpuPtr, guest_buffer, length); |
| s_gles3.glFlushMappedBufferRange(target, 0, length); |
| s_gles3.glUnmapBuffer(target); |
| } |
| } |
| } |
| |
| static void glGetSyncivAEMU(void* ctx_, uint64_t sync_, GLenum pname, GLsizei bufSize, |
| GLsizei* length, GLint* values) { |
| GLESv3* ctx = static_cast<GLESv3*>(ctx_); |
| |
| std::map<uint64_t, GlSync*>::iterator it; |
| it = ctx->sync_map.find(sync_); |
| if (it == ctx->sync_map.end()) |
| return; |
| |
| GlSync* sync = it->second; |
| s_gles3.glGetSynciv(sync->sync, pname, bufSize, length, values); |
| } |
| |
| static std::vector<std::string> sUnpackVarNames(GLsizei count, const char* packedNames) { |
| std::vector<std::string> unpacked; |
| GLsizei current = 0; |
| |
| while (current < count) { |
| const char* delimPos = strstr(packedNames, ";"); |
| size_t nameLen = delimPos - packedNames; |
| std::string next; |
| next.resize(nameLen); |
| memcpy(&next[0], packedNames, nameLen); |
| unpacked.push_back(next); |
| packedNames = delimPos + 1; |
| current++; |
| } |
| |
| return unpacked; |
| } |
| |
| static void glGetUniformIndicesAEMU(GLuint program, GLsizei uniformCount, const GLchar* packedNames, |
| GLsizei packedLen, GLuint* uniformIndices) { |
| std::vector<std::string> unpacked = sUnpackVarNames(uniformCount, packedNames); |
| GLchar** unpackedArray = new GLchar*[unpacked.size()]; |
| GLsizei i = 0; |
| for (auto& elt : unpacked) { |
| unpackedArray[i] = (GLchar*)&elt[0]; |
| i++; |
| } |
| |
| s_gles3.glGetUniformIndices(program, uniformCount, const_cast<const GLchar**>(unpackedArray), |
| uniformIndices); |
| delete[] unpackedArray; |
| } |
| |
| static GLboolean glIsSyncAEMU(void* ctx_, uint64_t sync) { |
| GLESv3* ctx = static_cast<GLESv3*>(ctx_); |
| return ctx->sync_map.count(sync) ? GL_TRUE : GL_FALSE; |
| } |
| |
| static void glMapBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length, |
| GLbitfield access, void* mapped) { |
| if ((access & GL_MAP_READ_BIT) || |
| ((access & GL_MAP_WRITE_BIT) && |
| (!(access & GL_MAP_INVALIDATE_RANGE_BIT) && !(access & GL_MAP_INVALIDATE_BUFFER_BIT)))) { |
| void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access); |
| if (gpuPtr) { |
| if (mapped) |
| memcpy(mapped, gpuPtr, length); |
| s_gles3.glUnmapBuffer(target); |
| } |
| } |
| } |
| |
| static void glReadPixelsOffsetAEMU(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, |
| GLenum type, GLuint offset) { |
| s_gles3.glReadPixels(x, y, width, height, format, type, reinterpret_cast<GLvoid*>(offset)); |
| } |
| |
| static void glShaderString(GLuint shader, const GLchar* string, GLsizei) { |
| s_gles3.glShaderSource(shader, 1, &string, NULL); |
| } |
| |
| static void glTexImage2DOffsetAEMU(GLenum target, GLint level, GLint internalformat, GLsizei width, |
| GLsizei height, GLint border, GLenum format, GLenum type, |
| GLuint offset) { |
| s_gles3.glTexImage2D(target, level, internalformat, width, height, border, format, type, |
| reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glTexImage3DOffsetAEMU(GLenum target, GLint level, GLint internalFormat, GLsizei width, |
| GLsizei height, GLsizei depth, GLint border, GLenum format, |
| GLenum type, GLuint offset) { |
| s_gles3.glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, |
| reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, |
| GLsizei width, GLsizei height, GLenum format, GLenum type, |
| GLuint offset) { |
| s_gles3.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, |
| reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, |
| GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, |
| GLenum format, GLenum type, GLuint offset) { |
| s_gles3.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, |
| type, reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glTransformFeedbackVaryingsAEMU(GLuint program, GLsizei count, |
| const char* packedVaryings, GLuint packedVaryingsLen, |
| GLenum bufferMode) { |
| std::vector<std::string> unpacked = sUnpackVarNames(count, packedVaryings); |
| char** unpackedArray = new char*[unpacked.size()]; |
| GLsizei i = 0; |
| for (auto& elt : unpacked) { |
| unpackedArray[i] = &elt[0]; |
| i++; |
| } |
| |
| s_gles3.glTransformFeedbackVaryings(program, count, const_cast<const char**>(unpackedArray), |
| bufferMode); |
| delete[] unpackedArray; |
| } |
| |
| static void glUnmapBufferAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, |
| void* guest_buffer, GLboolean* out_res) { |
| *out_res = GL_TRUE; |
| |
| if (access & GL_MAP_WRITE_BIT) { |
| if (guest_buffer) { |
| void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access); |
| if (gpuPtr) |
| memcpy(gpuPtr, guest_buffer, length); |
| } |
| |
| *out_res = s_gles3.glUnmapBuffer(target); |
| } |
| } |
| |
| static void glVertexAttribIPointerDataAEMU(GLuint index, GLint size, GLenum type, GLsizei, |
| void* data, GLuint) { |
| s_gles3.glVertexAttribIPointer(index, size, type, 0, data); |
| } |
| |
| static void glVertexAttribIPointerOffsetAEMU(GLuint index, GLint size, GLenum type, GLsizei, |
| GLuint offset) { |
| s_gles3.glVertexAttribIPointer(index, size, type, 0, reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, |
| GLsizei, void* data, GLuint) { |
| s_gles3.glVertexAttribPointer(indx, size, type, normalized, 0, data); |
| } |
| |
| static void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, |
| GLsizei, GLuint offset) { |
| s_gles3.glVertexAttribPointer(indx, size, type, normalized, 0, |
| reinterpret_cast<const GLvoid*>(offset)); |
| } |
| |
| static void glWaitSyncAEMU(void* ctx_, uint64_t wait_on, GLbitfield flags, GLuint64 timeout) { |
| GLESv3* ctx = static_cast<GLESv3*>(ctx_); |
| |
| std::map<uint64_t, GlSync*>::iterator it; |
| it = ctx->sync_map.find(wait_on); |
| if (it == ctx->sync_map.end()) |
| return; |
| |
| GlSync* sync = it->second; |
| s_gles3.glWaitSync(sync->sync, flags, timeout); |
| } |
| |
| #define KNIT(return_type, function_name, signature, callargs) function_name = s_gles3.function_name; |
| |
| GLESv3::GLESv3() { |
| LIST_GLES3_FUNCTIONS(KNIT, KNIT) |
| |
| // Remap some ES 2.0 extensions that become core in ES 3.1 |
| glBindVertexArrayOES = glBindVertexArray; |
| glDeleteVertexArraysOES = glDeleteVertexArrays; |
| glGenVertexArraysOES = glGenVertexArrays; |
| glGetProgramBinaryOES = glGetProgramBinary; |
| glIsVertexArrayOES = glIsVertexArray; |
| glProgramBinaryOES = glProgramBinary; |
| glUnmapBufferOES = glUnmapBuffer; |
| |
| // Entrypoints requiring custom wrappers (common) |
| glDrawElementsData = ::glDrawElementsData; |
| glDrawElementsOffset = ::glDrawElementsOffset; |
| glFinishRoundTrip = ::glFinishRoundTrip; |
| glGetCompressedTextureFormats = ::glGetCompressedTextureFormats; |
| |
| // Entrypoints requiring custom wrappers (ES 3.1) |
| glClientWaitSyncAEMU = ::glClientWaitSyncAEMU; |
| glCompressedTexImage2DOffsetAEMU = ::glCompressedTexImage2DOffsetAEMU; |
| glCompressedTexImage3DOffsetAEMU = ::glCompressedTexImage3DOffsetAEMU; |
| glCompressedTexSubImage2DOffsetAEMU = ::glCompressedTexSubImage2DOffsetAEMU; |
| glCompressedTexSubImage3DOffsetAEMU = ::glCompressedTexSubImage3DOffsetAEMU; |
| glCreateShaderProgramvAEMU = ::glCreateShaderProgramvAEMU; |
| glDeleteSyncAEMU = ::glDeleteSyncAEMU; |
| glDrawArraysIndirectDataAEMU = ::glDrawArraysIndirectDataAEMU; |
| glDrawArraysIndirectOffsetAEMU = ::glDrawArraysIndirectOffsetAEMU; |
| glDrawElementsIndirectDataAEMU = ::glDrawElementsIndirectDataAEMU; |
| glDrawElementsIndirectOffsetAEMU = ::glDrawElementsIndirectOffsetAEMU; |
| glDrawElementsInstancedDataAEMU = ::glDrawElementsInstancedDataAEMU; |
| glDrawElementsInstancedOffsetAEMU = ::glDrawElementsInstancedOffsetAEMU; |
| glDrawRangeElementsDataAEMU = ::glDrawRangeElementsDataAEMU; |
| glDrawRangeElementsOffsetAEMU = ::glDrawRangeElementsOffsetAEMU; |
| glFenceSyncAEMU = ::glFenceSyncAEMU; |
| glFlushMappedBufferRangeAEMU = ::glFlushMappedBufferRangeAEMU; |
| glGetSyncivAEMU = ::glGetSyncivAEMU; |
| glGetUniformIndicesAEMU = ::glGetUniformIndicesAEMU; |
| glIsSyncAEMU = ::glIsSyncAEMU; |
| glMapBufferRangeAEMU = ::glMapBufferRangeAEMU; |
| glReadPixelsOffsetAEMU = ::glReadPixelsOffsetAEMU; |
| glShaderString = ::glShaderString; |
| glTexImage2DOffsetAEMU = ::glTexImage2DOffsetAEMU; |
| glTexImage3DOffsetAEMU = ::glTexImage3DOffsetAEMU; |
| glTexSubImage2DOffsetAEMU = ::glTexSubImage2DOffsetAEMU; |
| glTexSubImage3DOffsetAEMU = ::glTexSubImage3DOffsetAEMU; |
| glTransformFeedbackVaryingsAEMU = ::glTransformFeedbackVaryingsAEMU; |
| glUnmapBufferAEMU = ::glUnmapBufferAEMU; |
| glVertexAttribIPointerDataAEMU = ::glVertexAttribIPointerDataAEMU; |
| glVertexAttribIPointerOffsetAEMU = ::glVertexAttribIPointerOffsetAEMU; |
| glVertexAttribPointerData = ::glVertexAttribPointerData; |
| glVertexAttribPointerOffset = ::glVertexAttribPointerOffset; |
| glWaitSyncAEMU = ::glWaitSyncAEMU; |
| |
| // Stub some extensions we will never implement (common) |
| glDeleteFencesNV = ::glDeleteFencesNV; |
| glDisableDriverControlQCOM = ::glDisableDriverControlQCOM; |
| glDiscardFramebufferEXT = ::glDiscardFramebufferEXT; |
| glEnableDriverControlQCOM = ::glEnableDriverControlQCOM; |
| glEndTilingQCOM = ::glEndTilingQCOM; |
| glExtGetBufferPointervQCOM = ::glExtGetBufferPointervQCOM; |
| glExtGetBuffersQCOM = ::glExtGetBuffersQCOM; |
| glExtGetFramebuffersQCOM = ::glExtGetFramebuffersQCOM; |
| glExtGetProgramBinarySourceQCOM = ::glExtGetProgramBinarySourceQCOM; |
| glExtGetProgramsQCOM = ::glExtGetProgramsQCOM; |
| glExtGetRenderbuffersQCOM = ::glExtGetRenderbuffersQCOM; |
| glExtGetShadersQCOM = ::glExtGetShadersQCOM; |
| glExtGetTexLevelParameterivQCOM = ::glExtGetTexLevelParameterivQCOM; |
| glExtGetTexSubImageQCOM = ::glExtGetTexSubImageQCOM; |
| glExtGetTexturesQCOM = ::glExtGetTexturesQCOM; |
| glExtIsProgramBinaryQCOM = ::glExtIsProgramBinaryQCOM; |
| glExtTexObjectStateOverrideiQCOM = ::glExtTexObjectStateOverrideiQCOM; |
| glFinishFenceNV = ::glFinishFenceNV; |
| glFramebufferTexture2DMultisampleIMG = ::glFramebufferTexture2DMultisampleIMG; |
| glGenFencesNV = ::glGenFencesNV; |
| glGetDriverControlsQCOM = ::glGetDriverControlsQCOM; |
| glGetDriverControlStringQCOM = ::glGetDriverControlStringQCOM; |
| glGetFenceivNV = ::glGetFenceivNV; |
| glIsFenceNV = ::glIsFenceNV; |
| glMapBufferOES = ::glMapBufferOES; |
| glMultiDrawArraysEXT = ::glMultiDrawArraysEXT; |
| glMultiDrawElementsEXT = ::glMultiDrawElementsEXT; |
| glRenderbufferStorageMultisampleIMG = ::glRenderbufferStorageMultisampleIMG; |
| glSetFenceNV = ::glSetFenceNV; |
| glStartTilingQCOM = ::glStartTilingQCOM; |
| glTestFenceNV = ::glTestFenceNV; |
| |
| // Stub some extensions we will never implement (ES 3.1) |
| glBeginPerfMonitorAMD = ::glBeginPerfMonitorAMD; |
| glCoverageMaskNV = ::glCoverageMaskNV; |
| glCoverageOperationNV = ::glCoverageOperationNV; |
| glDeletePerfMonitorsAMD = ::glDeletePerfMonitorsAMD; |
| glEndPerfMonitorAMD = ::glEndPerfMonitorAMD; |
| glGenPerfMonitorsAMD = ::glGenPerfMonitorsAMD; |
| glGetPerfMonitorCounterDataAMD = ::glGetPerfMonitorCounterDataAMD; |
| glGetPerfMonitorCounterInfoAMD = ::glGetPerfMonitorCounterInfoAMD; |
| glGetPerfMonitorCountersAMD = ::glGetPerfMonitorCountersAMD; |
| glGetPerfMonitorCounterStringAMD = ::glGetPerfMonitorCounterStringAMD; |
| glGetPerfMonitorGroupsAMD = ::glGetPerfMonitorGroupsAMD; |
| glGetPerfMonitorGroupStringAMD = ::glGetPerfMonitorGroupStringAMD; |
| glSelectPerfMonitorCountersAMD = ::glSelectPerfMonitorCountersAMD; |
| } |
