| // GENERATED FILE - DO NOT EDIT. |
| // Generated by generate_entry_points.py using data from gl.xml. |
| // |
| // Copyright 2020 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // entry_points_gl_3_1_autogen.cpp: |
| // Defines the GL 3.1 entry points. |
| |
| #include "libGL/entry_points_gl_3_1_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/Context.inl.h" |
| #include "libANGLE/entry_points_utils.h" |
| #include "libANGLE/gl_enum_utils.h" |
| #include "libANGLE/validationEGL.h" |
| #include "libANGLE/validationES.h" |
| #include "libANGLE/validationES1.h" |
| #include "libANGLE/validationES2.h" |
| #include "libANGLE/validationES3.h" |
| #include "libANGLE/validationES31.h" |
| #include "libANGLE/validationES32.h" |
| #include "libANGLE/validationESEXT.h" |
| #include "libANGLE/validationGL31_autogen.h" |
| #include "libGLESv2/global_state.h" |
| |
| namespace gl |
| { |
| void GL_APIENTRY CopyBufferSubData(GLenum readTarget, |
| GLenum writeTarget, |
| GLintptr readOffset, |
| GLintptr writeOffset, |
| GLsizeiptr size) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::CopyBufferSubData, "glCopyBufferSubData", |
| "context = %d, readTarget = %s, writeTarget = %s, readOffset = %llu, writeOffset = %llu, " |
| "size = %llu", |
| CID(context), GLenumToString(GLenumGroup::CopyBufferSubDataTarget, readTarget), |
| GLenumToString(GLenumGroup::CopyBufferSubDataTarget, writeTarget), |
| static_cast<unsigned long long>(readOffset), static_cast<unsigned long long>(writeOffset), |
| static_cast<unsigned long long>(size)); |
| |
| if (context) |
| { |
| BufferBinding readTargetPacked = FromGL<BufferBinding>(readTarget); |
| BufferBinding writeTargetPacked = FromGL<BufferBinding>(writeTarget); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateCopyBufferSubData(context, readTargetPacked, writeTargetPacked, |
| readOffset, writeOffset, size)); |
| if (isCallValid) |
| { |
| context->copyBufferSubData(readTargetPacked, writeTargetPacked, readOffset, writeOffset, |
| size); |
| } |
| ANGLE_CAPTURE(CopyBufferSubData, isCallValid, context, readTargetPacked, writeTargetPacked, |
| readOffset, writeOffset, size); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DrawArraysInstanced, "glDrawArraysInstanced", |
| "context = %d, mode = %s, first = %d, count = %d, instancecount = %d", CID(context), |
| GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, instancecount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateDrawArraysInstanced(context, modePacked, first, count, instancecount)); |
| if (isCallValid) |
| { |
| context->drawArraysInstanced(modePacked, first, count, instancecount); |
| } |
| ANGLE_CAPTURE(DrawArraysInstanced, isCallValid, context, modePacked, first, count, |
| instancecount); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DrawElementsInstanced(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const void *indices, |
| GLsizei instancecount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DrawElementsInstanced, "glDrawElementsInstanced", |
| "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR |
| ", instancecount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, |
| GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| DrawElementsType typePacked = FromGL<DrawElementsType>(type); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateDrawElementsInstanced(context, modePacked, count, typePacked, |
| indices, instancecount)); |
| if (isCallValid) |
| { |
| context->drawElementsInstanced(modePacked, count, typePacked, indices, instancecount); |
| } |
| ANGLE_CAPTURE(DrawElementsInstanced, isCallValid, context, modePacked, count, typePacked, |
| indices, instancecount); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetActiveUniformBlockName(GLuint program, |
| GLuint uniformBlockIndex, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLchar *uniformBlockName) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| context, gl::EntryPoint::GetActiveUniformBlockName, "glGetActiveUniformBlockName", |
| "context = %d, program = %u, uniformBlockIndex = %u, bufSize = %d, length = 0x%016" PRIxPTR |
| ", uniformBlockName = 0x%016" PRIxPTR "", |
| CID(context), program, uniformBlockIndex, bufSize, (uintptr_t)length, |
| (uintptr_t)uniformBlockName); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetActiveUniformBlockName(context, programPacked, uniformBlockIndex, bufSize, |
| length, uniformBlockName)); |
| if (isCallValid) |
| { |
| context->getActiveUniformBlockName(programPacked, uniformBlockIndex, bufSize, length, |
| uniformBlockName); |
| } |
| ANGLE_CAPTURE(GetActiveUniformBlockName, isCallValid, context, programPacked, |
| uniformBlockIndex, bufSize, length, uniformBlockName); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetActiveUniformBlockiv(GLuint program, |
| GLuint uniformBlockIndex, |
| GLenum pname, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetActiveUniformBlockiv, "glGetActiveUniformBlockiv", |
| "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, params = 0x%016" PRIxPTR |
| "", |
| CID(context), program, uniformBlockIndex, |
| GLenumToString(GLenumGroup::UniformBlockPName, pname), (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetActiveUniformBlockiv(context, programPacked, |
| uniformBlockIndex, pname, params)); |
| if (isCallValid) |
| { |
| context->getActiveUniformBlockiv(programPacked, uniformBlockIndex, pname, params); |
| } |
| ANGLE_CAPTURE(GetActiveUniformBlockiv, isCallValid, context, programPacked, |
| uniformBlockIndex, pname, params); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetActiveUniformName(GLuint program, |
| GLuint uniformIndex, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLchar *uniformName) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetActiveUniformName, "glGetActiveUniformName", |
| "context = %d, program = %u, uniformIndex = %u, bufSize = %d, length = 0x%016" PRIxPTR |
| ", uniformName = 0x%016" PRIxPTR "", |
| CID(context), program, uniformIndex, bufSize, (uintptr_t)length, (uintptr_t)uniformName); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetActiveUniformName(context, programPacked, uniformIndex, |
| bufSize, length, uniformName)); |
| if (isCallValid) |
| { |
| context->getActiveUniformName(programPacked, uniformIndex, bufSize, length, |
| uniformName); |
| } |
| ANGLE_CAPTURE(GetActiveUniformName, isCallValid, context, programPacked, uniformIndex, |
| bufSize, length, uniformName); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetActiveUniformsiv(GLuint program, |
| GLsizei uniformCount, |
| const GLuint *uniformIndices, |
| GLenum pname, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetActiveUniformsiv, "glGetActiveUniformsiv", |
| "context = %d, program = %u, uniformCount = %d, uniformIndices = 0x%016" PRIxPTR |
| ", pname = %s, params = 0x%016" PRIxPTR "", |
| CID(context), program, uniformCount, (uintptr_t)uniformIndices, |
| GLenumToString(GLenumGroup::UniformPName, pname), (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetActiveUniformsiv(context, programPacked, uniformCount, |
| uniformIndices, pname, params)); |
| if (isCallValid) |
| { |
| context->getActiveUniformsiv(programPacked, uniformCount, uniformIndices, pname, |
| params); |
| } |
| ANGLE_CAPTURE(GetActiveUniformsiv, isCallValid, context, programPacked, uniformCount, |
| uniformIndices, pname, params); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetUniformBlockIndex, "glGetUniformBlockIndex", |
| "context = %d, program = %u, uniformBlockName = 0x%016" PRIxPTR "", CID(context), program, |
| (uintptr_t)uniformBlockName); |
| |
| GLuint returnValue; |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetUniformBlockIndex(context, programPacked, uniformBlockName)); |
| if (isCallValid) |
| { |
| returnValue = context->getUniformBlockIndex(programPacked, uniformBlockName); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetUniformBlockIndex, GLuint>(); |
| } |
| ANGLE_CAPTURE(GetUniformBlockIndex, isCallValid, context, programPacked, uniformBlockName, |
| returnValue); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| returnValue = GetDefaultReturnValue<EntryPoint::GetUniformBlockIndex, GLuint>(); |
| } |
| return returnValue; |
| } |
| |
| void GL_APIENTRY GetUniformIndices(GLuint program, |
| GLsizei uniformCount, |
| const GLchar *const *uniformNames, |
| GLuint *uniformIndices) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetUniformIndices, "glGetUniformIndices", |
| "context = %d, program = %u, uniformCount = %d, uniformNames = 0x%016" PRIxPTR |
| ", uniformIndices = 0x%016" PRIxPTR "", |
| CID(context), program, uniformCount, (uintptr_t)uniformNames, (uintptr_t)uniformIndices); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetUniformIndices(context, programPacked, uniformCount, |
| uniformNames, uniformIndices)); |
| if (isCallValid) |
| { |
| context->getUniformIndices(programPacked, uniformCount, uniformNames, uniformIndices); |
| } |
| ANGLE_CAPTURE(GetUniformIndices, isCallValid, context, programPacked, uniformCount, |
| uniformNames, uniformIndices); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY PrimitiveRestartIndex(GLuint index) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::PrimitiveRestartIndex, "glPrimitiveRestartIndex", |
| "context = %d, index = %u", CID(context), index); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidatePrimitiveRestartIndex(context, index)); |
| if (isCallValid) |
| { |
| context->primitiveRestartIndex(index); |
| } |
| ANGLE_CAPTURE(PrimitiveRestartIndex, isCallValid, context, index); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY TexBuffer(GLenum target, GLenum internalformat, GLuint buffer) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::TexBuffer, "glTexBuffer", |
| "context = %d, target = %s, internalformat = %s, buffer = %u", CID(context), |
| GLenumToString(GLenumGroup::TextureTarget, target), |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| BufferID bufferPacked = FromGL<BufferID>(buffer); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateTexBuffer(context, targetPacked, internalformat, bufferPacked)); |
| if (isCallValid) |
| { |
| context->texBuffer(targetPacked, internalformat, bufferPacked); |
| } |
| ANGLE_CAPTURE(TexBuffer, isCallValid, context, targetPacked, internalformat, bufferPacked); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY UniformBlockBinding(GLuint program, |
| GLuint uniformBlockIndex, |
| GLuint uniformBlockBinding) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::UniformBlockBinding, "glUniformBlockBinding", |
| "context = %d, program = %u, uniformBlockIndex = %u, uniformBlockBinding = %u", |
| CID(context), program, uniformBlockIndex, uniformBlockBinding); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateUniformBlockBinding(context, programPacked, uniformBlockIndex, |
| uniformBlockBinding)); |
| if (isCallValid) |
| { |
| context->uniformBlockBinding(programPacked, uniformBlockIndex, uniformBlockBinding); |
| } |
| ANGLE_CAPTURE(UniformBlockBinding, isCallValid, context, programPacked, uniformBlockIndex, |
| uniformBlockBinding); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| } // namespace gl |
