diff options
Diffstat (limited to 'src/3rdparty/angle/src/libGLESv2')
13 files changed, 2475 insertions, 1341 deletions
diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_egl.cpp b/src/3rdparty/angle/src/libGLESv2/entry_points_egl.cpp index a6db1585e7..6f9770c57c 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_egl.cpp +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_egl.cpp @@ -8,8 +8,9 @@ #include "libGLESv2/entry_points_egl.h" #include "libGLESv2/entry_points_egl_ext.h" +#include "libGLESv2/entry_points_gles_2_0.h" #include "libGLESv2/entry_points_gles_2_0_ext.h" -#include "libGLESv2/entry_points_gles_3_0_ext.h" +#include "libGLESv2/entry_points_gles_3_0.h" #include "libGLESv2/global_state.h" #include "libANGLE/Context.h" @@ -40,7 +41,7 @@ EGLDisplay EGLAPIENTRY GetDisplay(EGLNativeDisplayType display_id) { EVENT("(EGLNativeDisplayType display_id = 0x%0.8p)", display_id); - return Display::getDisplay(display_id, AttributeMap()); + return Display::GetDisplayFromAttribs(reinterpret_cast<void *>(display_id), AttributeMap()); } EGLBoolean EGLAPIENTRY Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor) @@ -48,14 +49,13 @@ EGLBoolean EGLAPIENTRY Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor) EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint *major = 0x%0.8p, EGLint *minor = 0x%0.8p)", dpy, major, minor); - if (dpy == EGL_NO_DISPLAY) + Display *display = static_cast<Display *>(dpy); + if (dpy == EGL_NO_DISPLAY || !Display::isValidDisplay(display)) { SetGlobalError(Error(EGL_BAD_DISPLAY)); return EGL_FALSE; } - Display *display = static_cast<Display*>(dpy); - Error error = display->initialize(); if (error.isError()) { @@ -74,13 +74,13 @@ EGLBoolean EGLAPIENTRY Terminate(EGLDisplay dpy) { EVENT("(EGLDisplay dpy = 0x%0.8p)", dpy); - if (dpy == EGL_NO_DISPLAY) + Display *display = static_cast<Display *>(dpy); + if (dpy == EGL_NO_DISPLAY || !Display::isValidDisplay(display)) { SetGlobalError(Error(EGL_BAD_DISPLAY)); return EGL_FALSE; } - Display *display = static_cast<Display*>(dpy); gl::Context *context = GetGlobalContext(); if (display->isValidContext(context)) @@ -171,7 +171,7 @@ EGLBoolean EGLAPIENTRY GetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint con configs[i] = const_cast<Config*>(filteredConfigs[i]); } } - *num_config = filteredConfigs.size(); + *num_config = static_cast<EGLint>(filteredConfigs.size()); SetGlobalError(Error(EGL_SUCCESS)); return EGL_TRUE; @@ -207,7 +207,7 @@ EGLBoolean EGLAPIENTRY ChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, E configs[i] = const_cast<Config*>(filteredConfigs[i]); } } - *num_config = filteredConfigs.size(); + *num_config = static_cast<EGLint>(filteredConfigs.size()); SetGlobalError(Error(EGL_SUCCESS)); return EGL_TRUE; @@ -426,6 +426,37 @@ EGLBoolean EGLAPIENTRY QuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint a } *value = eglSurface->isFixedSize(); break; + case EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE: + if (!display->getExtensions().flexibleSurfaceCompatibility) + { + SetGlobalError( + Error(EGL_BAD_ATTRIBUTE, + "EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE cannot be used without " + "EGL_ANGLE_flexible_surface_compatibility support.")); + return EGL_FALSE; + } + *value = eglSurface->flexibleSurfaceCompatibilityRequested(); + break; + case EGL_SURFACE_ORIENTATION_ANGLE: + if (!display->getExtensions().surfaceOrientation) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE, + "EGL_SURFACE_ORIENTATION_ANGLE cannot be queried without " + "EGL_ANGLE_surface_orientation support.")); + return EGL_FALSE; + } + *value = eglSurface->getOrientation(); + break; + case EGL_DIRECT_COMPOSITION_ANGLE: + if (!display->getExtensions().directComposition) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE, + "EGL_DIRECT_COMPOSITION_ANGLE cannot be used without " + "EGL_ANGLE_direct_composition support.")); + return EGL_FALSE; + } + *value = eglSurface->directComposition(); + break; default: SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); return EGL_FALSE; @@ -504,14 +535,42 @@ EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface r Display *display = static_cast<Display*>(dpy); gl::Context *context = static_cast<gl::Context*>(ctx); - bool noContext = (ctx == EGL_NO_CONTEXT); - bool noSurface = (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE); - if (noContext != noSurface) + // If ctx is EGL_NO_CONTEXT and either draw or read are not EGL_NO_SURFACE, an EGL_BAD_MATCH + // error is generated. + if (ctx == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE)) { SetGlobalError(Error(EGL_BAD_MATCH)); return EGL_FALSE; } + if (ctx != EGL_NO_CONTEXT && draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE) + { + SetGlobalError(Error(EGL_BAD_MATCH)); + return EGL_FALSE; + } + + // If either of draw or read is a valid surface and the other is EGL_NO_SURFACE, an + // EGL_BAD_MATCH error is generated. + if ((read == EGL_NO_SURFACE) != (draw == EGL_NO_SURFACE)) + { + SetGlobalError(Error( + EGL_BAD_MATCH, "read and draw must both be valid surfaces, or both be EGL_NO_SURFACE")); + return EGL_FALSE; + } + + if (dpy == EGL_NO_DISPLAY || !Display::isValidDisplay(display)) + { + SetGlobalError(Error(EGL_BAD_DISPLAY, "'dpy' not a valid EGLDisplay handle")); + return EGL_FALSE; + } + + // EGL 1.5 spec: dpy can be uninitialized if all other parameters are null + if (!display->isInitialized() && (ctx != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE)) + { + SetGlobalError(Error(EGL_NOT_INITIALIZED, "'dpy' not initialized")); + return EGL_FALSE; + } + if (ctx != EGL_NO_CONTEXT) { Error error = ValidateContext(display, context); @@ -522,7 +581,7 @@ EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface r } } - if (dpy != EGL_NO_DISPLAY && display->isInitialized()) + if (display->isInitialized()) { if (display->testDeviceLost()) { @@ -559,19 +618,54 @@ EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface r } } + if (readSurface) + { + Error readCompatError = + ValidateCompatibleConfigs(display, readSurface->getConfig(), readSurface, + context->getConfig(), readSurface->getType()); + if (readCompatError.isError()) + { + SetGlobalError(readCompatError); + return EGL_FALSE; + } + } + if (draw != read) { UNIMPLEMENTED(); // FIXME + + if (drawSurface) + { + Error drawCompatError = + ValidateCompatibleConfigs(display, drawSurface->getConfig(), drawSurface, + context->getConfig(), drawSurface->getType()); + if (drawCompatError.isError()) + { + SetGlobalError(drawCompatError); + return EGL_FALSE; + } + } + } + + Error makeCurrentError = display->makeCurrent(drawSurface, readSurface, context); + if (makeCurrentError.isError()) + { + SetGlobalError(makeCurrentError); + return EGL_FALSE; } + gl::Context *previousContext = GetGlobalContext(); + SetGlobalDisplay(display); SetGlobalDrawSurface(drawSurface); SetGlobalReadSurface(readSurface); SetGlobalContext(context); - if (context != nullptr && display != nullptr && drawSurface != nullptr) + // Release the surface from the previously-current context, to allow + // destroyed surfaces to delete themselves. + if (previousContext != nullptr && context != previousContext) { - display->makeCurrent(drawSurface, readSurface, context); + previousContext->releaseSurface(); } SetGlobalError(Error(EGL_SUCCESS)); @@ -627,7 +721,7 @@ EGLBoolean EGLAPIENTRY QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attri switch (attribute) { case EGL_CONFIG_ID: - *value = context->getConfigID(); + *value = context->getConfig()->configID; break; case EGL_CONTEXT_CLIENT_TYPE: *value = context->getClientType(); @@ -651,20 +745,56 @@ EGLBoolean EGLAPIENTRY WaitGL(void) { EVENT("()"); - UNIMPLEMENTED(); // FIXME + Display *display = GetGlobalDisplay(); + + Error error = ValidateDisplay(display); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } + + // eglWaitGL like calling eglWaitClient with the OpenGL ES API bound. Since we only implement + // OpenGL ES we can do the call directly. + error = display->waitClient(); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } SetGlobalError(Error(EGL_SUCCESS)); - return 0; + return EGL_TRUE; } EGLBoolean EGLAPIENTRY WaitNative(EGLint engine) { EVENT("(EGLint engine = %d)", engine); - UNIMPLEMENTED(); // FIXME + Display *display = GetGlobalDisplay(); + + Error error = ValidateDisplay(display); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } + + if (engine != EGL_CORE_NATIVE_ENGINE) + { + SetGlobalError( + Error(EGL_BAD_PARAMETER, "the 'engine' parameter has an unrecognized value")); + } + + error = display->waitNative(engine, GetGlobalDrawSurface(), GetGlobalReadSurface()); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } SetGlobalError(Error(EGL_SUCCESS)); - return 0; + return EGL_TRUE; } EGLBoolean EGLAPIENTRY SwapBuffers(EGLDisplay dpy, EGLSurface surface) @@ -775,13 +905,18 @@ EGLBoolean EGLAPIENTRY BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint b gl::Texture *textureObject = context->getTargetTexture(GL_TEXTURE_2D); ASSERT(textureObject != NULL); - if (textureObject->isImmutable()) + if (textureObject->getImmutableFormat()) { SetGlobalError(Error(EGL_BAD_MATCH)); return EGL_FALSE; } - eglSurface->bindTexImage(textureObject, buffer); + error = eglSurface->bindTexImage(textureObject, buffer); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } } SetGlobalError(Error(EGL_SUCCESS)); @@ -845,7 +980,12 @@ EGLBoolean EGLAPIENTRY ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLin if (texture) { - eglSurface->releaseTexImage(buffer); + error = eglSurface->releaseTexImage(buffer); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } } SetGlobalError(Error(EGL_SUCCESS)); @@ -959,10 +1099,24 @@ EGLBoolean EGLAPIENTRY WaitClient(void) { EVENT("()"); - UNIMPLEMENTED(); // FIXME + Display *display = GetGlobalDisplay(); + + Error error = ValidateDisplay(display); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } + + error = display->waitClient(); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } SetGlobalError(Error(EGL_SUCCESS)); - return 0; + return EGL_TRUE; } // EGL 1.4 @@ -1066,62 +1220,443 @@ __eglMustCastToProperFunctionPointerType EGLAPIENTRY GetProcAddress(const char * { EVENT("(const char *procname = \"%s\")", procname); - struct Extension - { - const char *name; - __eglMustCastToProperFunctionPointerType address; + typedef std::map<std::string, __eglMustCastToProperFunctionPointerType> ProcAddressMap; + auto generateProcAddressMap = []() + { + ProcAddressMap map; +#define INSERT_PROC_ADDRESS(ns, proc) \ + map[#ns #proc] = reinterpret_cast<__eglMustCastToProperFunctionPointerType>(ns::proc) + + // GLES2 core + INSERT_PROC_ADDRESS(gl, ActiveTexture); + INSERT_PROC_ADDRESS(gl, AttachShader); + INSERT_PROC_ADDRESS(gl, BindAttribLocation); + INSERT_PROC_ADDRESS(gl, BindBuffer); + INSERT_PROC_ADDRESS(gl, BindFramebuffer); + INSERT_PROC_ADDRESS(gl, BindRenderbuffer); + INSERT_PROC_ADDRESS(gl, BindTexture); + INSERT_PROC_ADDRESS(gl, BlendColor); + INSERT_PROC_ADDRESS(gl, BlendEquation); + INSERT_PROC_ADDRESS(gl, BlendEquationSeparate); + INSERT_PROC_ADDRESS(gl, BlendFunc); + INSERT_PROC_ADDRESS(gl, BlendFuncSeparate); + INSERT_PROC_ADDRESS(gl, BufferData); + INSERT_PROC_ADDRESS(gl, BufferSubData); + INSERT_PROC_ADDRESS(gl, CheckFramebufferStatus); + INSERT_PROC_ADDRESS(gl, Clear); + INSERT_PROC_ADDRESS(gl, ClearColor); + INSERT_PROC_ADDRESS(gl, ClearDepthf); + INSERT_PROC_ADDRESS(gl, ClearStencil); + INSERT_PROC_ADDRESS(gl, ColorMask); + INSERT_PROC_ADDRESS(gl, CompileShader); + INSERT_PROC_ADDRESS(gl, CompressedTexImage2D); + INSERT_PROC_ADDRESS(gl, CompressedTexSubImage2D); + INSERT_PROC_ADDRESS(gl, CopyTexImage2D); + INSERT_PROC_ADDRESS(gl, CopyTexSubImage2D); + INSERT_PROC_ADDRESS(gl, CreateProgram); + INSERT_PROC_ADDRESS(gl, CreateShader); + INSERT_PROC_ADDRESS(gl, CullFace); + INSERT_PROC_ADDRESS(gl, DeleteBuffers); + INSERT_PROC_ADDRESS(gl, DeleteFramebuffers); + INSERT_PROC_ADDRESS(gl, DeleteProgram); + INSERT_PROC_ADDRESS(gl, DeleteRenderbuffers); + INSERT_PROC_ADDRESS(gl, DeleteShader); + INSERT_PROC_ADDRESS(gl, DeleteTextures); + INSERT_PROC_ADDRESS(gl, DepthFunc); + INSERT_PROC_ADDRESS(gl, DepthMask); + INSERT_PROC_ADDRESS(gl, DepthRangef); + INSERT_PROC_ADDRESS(gl, DetachShader); + INSERT_PROC_ADDRESS(gl, Disable); + INSERT_PROC_ADDRESS(gl, DisableVertexAttribArray); + INSERT_PROC_ADDRESS(gl, DrawArrays); + INSERT_PROC_ADDRESS(gl, DrawElements); + INSERT_PROC_ADDRESS(gl, Enable); + INSERT_PROC_ADDRESS(gl, EnableVertexAttribArray); + INSERT_PROC_ADDRESS(gl, Finish); + INSERT_PROC_ADDRESS(gl, Flush); + INSERT_PROC_ADDRESS(gl, FramebufferRenderbuffer); + INSERT_PROC_ADDRESS(gl, FramebufferTexture2D); + INSERT_PROC_ADDRESS(gl, FrontFace); + INSERT_PROC_ADDRESS(gl, GenBuffers); + INSERT_PROC_ADDRESS(gl, GenerateMipmap); + INSERT_PROC_ADDRESS(gl, GenFramebuffers); + INSERT_PROC_ADDRESS(gl, GenRenderbuffers); + INSERT_PROC_ADDRESS(gl, GenTextures); + INSERT_PROC_ADDRESS(gl, GetActiveAttrib); + INSERT_PROC_ADDRESS(gl, GetActiveUniform); + INSERT_PROC_ADDRESS(gl, GetAttachedShaders); + INSERT_PROC_ADDRESS(gl, GetAttribLocation); + INSERT_PROC_ADDRESS(gl, GetBooleanv); + INSERT_PROC_ADDRESS(gl, GetBufferParameteriv); + INSERT_PROC_ADDRESS(gl, GetError); + INSERT_PROC_ADDRESS(gl, GetFloatv); + INSERT_PROC_ADDRESS(gl, GetFramebufferAttachmentParameteriv); + INSERT_PROC_ADDRESS(gl, GetIntegerv); + INSERT_PROC_ADDRESS(gl, GetProgramiv); + INSERT_PROC_ADDRESS(gl, GetProgramInfoLog); + INSERT_PROC_ADDRESS(gl, GetRenderbufferParameteriv); + INSERT_PROC_ADDRESS(gl, GetShaderiv); + INSERT_PROC_ADDRESS(gl, GetShaderInfoLog); + INSERT_PROC_ADDRESS(gl, GetShaderPrecisionFormat); + INSERT_PROC_ADDRESS(gl, GetShaderSource); + INSERT_PROC_ADDRESS(gl, GetString); + INSERT_PROC_ADDRESS(gl, GetTexParameterfv); + INSERT_PROC_ADDRESS(gl, GetTexParameteriv); + INSERT_PROC_ADDRESS(gl, GetUniformfv); + INSERT_PROC_ADDRESS(gl, GetUniformiv); + INSERT_PROC_ADDRESS(gl, GetUniformLocation); + INSERT_PROC_ADDRESS(gl, GetVertexAttribfv); + INSERT_PROC_ADDRESS(gl, GetVertexAttribiv); + INSERT_PROC_ADDRESS(gl, GetVertexAttribPointerv); + INSERT_PROC_ADDRESS(gl, Hint); + INSERT_PROC_ADDRESS(gl, IsBuffer); + INSERT_PROC_ADDRESS(gl, IsEnabled); + INSERT_PROC_ADDRESS(gl, IsFramebuffer); + INSERT_PROC_ADDRESS(gl, IsProgram); + INSERT_PROC_ADDRESS(gl, IsRenderbuffer); + INSERT_PROC_ADDRESS(gl, IsShader); + INSERT_PROC_ADDRESS(gl, IsTexture); + INSERT_PROC_ADDRESS(gl, LineWidth); + INSERT_PROC_ADDRESS(gl, LinkProgram); + INSERT_PROC_ADDRESS(gl, PixelStorei); + INSERT_PROC_ADDRESS(gl, PolygonOffset); + INSERT_PROC_ADDRESS(gl, ReadPixels); + INSERT_PROC_ADDRESS(gl, ReleaseShaderCompiler); + INSERT_PROC_ADDRESS(gl, RenderbufferStorage); + INSERT_PROC_ADDRESS(gl, SampleCoverage); + INSERT_PROC_ADDRESS(gl, Scissor); + INSERT_PROC_ADDRESS(gl, ShaderBinary); + INSERT_PROC_ADDRESS(gl, ShaderSource); + INSERT_PROC_ADDRESS(gl, StencilFunc); + INSERT_PROC_ADDRESS(gl, StencilFuncSeparate); + INSERT_PROC_ADDRESS(gl, StencilMask); + INSERT_PROC_ADDRESS(gl, StencilMaskSeparate); + INSERT_PROC_ADDRESS(gl, StencilOp); + INSERT_PROC_ADDRESS(gl, StencilOpSeparate); + INSERT_PROC_ADDRESS(gl, TexImage2D); + INSERT_PROC_ADDRESS(gl, TexParameterf); + INSERT_PROC_ADDRESS(gl, TexParameterfv); + INSERT_PROC_ADDRESS(gl, TexParameteri); + INSERT_PROC_ADDRESS(gl, TexParameteriv); + INSERT_PROC_ADDRESS(gl, TexSubImage2D); + INSERT_PROC_ADDRESS(gl, Uniform1f); + INSERT_PROC_ADDRESS(gl, Uniform1fv); + INSERT_PROC_ADDRESS(gl, Uniform1i); + INSERT_PROC_ADDRESS(gl, Uniform1iv); + INSERT_PROC_ADDRESS(gl, Uniform2f); + INSERT_PROC_ADDRESS(gl, Uniform2fv); + INSERT_PROC_ADDRESS(gl, Uniform2i); + INSERT_PROC_ADDRESS(gl, Uniform2iv); + INSERT_PROC_ADDRESS(gl, Uniform3f); + INSERT_PROC_ADDRESS(gl, Uniform3fv); + INSERT_PROC_ADDRESS(gl, Uniform3i); + INSERT_PROC_ADDRESS(gl, Uniform3iv); + INSERT_PROC_ADDRESS(gl, Uniform4f); + INSERT_PROC_ADDRESS(gl, Uniform4fv); + INSERT_PROC_ADDRESS(gl, Uniform4i); + INSERT_PROC_ADDRESS(gl, Uniform4iv); + INSERT_PROC_ADDRESS(gl, UniformMatrix2fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix3fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix4fv); + INSERT_PROC_ADDRESS(gl, UseProgram); + INSERT_PROC_ADDRESS(gl, ValidateProgram); + INSERT_PROC_ADDRESS(gl, VertexAttrib1f); + INSERT_PROC_ADDRESS(gl, VertexAttrib1fv); + INSERT_PROC_ADDRESS(gl, VertexAttrib2f); + INSERT_PROC_ADDRESS(gl, VertexAttrib2fv); + INSERT_PROC_ADDRESS(gl, VertexAttrib3f); + INSERT_PROC_ADDRESS(gl, VertexAttrib3fv); + INSERT_PROC_ADDRESS(gl, VertexAttrib4f); + INSERT_PROC_ADDRESS(gl, VertexAttrib4fv); + INSERT_PROC_ADDRESS(gl, VertexAttribPointer); + INSERT_PROC_ADDRESS(gl, Viewport); + + // GL_ANGLE_framebuffer_blit + INSERT_PROC_ADDRESS(gl, BlitFramebufferANGLE); + + // GL_ANGLE_framebuffer_multisample + INSERT_PROC_ADDRESS(gl, RenderbufferStorageMultisampleANGLE); + + // GL_EXT_discard_framebuffer + INSERT_PROC_ADDRESS(gl, DiscardFramebufferEXT); + + // GL_NV_fence + INSERT_PROC_ADDRESS(gl, DeleteFencesNV); + INSERT_PROC_ADDRESS(gl, GenFencesNV); + INSERT_PROC_ADDRESS(gl, IsFenceNV); + INSERT_PROC_ADDRESS(gl, TestFenceNV); + INSERT_PROC_ADDRESS(gl, GetFenceivNV); + INSERT_PROC_ADDRESS(gl, FinishFenceNV); + INSERT_PROC_ADDRESS(gl, SetFenceNV); + + // GL_ANGLE_translated_shader_source + INSERT_PROC_ADDRESS(gl, GetTranslatedShaderSourceANGLE); + + // GL_EXT_texture_storage + INSERT_PROC_ADDRESS(gl, TexStorage2DEXT); + + // GL_EXT_robustness + INSERT_PROC_ADDRESS(gl, GetGraphicsResetStatusEXT); + INSERT_PROC_ADDRESS(gl, ReadnPixelsEXT); + INSERT_PROC_ADDRESS(gl, GetnUniformfvEXT); + INSERT_PROC_ADDRESS(gl, GetnUniformivEXT); + + // GL_EXT_occlusion_query_boolean + INSERT_PROC_ADDRESS(gl, GenQueriesEXT); + INSERT_PROC_ADDRESS(gl, DeleteQueriesEXT); + INSERT_PROC_ADDRESS(gl, IsQueryEXT); + INSERT_PROC_ADDRESS(gl, BeginQueryEXT); + INSERT_PROC_ADDRESS(gl, EndQueryEXT); + INSERT_PROC_ADDRESS(gl, GetQueryivEXT); + INSERT_PROC_ADDRESS(gl, GetQueryObjectuivEXT); + + // GL_EXT_draw_buffers + INSERT_PROC_ADDRESS(gl, DrawBuffersEXT); + + // GL_ANGLE_instanced_arrays + INSERT_PROC_ADDRESS(gl, DrawArraysInstancedANGLE); + INSERT_PROC_ADDRESS(gl, DrawElementsInstancedANGLE); + INSERT_PROC_ADDRESS(gl, VertexAttribDivisorANGLE); + + // GL_OES_get_program_binary + INSERT_PROC_ADDRESS(gl, GetProgramBinaryOES); + INSERT_PROC_ADDRESS(gl, ProgramBinaryOES); + + // GL_OES_mapbuffer + INSERT_PROC_ADDRESS(gl, MapBufferOES); + INSERT_PROC_ADDRESS(gl, UnmapBufferOES); + INSERT_PROC_ADDRESS(gl, GetBufferPointervOES); + + // GL_EXT_map_buffer_range + INSERT_PROC_ADDRESS(gl, MapBufferRangeEXT); + INSERT_PROC_ADDRESS(gl, FlushMappedBufferRangeEXT); + + // GL_EXT_debug_marker + INSERT_PROC_ADDRESS(gl, InsertEventMarkerEXT); + INSERT_PROC_ADDRESS(gl, PushGroupMarkerEXT); + INSERT_PROC_ADDRESS(gl, PopGroupMarkerEXT); + + // GL_OES_EGL_image + INSERT_PROC_ADDRESS(gl, EGLImageTargetTexture2DOES); + INSERT_PROC_ADDRESS(gl, EGLImageTargetRenderbufferStorageOES); + + // GL_OES_vertex_array_object + INSERT_PROC_ADDRESS(gl, BindVertexArrayOES); + INSERT_PROC_ADDRESS(gl, DeleteVertexArraysOES); + INSERT_PROC_ADDRESS(gl, GenVertexArraysOES); + INSERT_PROC_ADDRESS(gl, IsVertexArrayOES); + + // GL_KHR_debug + INSERT_PROC_ADDRESS(gl, DebugMessageControlKHR); + INSERT_PROC_ADDRESS(gl, DebugMessageInsertKHR); + INSERT_PROC_ADDRESS(gl, DebugMessageCallbackKHR); + INSERT_PROC_ADDRESS(gl, GetDebugMessageLogKHR); + INSERT_PROC_ADDRESS(gl, PushDebugGroupKHR); + INSERT_PROC_ADDRESS(gl, PopDebugGroupKHR); + INSERT_PROC_ADDRESS(gl, ObjectLabelKHR); + INSERT_PROC_ADDRESS(gl, GetObjectLabelKHR); + INSERT_PROC_ADDRESS(gl, ObjectPtrLabelKHR); + INSERT_PROC_ADDRESS(gl, GetObjectPtrLabelKHR); + INSERT_PROC_ADDRESS(gl, GetPointervKHR); + + // GLES3 core + INSERT_PROC_ADDRESS(gl, ReadBuffer); + INSERT_PROC_ADDRESS(gl, DrawRangeElements); + INSERT_PROC_ADDRESS(gl, TexImage3D); + INSERT_PROC_ADDRESS(gl, TexSubImage3D); + INSERT_PROC_ADDRESS(gl, CopyTexSubImage3D); + INSERT_PROC_ADDRESS(gl, CompressedTexImage3D); + INSERT_PROC_ADDRESS(gl, CompressedTexSubImage3D); + INSERT_PROC_ADDRESS(gl, GenQueries); + INSERT_PROC_ADDRESS(gl, DeleteQueries); + INSERT_PROC_ADDRESS(gl, IsQuery); + INSERT_PROC_ADDRESS(gl, BeginQuery); + INSERT_PROC_ADDRESS(gl, EndQuery); + INSERT_PROC_ADDRESS(gl, GetQueryiv); + INSERT_PROC_ADDRESS(gl, GetQueryObjectuiv); + INSERT_PROC_ADDRESS(gl, UnmapBuffer); + INSERT_PROC_ADDRESS(gl, GetBufferPointerv); + INSERT_PROC_ADDRESS(gl, DrawBuffers); + INSERT_PROC_ADDRESS(gl, UniformMatrix2x3fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix3x2fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix2x4fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix4x2fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix3x4fv); + INSERT_PROC_ADDRESS(gl, UniformMatrix4x3fv); + INSERT_PROC_ADDRESS(gl, BlitFramebuffer); + INSERT_PROC_ADDRESS(gl, RenderbufferStorageMultisample); + INSERT_PROC_ADDRESS(gl, FramebufferTextureLayer); + INSERT_PROC_ADDRESS(gl, MapBufferRange); + INSERT_PROC_ADDRESS(gl, FlushMappedBufferRange); + INSERT_PROC_ADDRESS(gl, BindVertexArray); + INSERT_PROC_ADDRESS(gl, DeleteVertexArrays); + INSERT_PROC_ADDRESS(gl, GenVertexArrays); + INSERT_PROC_ADDRESS(gl, IsVertexArray); + INSERT_PROC_ADDRESS(gl, GetIntegeri_v); + INSERT_PROC_ADDRESS(gl, BeginTransformFeedback); + INSERT_PROC_ADDRESS(gl, EndTransformFeedback); + INSERT_PROC_ADDRESS(gl, BindBufferRange); + INSERT_PROC_ADDRESS(gl, BindBufferBase); + INSERT_PROC_ADDRESS(gl, TransformFeedbackVaryings); + INSERT_PROC_ADDRESS(gl, GetTransformFeedbackVarying); + INSERT_PROC_ADDRESS(gl, VertexAttribIPointer); + INSERT_PROC_ADDRESS(gl, GetVertexAttribIiv); + INSERT_PROC_ADDRESS(gl, GetVertexAttribIuiv); + INSERT_PROC_ADDRESS(gl, VertexAttribI4i); + INSERT_PROC_ADDRESS(gl, VertexAttribI4ui); + INSERT_PROC_ADDRESS(gl, VertexAttribI4iv); + INSERT_PROC_ADDRESS(gl, VertexAttribI4uiv); + INSERT_PROC_ADDRESS(gl, GetUniformuiv); + INSERT_PROC_ADDRESS(gl, GetFragDataLocation); + INSERT_PROC_ADDRESS(gl, Uniform1ui); + INSERT_PROC_ADDRESS(gl, Uniform2ui); + INSERT_PROC_ADDRESS(gl, Uniform3ui); + INSERT_PROC_ADDRESS(gl, Uniform4ui); + INSERT_PROC_ADDRESS(gl, Uniform1uiv); + INSERT_PROC_ADDRESS(gl, Uniform2uiv); + INSERT_PROC_ADDRESS(gl, Uniform3uiv); + INSERT_PROC_ADDRESS(gl, Uniform4uiv); + INSERT_PROC_ADDRESS(gl, ClearBufferiv); + INSERT_PROC_ADDRESS(gl, ClearBufferuiv); + INSERT_PROC_ADDRESS(gl, ClearBufferfv); + INSERT_PROC_ADDRESS(gl, ClearBufferfi); + INSERT_PROC_ADDRESS(gl, GetStringi); + INSERT_PROC_ADDRESS(gl, CopyBufferSubData); + INSERT_PROC_ADDRESS(gl, GetUniformIndices); + INSERT_PROC_ADDRESS(gl, GetActiveUniformsiv); + INSERT_PROC_ADDRESS(gl, GetUniformBlockIndex); + INSERT_PROC_ADDRESS(gl, GetActiveUniformBlockiv); + INSERT_PROC_ADDRESS(gl, GetActiveUniformBlockName); + INSERT_PROC_ADDRESS(gl, UniformBlockBinding); + INSERT_PROC_ADDRESS(gl, DrawArraysInstanced); + INSERT_PROC_ADDRESS(gl, DrawElementsInstanced); + map["glFenceSync"] = + reinterpret_cast<__eglMustCastToProperFunctionPointerType>(gl::FenceSync_); + INSERT_PROC_ADDRESS(gl, IsSync); + INSERT_PROC_ADDRESS(gl, DeleteSync); + INSERT_PROC_ADDRESS(gl, ClientWaitSync); + INSERT_PROC_ADDRESS(gl, WaitSync); + INSERT_PROC_ADDRESS(gl, GetInteger64v); + INSERT_PROC_ADDRESS(gl, GetSynciv); + INSERT_PROC_ADDRESS(gl, GetInteger64i_v); + INSERT_PROC_ADDRESS(gl, GetBufferParameteri64v); + INSERT_PROC_ADDRESS(gl, GenSamplers); + INSERT_PROC_ADDRESS(gl, DeleteSamplers); + INSERT_PROC_ADDRESS(gl, IsSampler); + INSERT_PROC_ADDRESS(gl, BindSampler); + INSERT_PROC_ADDRESS(gl, SamplerParameteri); + INSERT_PROC_ADDRESS(gl, SamplerParameteriv); + INSERT_PROC_ADDRESS(gl, SamplerParameterf); + INSERT_PROC_ADDRESS(gl, SamplerParameterfv); + INSERT_PROC_ADDRESS(gl, GetSamplerParameteriv); + INSERT_PROC_ADDRESS(gl, GetSamplerParameterfv); + INSERT_PROC_ADDRESS(gl, VertexAttribDivisor); + INSERT_PROC_ADDRESS(gl, BindTransformFeedback); + INSERT_PROC_ADDRESS(gl, DeleteTransformFeedbacks); + INSERT_PROC_ADDRESS(gl, GenTransformFeedbacks); + INSERT_PROC_ADDRESS(gl, IsTransformFeedback); + INSERT_PROC_ADDRESS(gl, PauseTransformFeedback); + INSERT_PROC_ADDRESS(gl, ResumeTransformFeedback); + INSERT_PROC_ADDRESS(gl, GetProgramBinary); + INSERT_PROC_ADDRESS(gl, ProgramBinary); + INSERT_PROC_ADDRESS(gl, ProgramParameteri); + INSERT_PROC_ADDRESS(gl, InvalidateFramebuffer); + INSERT_PROC_ADDRESS(gl, InvalidateSubFramebuffer); + INSERT_PROC_ADDRESS(gl, TexStorage2D); + INSERT_PROC_ADDRESS(gl, TexStorage3D); + INSERT_PROC_ADDRESS(gl, GetInternalformativ); + + // EGL 1.0 + INSERT_PROC_ADDRESS(egl, ChooseConfig); + INSERT_PROC_ADDRESS(egl, CopyBuffers); + INSERT_PROC_ADDRESS(egl, CreateContext); + INSERT_PROC_ADDRESS(egl, CreatePbufferSurface); + INSERT_PROC_ADDRESS(egl, CreatePixmapSurface); + INSERT_PROC_ADDRESS(egl, CreateWindowSurface); + INSERT_PROC_ADDRESS(egl, DestroyContext); + INSERT_PROC_ADDRESS(egl, DestroySurface); + INSERT_PROC_ADDRESS(egl, GetConfigAttrib); + INSERT_PROC_ADDRESS(egl, GetConfigs); + INSERT_PROC_ADDRESS(egl, GetCurrentDisplay); + INSERT_PROC_ADDRESS(egl, GetCurrentSurface); + INSERT_PROC_ADDRESS(egl, GetDisplay); + INSERT_PROC_ADDRESS(egl, GetError); + INSERT_PROC_ADDRESS(egl, GetProcAddress); + INSERT_PROC_ADDRESS(egl, Initialize); + INSERT_PROC_ADDRESS(egl, MakeCurrent); + INSERT_PROC_ADDRESS(egl, QueryContext); + INSERT_PROC_ADDRESS(egl, QueryString); + INSERT_PROC_ADDRESS(egl, QuerySurface); + INSERT_PROC_ADDRESS(egl, SwapBuffers); + INSERT_PROC_ADDRESS(egl, Terminate); + INSERT_PROC_ADDRESS(egl, WaitGL); + INSERT_PROC_ADDRESS(egl, WaitNative); + + // EGL 1.1 + INSERT_PROC_ADDRESS(egl, BindTexImage); + INSERT_PROC_ADDRESS(egl, ReleaseTexImage); + INSERT_PROC_ADDRESS(egl, SurfaceAttrib); + INSERT_PROC_ADDRESS(egl, SwapInterval); + + // EGL 1.2 + INSERT_PROC_ADDRESS(egl, BindAPI); + INSERT_PROC_ADDRESS(egl, QueryAPI); + INSERT_PROC_ADDRESS(egl, CreatePbufferFromClientBuffer); + INSERT_PROC_ADDRESS(egl, ReleaseThread); + INSERT_PROC_ADDRESS(egl, WaitClient); + + // EGL 1.4 + INSERT_PROC_ADDRESS(egl, GetCurrentContext); + + // EGL 1.5 + INSERT_PROC_ADDRESS(egl, CreateSync); + INSERT_PROC_ADDRESS(egl, DestroySync); + INSERT_PROC_ADDRESS(egl, ClientWaitSync); + INSERT_PROC_ADDRESS(egl, GetSyncAttrib); + INSERT_PROC_ADDRESS(egl, CreateImage); + INSERT_PROC_ADDRESS(egl, DestroyImage); + INSERT_PROC_ADDRESS(egl, GetPlatformDisplay); + INSERT_PROC_ADDRESS(egl, CreatePlatformWindowSurface); + INSERT_PROC_ADDRESS(egl, CreatePlatformPixmapSurface); + INSERT_PROC_ADDRESS(egl, WaitSync); + + // EGL_ANGLE_query_surface_pointer + INSERT_PROC_ADDRESS(egl, QuerySurfacePointerANGLE); + + // EGL_NV_post_sub_buffer + INSERT_PROC_ADDRESS(egl, PostSubBufferNV); + + // EGL_EXT_platform_base + INSERT_PROC_ADDRESS(egl, GetPlatformDisplayEXT); + + // EGL_EXT_device_query + INSERT_PROC_ADDRESS(egl, QueryDisplayAttribEXT); + INSERT_PROC_ADDRESS(egl, QueryDeviceAttribEXT); + INSERT_PROC_ADDRESS(egl, QueryDeviceStringEXT); + + // EGL_KHR_image_base/EGL_KHR_image + INSERT_PROC_ADDRESS(egl, CreateImageKHR); + INSERT_PROC_ADDRESS(egl, DestroyImageKHR); + + // EGL_EXT_device_creation + INSERT_PROC_ADDRESS(egl, CreateDeviceANGLE); + INSERT_PROC_ADDRESS(egl, ReleaseDeviceANGLE); + +#undef INSERT_PROC_ADDRESS + return map; }; - static const Extension extensions[] = - { - { "eglQuerySurfacePointerANGLE", (__eglMustCastToProperFunctionPointerType)QuerySurfacePointerANGLE }, - { "eglPostSubBufferNV", (__eglMustCastToProperFunctionPointerType)PostSubBufferNV }, - { "eglGetPlatformDisplayEXT", (__eglMustCastToProperFunctionPointerType)GetPlatformDisplayEXT }, - { "glBlitFramebufferANGLE", (__eglMustCastToProperFunctionPointerType)gl::BlitFramebufferANGLE }, - { "glRenderbufferStorageMultisampleANGLE", (__eglMustCastToProperFunctionPointerType)gl::RenderbufferStorageMultisampleANGLE }, - { "glDeleteFencesNV", (__eglMustCastToProperFunctionPointerType)gl::DeleteFencesNV }, - { "glGenFencesNV", (__eglMustCastToProperFunctionPointerType)gl::GenFencesNV }, - { "glIsFenceNV", (__eglMustCastToProperFunctionPointerType)gl::IsFenceNV }, - { "glTestFenceNV", (__eglMustCastToProperFunctionPointerType)gl::TestFenceNV }, - { "glGetFenceivNV", (__eglMustCastToProperFunctionPointerType)gl::GetFenceivNV }, - { "glFinishFenceNV", (__eglMustCastToProperFunctionPointerType)gl::FinishFenceNV }, - { "glSetFenceNV", (__eglMustCastToProperFunctionPointerType)gl::SetFenceNV }, - { "glGetTranslatedShaderSourceANGLE", (__eglMustCastToProperFunctionPointerType)gl::GetTranslatedShaderSourceANGLE }, - { "glTexStorage2DEXT", (__eglMustCastToProperFunctionPointerType)gl::TexStorage2DEXT }, - { "glGetGraphicsResetStatusEXT", (__eglMustCastToProperFunctionPointerType)gl::GetGraphicsResetStatusEXT }, - { "glReadnPixelsEXT", (__eglMustCastToProperFunctionPointerType)gl::ReadnPixelsEXT }, - { "glGetnUniformfvEXT", (__eglMustCastToProperFunctionPointerType)gl::GetnUniformfvEXT }, - { "glGetnUniformivEXT", (__eglMustCastToProperFunctionPointerType)gl::GetnUniformivEXT }, - { "glGenQueriesEXT", (__eglMustCastToProperFunctionPointerType)gl::GenQueriesEXT }, - { "glDeleteQueriesEXT", (__eglMustCastToProperFunctionPointerType)gl::DeleteQueriesEXT }, - { "glIsQueryEXT", (__eglMustCastToProperFunctionPointerType)gl::IsQueryEXT }, - { "glBeginQueryEXT", (__eglMustCastToProperFunctionPointerType)gl::BeginQueryEXT }, - { "glEndQueryEXT", (__eglMustCastToProperFunctionPointerType)gl::EndQueryEXT }, - { "glGetQueryivEXT", (__eglMustCastToProperFunctionPointerType)gl::GetQueryivEXT }, - { "glGetQueryObjectuivEXT", (__eglMustCastToProperFunctionPointerType)gl::GetQueryObjectuivEXT }, - { "glDrawBuffersEXT", (__eglMustCastToProperFunctionPointerType)gl::DrawBuffersEXT }, - { "glVertexAttribDivisorANGLE", (__eglMustCastToProperFunctionPointerType)gl::VertexAttribDivisorANGLE }, - { "glDrawArraysInstancedANGLE", (__eglMustCastToProperFunctionPointerType)gl::DrawArraysInstancedANGLE }, - { "glDrawElementsInstancedANGLE", (__eglMustCastToProperFunctionPointerType)gl::DrawElementsInstancedANGLE }, - { "glGetProgramBinaryOES", (__eglMustCastToProperFunctionPointerType)gl::GetProgramBinaryOES }, - { "glProgramBinaryOES", (__eglMustCastToProperFunctionPointerType)gl::ProgramBinaryOES }, - { "glGetBufferPointervOES", (__eglMustCastToProperFunctionPointerType)gl::GetBufferPointervOES }, - { "glMapBufferOES", (__eglMustCastToProperFunctionPointerType)gl::MapBufferOES }, - { "glUnmapBufferOES", (__eglMustCastToProperFunctionPointerType)gl::UnmapBufferOES }, - { "glMapBufferRangeEXT", (__eglMustCastToProperFunctionPointerType)gl::MapBufferRangeEXT }, - { "glFlushMappedBufferRangeEXT", (__eglMustCastToProperFunctionPointerType)gl::FlushMappedBufferRangeEXT }, - { "", NULL }, - }; + static const ProcAddressMap procAddressMap = generateProcAddressMap(); - for (const Extension *extension = &extensions[0]; extension->address != nullptr; extension++) + auto iter = procAddressMap.find(procname); + if (iter != procAddressMap.end()) { - if (strcmp(procname, extension->name) == 0) - { - return reinterpret_cast<__eglMustCastToProperFunctionPointerType>(extension->address); - } + return iter->second; + } + else + { + return nullptr; } - - return NULL; } } diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.cpp b/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.cpp index 02b663192d..6c7e2ffc3d 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.cpp +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.cpp @@ -10,6 +10,7 @@ #include "libGLESv2/global_state.h" #include "libANGLE/Display.h" +#include "libANGLE/Device.h" #include "libANGLE/Surface.h" #include "libANGLE/validationEGL.h" @@ -58,7 +59,13 @@ EGLBoolean EGLAPIENTRY QuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surfa return EGL_FALSE; } break; - + case EGL_DXGI_KEYED_MUTEX_ANGLE: + if (!display->getExtensions().keyedMutex) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); + return EGL_FALSE; + } + break; default: SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); return EGL_FALSE; @@ -140,136 +147,412 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp return EGL_NO_DISPLAY; } break; - + case EGL_PLATFORM_DEVICE_EXT: + if (!clientExtensions.platformDevice) + { + SetGlobalError(Error(EGL_BAD_PARAMETER, "Platform Device extension is not active")); + return EGL_NO_DISPLAY; + } + break; default: SetGlobalError(Error(EGL_BAD_CONFIG)); return EGL_NO_DISPLAY; } - EGLint platformType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE; - EGLint deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE; - bool majorVersionSpecified = false; - bool minorVersionSpecified = false; - bool enableAutoTrimSpecified = false; - - if (attrib_list) + if (platform == EGL_PLATFORM_ANGLE_ANGLE) { - for (const EGLint *curAttrib = attrib_list; curAttrib[0] != EGL_NONE; curAttrib += 2) + EGLint platformType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE; + EGLint deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE; + bool majorVersionSpecified = false; + bool minorVersionSpecified = false; + bool enableAutoTrimSpecified = false; + bool deviceTypeSpecified = false; + bool presentPathSpecified = false; + + if (attrib_list) { - switch (curAttrib[0]) + for (const EGLint *curAttrib = attrib_list; curAttrib[0] != EGL_NONE; curAttrib += 2) { - case EGL_PLATFORM_ANGLE_TYPE_ANGLE: - switch (curAttrib[1]) + switch (curAttrib[0]) { - case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE: - break; - - case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE: - case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE: - if (!clientExtensions.platformANGLED3D) + case EGL_PLATFORM_ANGLE_TYPE_ANGLE: + switch (curAttrib[1]) { + case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE: + break; + + case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE: + case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE: + if (!clientExtensions.platformANGLED3D) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); + return EGL_NO_DISPLAY; + } + break; + + case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE: + case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE: + if (!clientExtensions.platformANGLEOpenGL) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); + return EGL_NO_DISPLAY; + } + break; + + default: SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); return EGL_NO_DISPLAY; } + platformType = curAttrib[1]; break; - case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE: - case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE: - if (!clientExtensions.platformANGLEOpenGL) + case EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE: + if (curAttrib[1] != EGL_DONT_CARE) + { + majorVersionSpecified = true; + } + break; + + case EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE: + if (curAttrib[1] != EGL_DONT_CARE) + { + minorVersionSpecified = true; + } + break; + + case EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE: + switch (curAttrib[1]) { + case EGL_TRUE: + case EGL_FALSE: + break; + default: SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); return EGL_NO_DISPLAY; } + enableAutoTrimSpecified = true; break; - default: - SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); - return EGL_NO_DISPLAY; - } - platformType = curAttrib[1]; - break; + case EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE: + if (!clientExtensions.experimentalPresentPath) + { + SetGlobalError( + Error(EGL_BAD_ATTRIBUTE, + "EGL_ANGLE_experimental_present_path extension not active")); + return EGL_NO_DISPLAY; + } + + switch (curAttrib[1]) + { + case EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE: + case EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE: + break; + default: + SetGlobalError( + Error(EGL_BAD_ATTRIBUTE, + "Invalid value for EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE")); + return EGL_NO_DISPLAY; + } + presentPathSpecified = true; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE: + switch (curAttrib[1]) + { + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE: + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE: + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE: + deviceTypeSpecified = true; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE: + // This is a hidden option, accepted by the OpenGL back-end. + break; + + default: + SetGlobalError(Error(EGL_BAD_ATTRIBUTE, + "Invalid value for " + "EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE " + "attrib")); + return EGL_NO_DISPLAY; + } + deviceType = curAttrib[1]; + break; - case EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE: - if (curAttrib[1] != EGL_DONT_CARE) - { - majorVersionSpecified = true; + default: + break; } - break; + } + } - case EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE: - if (curAttrib[1] != EGL_DONT_CARE) - { - minorVersionSpecified = true; - } - break; + if (!majorVersionSpecified && minorVersionSpecified) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); + return EGL_NO_DISPLAY; + } - case EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE: - switch (curAttrib[1]) - { - case EGL_TRUE: - case EGL_FALSE: - break; - default: - SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); - return EGL_NO_DISPLAY; - } - enableAutoTrimSpecified = true; - break; + if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE && + platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) + { + SetGlobalError( + Error(EGL_BAD_ATTRIBUTE, + "EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE requires a device type of " + "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.")); + return EGL_NO_DISPLAY; + } - case EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE: - if (!clientExtensions.platformANGLED3D) - { - SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); - return EGL_NO_DISPLAY; - } + if (enableAutoTrimSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) + { + SetGlobalError( + Error(EGL_BAD_ATTRIBUTE, + "EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE requires a device type of " + "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.")); + return EGL_NO_DISPLAY; + } - switch (curAttrib[1]) - { - case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE: - case EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE: - case EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE: - case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE: - break; + if (presentPathSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE, + "EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE requires a device type of " + "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.")); + return EGL_NO_DISPLAY; + } - default: - SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); - return EGL_NO_DISPLAY; - } - deviceType = curAttrib[1]; - break; + if (deviceTypeSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE && + platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) + { + SetGlobalError( + Error(EGL_BAD_ATTRIBUTE, + "EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE requires a device type of " + "EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE or EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE.")); + return EGL_NO_DISPLAY; + } - default: - break; - } + SetGlobalError(Error(EGL_SUCCESS)); + return Display::GetDisplayFromAttribs(native_display, AttributeMap(attrib_list)); + } + else if (platform == EGL_PLATFORM_DEVICE_EXT) + { + Device *eglDevice = reinterpret_cast<Device *>(native_display); + if (eglDevice == nullptr || !Device::IsValidDevice(eglDevice)) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE, + "native_display should be a valid EGL device if platform equals " + "EGL_PLATFORM_DEVICE_EXT")); + return EGL_NO_DISPLAY; } + + SetGlobalError(Error(EGL_SUCCESS)); + return Display::GetDisplayFromDevice(native_display); + } + else + { + UNREACHABLE(); + return EGL_NO_DISPLAY; + } +} + +// EGL_EXT_device_query +EGLBoolean EGLAPIENTRY QueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value) +{ + EVENT("(EGLDeviceEXT device = 0x%0.8p, EGLint attribute = %d, EGLAttrib *value = 0x%0.8p)", + device, attribute, value); + + Device *dev = static_cast<Device*>(device); + if (dev == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(dev)) + { + SetGlobalError(Error(EGL_BAD_ACCESS)); + return EGL_FALSE; + } + + // If the device was created by (and is owned by) a display, and that display doesn't support + // device querying, then this call should fail + Display *owningDisplay = dev->getOwningDisplay(); + if (owningDisplay != nullptr && !owningDisplay->getExtensions().deviceQuery) + { + SetGlobalError(Error(EGL_BAD_ACCESS, + "Device wasn't created using eglCreateDeviceANGLE, and the Display " + "that created it doesn't support device querying")); + return EGL_FALSE; } - if (!majorVersionSpecified && minorVersionSpecified) + Error error(EGL_SUCCESS); + + // validate the attribute parameter + switch (attribute) { + case EGL_D3D11_DEVICE_ANGLE: + case EGL_D3D9_DEVICE_ANGLE: + if (!dev->getExtensions().deviceD3D || dev->getType() != attribute) + { + SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); + return EGL_FALSE; + } + error = dev->getDevice(value); + break; + default: SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); - return EGL_NO_DISPLAY; + return EGL_FALSE; } - if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE && - platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) + SetGlobalError(error); + return (error.isError() ? EGL_FALSE : EGL_TRUE); +} + +// EGL_EXT_device_query +const char * EGLAPIENTRY QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name) +{ + EVENT("(EGLDeviceEXT device = 0x%0.8p, EGLint name = %d)", + device, name); + + Device *dev = static_cast<Device*>(device); + if (dev == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(dev)) { - SetGlobalError(Error(EGL_BAD_ATTRIBUTE, "EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE requires a device type of " - "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.")); - return EGL_NO_DISPLAY; + SetGlobalError(Error(EGL_BAD_DEVICE_EXT)); + return nullptr; } - if (enableAutoTrimSpecified && - platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) + const char *result; + switch (name) { - SetGlobalError(Error(EGL_BAD_ATTRIBUTE, "EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE requires a device type of " - "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.")); - return EGL_NO_DISPLAY; + case EGL_EXTENSIONS: + result = dev->getExtensionString().c_str(); + break; + default: + SetGlobalError(Error(EGL_BAD_DEVICE_EXT)); + return nullptr; } SetGlobalError(Error(EGL_SUCCESS)); + return result; +} + +// EGL_EXT_device_query +EGLBoolean EGLAPIENTRY QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value) +{ + EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint attribute = %d, EGLAttrib *value = 0x%0.8p)", + dpy, attribute, value); + + Display *display = static_cast<Display*>(dpy); + Error error(EGL_SUCCESS); + + if (!display->getExtensions().deviceQuery) + { + SetGlobalError(Error(EGL_BAD_ACCESS)); + return EGL_FALSE; + } + + // validate the attribute parameter + switch (attribute) + { + case EGL_DEVICE_EXT: + *value = reinterpret_cast<EGLAttrib>(display->getDevice()); + break; + + default: + SetGlobalError(Error(EGL_BAD_ATTRIBUTE)); + return EGL_FALSE; + } + + SetGlobalError(error); + return (error.isError() ? EGL_FALSE : EGL_TRUE); +} + +ANGLE_EXPORT EGLImageKHR EGLAPIENTRY CreateImageKHR(EGLDisplay dpy, + EGLContext ctx, + EGLenum target, + EGLClientBuffer buffer, + const EGLint *attrib_list) +{ + EVENT( + "(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLenum target = 0x%X, " + "EGLClientBuffer buffer = 0x%0.8p, const EGLAttrib *attrib_list = 0x%0.8p)", + dpy, ctx, target, buffer, attrib_list); + + Display *display = static_cast<Display *>(dpy); + gl::Context *context = static_cast<gl::Context *>(ctx); + AttributeMap attributes(attrib_list); + + Error error = ValidateCreateImageKHR(display, context, target, buffer, attributes); + if (error.isError()) + { + SetGlobalError(error); + return EGL_NO_IMAGE; + } + + Image *image = nullptr; + error = display->createImage(context, target, buffer, attributes, &image); + if (error.isError()) + { + SetGlobalError(error); + return EGL_NO_IMAGE; + } + + return static_cast<EGLImage>(image); +} + +ANGLE_EXPORT EGLBoolean EGLAPIENTRY DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) +{ + EVENT("(EGLDisplay dpy = 0x%0.8p, EGLImage image = 0x%0.8p)", dpy, image); + + Display *display = static_cast<Display *>(dpy); + Image *img = static_cast<Image *>(image); + + Error error = ValidateDestroyImageKHR(display, img); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } + + display->destroyImage(img); + + return EGL_TRUE; +} + +ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY CreateDeviceANGLE(EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list) +{ + EVENT( + "(EGLint device_type = %d, void* native_device = 0x%0.8p, const EGLAttrib* attrib_list = " + "0x%0.8p)", + device_type, native_device, attrib_list); + + Error error = ValidateCreateDeviceANGLE(device_type, native_device, attrib_list); + if (error.isError()) + { + SetGlobalError(error); + return EGL_NO_DEVICE_EXT; + } + + Device *device = nullptr; + error = Device::CreateDevice(native_device, device_type, &device); + if (error.isError()) + { + ASSERT(device == nullptr); + SetGlobalError(error); + return EGL_NO_DEVICE_EXT; + } - EGLNativeDisplayType displayId = static_cast<EGLNativeDisplayType>(native_display); - return Display::getDisplay(displayId, AttributeMap(attrib_list)); + return device; } +ANGLE_EXPORT EGLBoolean EGLAPIENTRY ReleaseDeviceANGLE(EGLDeviceEXT device) +{ + EVENT("(EGLDeviceEXT device = 0x%0.8p)", device); + + Device *dev = static_cast<Device *>(device); + + Error error = ValidateReleaseDeviceANGLE(dev); + if (error.isError()) + { + SetGlobalError(error); + return EGL_FALSE; + } + + SafeDelete(dev); + + return EGL_TRUE; +} } diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.h b/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.h index 9de1027082..d64fa6e483 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.h +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_egl_ext.h @@ -25,6 +25,24 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY PostSubBufferNV(EGLDisplay dpy, EGLSurface s // EGL_EXT_platform_base ANGLE_EXPORT EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list); +// EGL_EXT_device_query +ANGLE_EXPORT EGLBoolean EGLAPIENTRY QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY QueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value); +ANGLE_EXPORT const char * EGLAPIENTRY QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name); + +// EGL_KHR_image_base/EGL_KHR_image +ANGLE_EXPORT EGLImageKHR EGLAPIENTRY CreateImageKHR(EGLDisplay dpy, + EGLContext ctx, + EGLenum target, + EGLClientBuffer buffer, + const EGLint *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image); + +// EGL_EXT_device_creation +ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY CreateDeviceANGLE(EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY ReleaseDeviceANGLE(EGLDeviceEXT device); } #endif // LIBGLESV2_ENTRYPOINTSEGLEXT_H_ diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0.cpp b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0.cpp index 6d3089ba4f..336b320ba5 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0.cpp +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0.cpp @@ -59,35 +59,16 @@ void GL_APIENTRY AttachShader(GLuint program, GLuint shader) Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); - Shader *shaderObject = context->getShader(shader); - + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - if (context->getProgram(shader)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (!programObject->attachShader(shaderObject)) @@ -111,20 +92,11 @@ void GL_APIENTRY BindAttribLocation(GLuint program, GLuint index, const GLchar* return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (strncmp(name, "gl_", 3) == 0) @@ -444,17 +416,25 @@ void GL_APIENTRY BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha return; } - bool constantColorUsed = (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR || - dstRGB == GL_CONSTANT_COLOR || dstRGB == GL_ONE_MINUS_CONSTANT_COLOR); + if (context->getLimitations().noSimultaneousConstantColorAndAlphaBlendFunc) + { + bool constantColorUsed = + (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR || + dstRGB == GL_CONSTANT_COLOR || dstRGB == GL_ONE_MINUS_CONSTANT_COLOR); - bool constantAlphaUsed = (srcRGB == GL_CONSTANT_ALPHA || srcRGB == GL_ONE_MINUS_CONSTANT_ALPHA || - dstRGB == GL_CONSTANT_ALPHA || dstRGB == GL_ONE_MINUS_CONSTANT_ALPHA); + bool constantAlphaUsed = + (srcRGB == GL_CONSTANT_ALPHA || srcRGB == GL_ONE_MINUS_CONSTANT_ALPHA || + dstRGB == GL_CONSTANT_ALPHA || dstRGB == GL_ONE_MINUS_CONSTANT_ALPHA); - if (constantColorUsed && constantAlphaUsed) - { - ERR("Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA and GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR invalid under WebGL"); - context->recordError(Error(GL_INVALID_OPERATION)); - return; + if (constantColorUsed && constantAlphaUsed) + { + ERR( + "Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA and " + "GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR not supported by this " + "implementation."); + context->recordError(Error(GL_INVALID_OPERATION)); + return; + } } context->getState().setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha); @@ -537,11 +517,6 @@ void GL_APIENTRY BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, return; } - if (data == NULL) - { - return; - } - if (!ValidBufferTarget(context, target)) { context->recordError(Error(GL_INVALID_ENUM)); @@ -575,6 +550,11 @@ void GL_APIENTRY BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, return; } + if (data == NULL) + { + return; + } + Error error = buffer->bufferSubData(data, size, offset); if (error.isError()) { @@ -613,27 +593,12 @@ void GL_APIENTRY Clear(GLbitfield mask) Context *context = GetValidGlobalContext(); if (context) { - Framebuffer *framebufferObject = context->getState().getDrawFramebuffer(); - ASSERT(framebufferObject); - - if (framebufferObject->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE) - { - context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION)); - return; - } - - if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0) + if (!context->skipValidation() && !ValidateClear(context, mask)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } - Error error = framebufferObject->clear(context->getData(), mask); - if (error.isError()) - { - context->recordError(error); - return; - } + context->clear(mask); } } @@ -690,22 +655,11 @@ void GL_APIENTRY CompileShader(GLuint shader) Context *context = GetValidGlobalContext(); if (context) { - Shader *shaderObject = context->getShader(shader); - + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - if (context->getProgram(shader)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } - shaderObject->compile(context->getCompiler()); } } @@ -728,8 +682,9 @@ void GL_APIENTRY CompressedTexImage2D(GLenum target, GLint level, GLenum interna } if (context->getClientVersion() >= 3 && - !ValidateES3TexImageParameters(context, target, level, internalformat, true, false, - 0, 0, 0, width, height, 1, border, GL_NONE, GL_NONE, data)) + !ValidateES3TexImage2DParameters(context, target, level, internalformat, true, false, 0, + 0, 0, width, height, 1, border, GL_NONE, GL_NONE, + data)) { return; } @@ -743,8 +698,9 @@ void GL_APIENTRY CompressedTexImage2D(GLenum target, GLint level, GLenum interna Extents size(width, height, 1); Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); - Error error = texture->setCompressedImage(target, level, internalformat, size, context->getState().getUnpackState(), - reinterpret_cast<const uint8_t *>(data)); + Error error = + texture->setCompressedImage(context, target, level, internalformat, size, imageSize, + reinterpret_cast<const uint8_t *>(data)); if (error.isError()) { context->recordError(error); @@ -772,8 +728,9 @@ void GL_APIENTRY CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffs } if (context->getClientVersion() >= 3 && - !ValidateES3TexImageParameters(context, target, level, GL_NONE, true, true, - xoffset, yoffset, 0, width, height, 1, 0, GL_NONE, GL_NONE, data)) + !ValidateES3TexImage2DParameters(context, target, level, GL_NONE, true, true, xoffset, + yoffset, 0, width, height, 1, 0, GL_NONE, GL_NONE, + data)) { return; } @@ -785,11 +742,11 @@ void GL_APIENTRY CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffs return; } - Box area(xoffset, yoffset, 0, width, height, 1); Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); - Error error = texture->setCompressedSubImage(target, level, area, format, context->getState().getUnpackState(), - reinterpret_cast<const uint8_t *>(data)); + Error error = + texture->setCompressedSubImage(context, target, level, area, format, imageSize, + reinterpret_cast<const uint8_t *>(data)); if (error.isError()) { context->recordError(error); @@ -807,30 +764,13 @@ void GL_APIENTRY CopyTexImage2D(GLenum target, GLint level, GLenum internalforma Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3 && - !ValidateES2CopyTexImageParameters(context, target, level, internalformat, false, - 0, 0, x, y, width, height, border)) - { - return; - } - - if (context->getClientVersion() >= 3 && - !ValidateES3CopyTexImageParameters(context, target, level, internalformat, false, - 0, 0, 0, x, y, width, height, border)) - { - return; - } - - Rectangle sourceArea(x, y, width, height); - - const Framebuffer *framebuffer = context->getState().getReadFramebuffer(); - Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); - Error error = texture->copyImage(target, level, sourceArea, internalformat, framebuffer); - if (error.isError()) + if (!context->skipValidation() && + !ValidateCopyTexImage2D(context, target, level, internalformat, x, y, width, height, + border)) { - context->recordError(error); return; } + context->copyTexImage2D(target, level, internalformat, x, y, width, height, border); } } @@ -843,31 +783,14 @@ void GL_APIENTRY CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GL Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3 && - !ValidateES2CopyTexImageParameters(context, target, level, GL_NONE, true, - xoffset, yoffset, x, y, width, height, 0)) - { - return; - } - - if (context->getClientVersion() >= 3 && - !ValidateES3CopyTexImageParameters(context, target, level, GL_NONE, true, - xoffset, yoffset, 0, x, y, width, height, 0)) + if (!context->skipValidation() && + !ValidateCopyTexSubImage2D(context, target, level, xoffset, yoffset, x, y, width, + height)) { return; } - Offset destOffset(xoffset, yoffset, 0); - Rectangle sourceArea(x, y, width, height); - - const Framebuffer *framebuffer = context->getState().getReadFramebuffer(); - Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); - Error error = texture->copySubImage(target, level, destOffset, sourceArea, framebuffer); - if (error.isError()) - { - context->recordError(error); - return; - } + context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); } } @@ -1131,38 +1054,16 @@ void GL_APIENTRY DetachShader(GLuint program, GLuint shader) Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); - Shader *shaderObject = context->getShader(shader); - + Program *programObject = GetValidProgram(context, program); if (!programObject) { - Shader *shaderByProgramHandle; - shaderByProgramHandle = context->getShader(program); - if (!shaderByProgramHandle) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - else - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } + return; } + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - Program *programByShaderHandle = context->getProgram(shader); - if (!programByShaderHandle) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - else - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } + return; } if (!programObject->detachShader(shaderObject)) @@ -1219,7 +1120,7 @@ void GL_APIENTRY DrawArrays(GLenum mode, GLint first, GLsizei count) return; } - Error error = context->drawArrays(mode, first, count, 0); + Error error = context->drawArrays(mode, first, count); if (error.isError()) { context->recordError(error); @@ -1236,13 +1137,13 @@ void GL_APIENTRY DrawElements(GLenum mode, GLsizei count, GLenum type, const GLv Context *context = GetValidGlobalContext(); if (context) { - rx::RangeUI indexRange; + IndexRange indexRange; if (!ValidateDrawElements(context, mode, count, type, indices, 0, &indexRange)) { return; } - Error error = context->drawElements(mode, count, type, indices, 0, indexRange); + Error error = context->drawElements(mode, count, type, indices, indexRange); if (error.isError()) { context->recordError(error); @@ -1264,6 +1165,20 @@ void GL_APIENTRY Enable(GLenum cap) return; } + if (context->getLimitations().noSampleAlphaToCoverageSupport) + { + if (cap == GL_SAMPLE_ALPHA_TO_COVERAGE) + { + const char *errorMessage = "Current renderer doesn't support alpha-to-coverage"; + context->recordError(Error(GL_INVALID_OPERATION, errorMessage)); + + // We also output an error message to the debugger window if tracing is active, so that developers can see the error message. + ERR("%s", errorMessage); + + return; + } + } + context->getState().setEnableFeature(cap, true); } } @@ -1325,29 +1240,14 @@ void GL_APIENTRY FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenu Context *context = GetValidGlobalContext(); if (context) { - if (!ValidFramebufferTarget(target) || (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0)) - { - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - - if (!ValidateFramebufferRenderbufferParameters(context, target, attachment, renderbuffertarget, renderbuffer)) + if (!context->skipValidation() && + !ValidateFramebufferRenderbuffer(context, target, attachment, renderbuffertarget, + renderbuffer)) { return; } - Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); - ASSERT(framebuffer); - - if (renderbuffer != 0) - { - Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer); - framebuffer->setRenderbufferAttachment(attachment, renderbufferObject); - } - else - { - framebuffer->setNULLAttachment(attachment); - } + context->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); } } @@ -1359,36 +1259,13 @@ void GL_APIENTRY FramebufferTexture2D(GLenum target, GLenum attachment, GLenum t Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateFramebufferTexture2D(context, target, attachment, textarget, texture, level)) + if (!context->skipValidation() && + !ValidateFramebufferTexture2D(context, target, attachment, textarget, texture, level)) { return; } - Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); - ASSERT(framebuffer); - - if (texture != 0) - { - Texture *textureObj = context->getTexture(texture); - - ImageIndex index = ImageIndex::MakeInvalid(); - - if (textarget == GL_TEXTURE_2D) - { - index = ImageIndex::Make2D(level); - } - else - { - ASSERT(IsCubeMapTextureTarget(textarget)); - index = ImageIndex::MakeCube(textarget, level); - } - - framebuffer->setTextureAttachment(attachment, textureObj, index); - } - else - { - framebuffer->setNULLAttachment(attachment); - } + context->framebufferTexture2D(target, attachment, textarget, texture, level); } } @@ -1485,7 +1362,9 @@ void GL_APIENTRY GenerateMipmap(GLenum target) } // Non-power of 2 ES2 check - if (!context->getExtensions().textureNPOT && (!isPow2(texture->getWidth(baseTarget, 0)) || !isPow2(texture->getHeight(baseTarget, 0)))) + if (!context->getExtensions().textureNPOT && + (!isPow2(static_cast<int>(texture->getWidth(baseTarget, 0))) || + !isPow2(static_cast<int>(texture->getHeight(baseTarget, 0))))) { ASSERT(context->getClientVersion() <= 2 && (target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP)); context->recordError(Error(GL_INVALID_OPERATION)); @@ -1583,20 +1462,11 @@ void GL_APIENTRY GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (index >= (GLuint)programObject->getActiveAttributeCount()) @@ -1625,20 +1495,11 @@ void GL_APIENTRY GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (index >= (GLuint)programObject->getActiveUniformCount()) @@ -1665,20 +1526,11 @@ void GL_APIENTRY GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* c return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } return programObject->getAttachedShaders(maxcount, count, shaders); @@ -1692,20 +1544,11 @@ GLint GL_APIENTRY GetAttribLocation(GLuint program, const GLchar* name) Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return -1; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return -1; - } + return -1; } if (!programObject->isLinked()) @@ -1784,7 +1627,11 @@ void GL_APIENTRY GetBufferParameteriv(GLenum target, GLenum pname, GLint* params case GL_BUFFER_ACCESS_FLAGS: *params = buffer->getAccessFlags(); break; + case GL_BUFFER_ACCESS_OES: + *params = buffer->getAccess(); + break; case GL_BUFFER_MAPPED: + static_assert(GL_BUFFER_MAPPED == GL_BUFFER_MAPPED_OES, "GL enums should be equal."); *params = static_cast<GLint>(buffer->isMapped()); break; case GL_BUFFER_MAP_OFFSET: @@ -1918,7 +1765,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac break; } - Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); + const Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); ASSERT(framebuffer); if (framebuffer->id() == 0) @@ -2134,11 +1981,10 @@ void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint* params) Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -2151,6 +1997,7 @@ void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint* params) case GL_TRANSFORM_FEEDBACK_BUFFER_MODE: case GL_TRANSFORM_FEEDBACK_VARYINGS: case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: + case GL_PROGRAM_BINARY_RETRIEVABLE_HINT: context->recordError(Error(GL_INVALID_ENUM)); return; } @@ -2203,6 +2050,9 @@ void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint* params) case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: *params = programObject->getTransformFeedbackVaryingMaxLength(); break; + case GL_PROGRAM_BINARY_RETRIEVABLE_HINT: + *params = programObject->getBinaryRetrievableHint(); + break; default: context->recordError(Error(GL_INVALID_ENUM)); @@ -2225,11 +2075,9 @@ void GL_APIENTRY GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* len return; } - Program *programObject = context->getProgram(program); - + Program *programObject = GetValidProgram(context, program); if (!programObject) { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -2293,11 +2141,9 @@ void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint* params) Context *context = GetValidGlobalContext(); if (context) { - Shader *shaderObject = context->getShader(shader); - + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -2319,7 +2165,7 @@ void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint* params) *params = shaderObject->getSourceLength(); return; case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE: - *params = shaderObject->getTranslatedSourceLength(); + *params = shaderObject->getTranslatedSourceWithDebugInfoLength(); return; default: @@ -2343,11 +2189,9 @@ void GL_APIENTRY GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* lengt return; } - Shader *shaderObject = context->getShader(shader); - + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -2443,11 +2287,9 @@ void GL_APIENTRY GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length return; } - Shader *shaderObject = context->getShader(shader); - + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } @@ -2461,44 +2303,50 @@ const GLubyte *GL_APIENTRY GetString(GLenum name) Context *context = GetValidGlobalContext(); - switch (name) + if (context) { - case GL_VENDOR: - return (GLubyte*)"Google Inc."; + switch (name) + { + case GL_VENDOR: + return reinterpret_cast<const GLubyte *>("Google Inc."); - case GL_RENDERER: - return (GLubyte*)((context != NULL) ? context->getRendererString().c_str() : "ANGLE"); + case GL_RENDERER: + return reinterpret_cast<const GLubyte *>(context->getRendererString().c_str()); - case GL_VERSION: - if (context->getClientVersion() == 2) - { - return (GLubyte*)"OpenGL ES 2.0 (ANGLE " ANGLE_VERSION_STRING ")"; - } - else - { - return (GLubyte*)"OpenGL ES 3.0 (ANGLE " ANGLE_VERSION_STRING ")"; - } + case GL_VERSION: + if (context->getClientVersion() == 2) + { + return reinterpret_cast<const GLubyte *>( + "OpenGL ES 2.0 (ANGLE " ANGLE_VERSION_STRING ")"); + } + else + { + return reinterpret_cast<const GLubyte *>( + "OpenGL ES 3.0 (ANGLE " ANGLE_VERSION_STRING ")"); + } - case GL_SHADING_LANGUAGE_VERSION: - if (context->getClientVersion() == 2) - { - return (GLubyte*)"OpenGL ES GLSL ES 1.00 (ANGLE " ANGLE_VERSION_STRING ")"; - } - else - { - return (GLubyte*)"OpenGL ES GLSL ES 3.00 (ANGLE " ANGLE_VERSION_STRING ")"; - } + case GL_SHADING_LANGUAGE_VERSION: + if (context->getClientVersion() == 2) + { + return reinterpret_cast<const GLubyte *>( + "OpenGL ES GLSL ES 1.00 (ANGLE " ANGLE_VERSION_STRING ")"); + } + else + { + return reinterpret_cast<const GLubyte *>( + "OpenGL ES GLSL ES 3.00 (ANGLE " ANGLE_VERSION_STRING ")"); + } - case GL_EXTENSIONS: - return (GLubyte*)((context != NULL) ? context->getExtensionString().c_str() : ""); + case GL_EXTENSIONS: + return reinterpret_cast<const GLubyte *>(context->getExtensionString().c_str()); - default: - if (context) - { + default: context->recordError(Error(GL_INVALID_ENUM)); + return nullptr; } - return NULL; } + + return nullptr; } void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) @@ -2508,6 +2356,12 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) Context *context = GetValidGlobalContext(); if (context) { + if (!ValidTextureTarget(context, target)) + { + context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target")); + return; + } + Texture *texture = context->getTargetTexture(target); if (!texture) @@ -2519,16 +2373,16 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) switch (pname) { case GL_TEXTURE_MAG_FILTER: - *params = (GLfloat)texture->getSamplerState().magFilter; + *params = (GLfloat)texture->getMagFilter(); break; case GL_TEXTURE_MIN_FILTER: - *params = (GLfloat)texture->getSamplerState().minFilter; + *params = (GLfloat)texture->getMinFilter(); break; case GL_TEXTURE_WRAP_S: - *params = (GLfloat)texture->getSamplerState().wrapS; + *params = (GLfloat)texture->getWrapS(); break; case GL_TEXTURE_WRAP_T: - *params = (GLfloat)texture->getSamplerState().wrapT; + *params = (GLfloat)texture->getWrapT(); break; case GL_TEXTURE_WRAP_R: if (context->getClientVersion() < 3) @@ -2536,11 +2390,11 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().wrapR; + *params = (GLfloat)texture->getWrapR(); break; case GL_TEXTURE_IMMUTABLE_FORMAT: // Exposed to ES2.0 through EXT_texture_storage, no client version validation. - *params = (GLfloat)(texture->isImmutable() ? GL_TRUE : GL_FALSE); + *params = (GLfloat)(texture->getImmutableFormat() ? GL_TRUE : GL_FALSE); break; case GL_TEXTURE_IMMUTABLE_LEVELS: if (context->getClientVersion() < 3) @@ -2548,7 +2402,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->immutableLevelCount(); + *params = (GLfloat)texture->getImmutableLevels(); break; case GL_TEXTURE_USAGE_ANGLE: *params = (GLfloat)texture->getUsage(); @@ -2559,7 +2413,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().maxAnisotropy; + *params = (GLfloat)texture->getMaxAnisotropy(); break; case GL_TEXTURE_SWIZZLE_R: if (context->getClientVersion() < 3) @@ -2567,7 +2421,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().swizzleRed; + *params = (GLfloat)texture->getSwizzleRed(); break; case GL_TEXTURE_SWIZZLE_G: if (context->getClientVersion() < 3) @@ -2575,7 +2429,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().swizzleGreen; + *params = (GLfloat)texture->getSwizzleGreen(); break; case GL_TEXTURE_SWIZZLE_B: if (context->getClientVersion() < 3) @@ -2583,7 +2437,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().swizzleBlue; + *params = (GLfloat)texture->getSwizzleBlue(); break; case GL_TEXTURE_SWIZZLE_A: if (context->getClientVersion() < 3) @@ -2591,7 +2445,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().swizzleAlpha; + *params = (GLfloat)texture->getSwizzleAlpha(); break; case GL_TEXTURE_BASE_LEVEL: if (context->getClientVersion() < 3) @@ -2599,7 +2453,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().baseLevel; + *params = (GLfloat)texture->getBaseLevel(); break; case GL_TEXTURE_MAX_LEVEL: if (context->getClientVersion() < 3) @@ -2607,7 +2461,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLfloat)texture->getSamplerState().maxLevel; + *params = (GLfloat)texture->getMaxLevel(); break; case GL_TEXTURE_MIN_LOD: if (context->getClientVersion() < 3) @@ -2640,6 +2494,12 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) Context *context = GetValidGlobalContext(); if (context) { + if (!ValidTextureTarget(context, target)) + { + context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target")); + return; + } + Texture *texture = context->getTargetTexture(target); if (!texture) @@ -2672,7 +2532,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) break; case GL_TEXTURE_IMMUTABLE_FORMAT: // Exposed to ES2.0 through EXT_texture_storage, no client version validation. - *params = texture->isImmutable() ? GL_TRUE : GL_FALSE; + *params = texture->getImmutableFormat() ? GL_TRUE : GL_FALSE; break; case GL_TEXTURE_IMMUTABLE_LEVELS: if (context->getClientVersion() < 3) @@ -2680,7 +2540,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = static_cast<GLint>(texture->immutableLevelCount()); + *params = static_cast<GLint>(texture->getImmutableLevels()); break; case GL_TEXTURE_USAGE_ANGLE: *params = texture->getUsage(); @@ -2691,7 +2551,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLint)texture->getSamplerState().maxAnisotropy; + *params = (GLint)texture->getMaxAnisotropy(); break; case GL_TEXTURE_SWIZZLE_R: if (context->getClientVersion() < 3) @@ -2699,7 +2559,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = texture->getSamplerState().swizzleRed; + *params = texture->getSwizzleRed(); break; case GL_TEXTURE_SWIZZLE_G: if (context->getClientVersion() < 3) @@ -2707,7 +2567,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = texture->getSamplerState().swizzleGreen; + *params = texture->getSwizzleGreen(); break; case GL_TEXTURE_SWIZZLE_B: if (context->getClientVersion() < 3) @@ -2715,7 +2575,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = texture->getSamplerState().swizzleBlue; + *params = texture->getSwizzleBlue(); break; case GL_TEXTURE_SWIZZLE_A: if (context->getClientVersion() < 3) @@ -2723,7 +2583,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = texture->getSamplerState().swizzleAlpha; + *params = texture->getSwizzleAlpha(); break; case GL_TEXTURE_BASE_LEVEL: if (context->getClientVersion() < 3) @@ -2731,7 +2591,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = texture->getSamplerState().baseLevel; + *params = texture->getBaseLevel(); break; case GL_TEXTURE_MAX_LEVEL: if (context->getClientVersion() < 3) @@ -2739,7 +2599,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = texture->getSamplerState().maxLevel; + *params = texture->getMaxLevel(); break; case GL_TEXTURE_MIN_LOD: if (context->getClientVersion() < 3) @@ -2747,7 +2607,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLint)texture->getSamplerState().minLod; + *params = (GLint)texture->getMinLod(); break; case GL_TEXTURE_MAX_LOD: if (context->getClientVersion() < 3) @@ -2755,7 +2615,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params) context->recordError(Error(GL_INVALID_ENUM)); return; } - *params = (GLint)texture->getSamplerState().maxLod; + *params = (GLint)texture->getMaxLod(); break; default: @@ -2815,20 +2675,11 @@ GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar* name) return -1; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return -1; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return -1; - } + return -1; } if (!programObject->isLinked()) @@ -3122,20 +2973,10 @@ void GL_APIENTRY LinkProgram(GLuint program) Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); - + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } Error error = programObject->link(context->getData()); @@ -3160,14 +3001,28 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param) { case GL_UNPACK_IMAGE_HEIGHT: case GL_UNPACK_SKIP_IMAGES: + context->recordError(Error(GL_INVALID_ENUM)); + return; + case GL_UNPACK_ROW_LENGTH: case GL_UNPACK_SKIP_ROWS: case GL_UNPACK_SKIP_PIXELS: + if (!context->getExtensions().unpackSubimage) + { + context->recordError(Error(GL_INVALID_ENUM)); + return; + } + break; + case GL_PACK_ROW_LENGTH: case GL_PACK_SKIP_ROWS: case GL_PACK_SKIP_PIXELS: - context->recordError(Error(GL_INVALID_ENUM)); - return; + if (!context->getExtensions().packSubimage) + { + context->recordError(Error(GL_INVALID_ENUM)); + return; + } + break; } } @@ -3206,43 +3061,43 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param) break; case GL_UNPACK_ROW_LENGTH: - ASSERT(context->getClientVersion() >= 3); + ASSERT((context->getClientVersion() >= 3) || context->getExtensions().unpackSubimage); state.setUnpackRowLength(param); break; case GL_UNPACK_IMAGE_HEIGHT: ASSERT(context->getClientVersion() >= 3); - state.getUnpackState().imageHeight = param; + state.setUnpackImageHeight(param); break; case GL_UNPACK_SKIP_IMAGES: - ASSERT(context->getClientVersion() >= 3); - state.getUnpackState().skipImages = param; + ASSERT(context->getClientVersion() >= 3); + state.setUnpackSkipImages(param); break; case GL_UNPACK_SKIP_ROWS: - ASSERT(context->getClientVersion() >= 3); - state.getUnpackState().skipRows = param; + ASSERT((context->getClientVersion() >= 3) || context->getExtensions().unpackSubimage); + state.setUnpackSkipRows(param); break; case GL_UNPACK_SKIP_PIXELS: - ASSERT(context->getClientVersion() >= 3); - state.getUnpackState().skipPixels = param; + ASSERT((context->getClientVersion() >= 3) || context->getExtensions().unpackSubimage); + state.setUnpackSkipPixels(param); break; case GL_PACK_ROW_LENGTH: - ASSERT(context->getClientVersion() >= 3); - state.getPackState().rowLength = param; + ASSERT((context->getClientVersion() >= 3) || context->getExtensions().packSubimage); + state.setPackRowLength(param); break; case GL_PACK_SKIP_ROWS: - ASSERT(context->getClientVersion() >= 3); - state.getPackState().skipRows = param; + ASSERT((context->getClientVersion() >= 3) || context->getExtensions().packSubimage); + state.setPackSkipRows(param); break; case GL_PACK_SKIP_PIXELS: - ASSERT(context->getClientVersion() >= 3); - state.getPackState().skipPixels = param; + ASSERT((context->getClientVersion() >= 3) || context->getExtensions().packSubimage); + state.setPackSkipPixels(param); break; default: @@ -3273,28 +3128,13 @@ void GL_APIENTRY ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, Context *context = GetValidGlobalContext(); if (context) { - if (width < 0 || height < 0) + if (!context->skipValidation() && + !ValidateReadPixels(context, x, y, width, height, format, type, pixels)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } - if (!ValidateReadPixelsParameters(context, x, y, width, height, - format, type, NULL, pixels)) - { - return; - } - - Framebuffer *framebufferObject = context->getState().getReadFramebuffer(); - ASSERT(framebufferObject); - - Rectangle area(x, y, width, height); - Error error = framebufferObject->readPixels(context->getState(), area, format, type, pixels); - if (error.isError()) - { - context->recordError(error); - return; - } + context->readPixels(x, y, width, height, format, type, pixels); } } @@ -3404,22 +3244,11 @@ void GL_APIENTRY ShaderSource(GLuint shader, GLsizei count, const GLchar* const* return; } - Shader *shaderObject = context->getShader(shader); - + Shader *shaderObject = GetValidShader(context, shader); if (!shaderObject) { - if (context->getProgram(shader)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } - shaderObject->setSource(count, string, length); } } @@ -3619,15 +3448,16 @@ void GL_APIENTRY TexImage2D(GLenum target, GLint level, GLint internalformat, GL } if (context->getClientVersion() >= 3 && - !ValidateES3TexImageParameters(context, target, level, internalformat, false, false, - 0, 0, 0, width, height, 1, border, format, type, pixels)) + !ValidateES3TexImage2DParameters(context, target, level, internalformat, false, false, + 0, 0, 0, width, height, 1, border, format, type, + pixels)) { return; } Extents size(width, height, 1); Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); - Error error = texture->setImage(target, level, internalformat, size, format, type, context->getState().getUnpackState(), + Error error = texture->setImage(context, target, level, internalformat, size, format, type, reinterpret_cast<const uint8_t *>(pixels)); if (error.isError()) { @@ -3644,6 +3474,12 @@ void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param) Context *context = GetValidGlobalContext(); if (context) { + if (!ValidTextureTarget(context, target)) + { + context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target")); + return; + } + if (!ValidateTexParamParameters(context, pname, static_cast<GLint>(param))) { return; @@ -3657,27 +3493,29 @@ void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param) return; } + // clang-format off switch (pname) { - case GL_TEXTURE_WRAP_S: texture->getSamplerState().wrapS = uiround<GLenum>(param); break; - case GL_TEXTURE_WRAP_T: texture->getSamplerState().wrapT = uiround<GLenum>(param); break; - case GL_TEXTURE_WRAP_R: texture->getSamplerState().wrapR = uiround<GLenum>(param); break; - case GL_TEXTURE_MIN_FILTER: texture->getSamplerState().minFilter = uiround<GLenum>(param); break; - case GL_TEXTURE_MAG_FILTER: texture->getSamplerState().magFilter = uiround<GLenum>(param); break; - case GL_TEXTURE_USAGE_ANGLE: texture->setUsage(uiround<GLenum>(param)); break; - case GL_TEXTURE_MAX_ANISOTROPY_EXT: texture->getSamplerState().maxAnisotropy = std::min(param, context->getExtensions().maxTextureAnisotropy); break; - case GL_TEXTURE_COMPARE_MODE: texture->getSamplerState().compareMode = uiround<GLenum>(param); break; - case GL_TEXTURE_COMPARE_FUNC: texture->getSamplerState().compareFunc = uiround<GLenum>(param); break; - case GL_TEXTURE_SWIZZLE_R: texture->getSamplerState().swizzleRed = uiround<GLenum>(param); break; - case GL_TEXTURE_SWIZZLE_G: texture->getSamplerState().swizzleGreen = uiround<GLenum>(param); break; - case GL_TEXTURE_SWIZZLE_B: texture->getSamplerState().swizzleBlue = uiround<GLenum>(param); break; - case GL_TEXTURE_SWIZZLE_A: texture->getSamplerState().swizzleAlpha = uiround<GLenum>(param); break; - case GL_TEXTURE_BASE_LEVEL: texture->getSamplerState().baseLevel = iround<GLint>(param); break; - case GL_TEXTURE_MAX_LEVEL: texture->getSamplerState().maxLevel = iround<GLint>(param); break; - case GL_TEXTURE_MIN_LOD: texture->getSamplerState().minLod = param; break; - case GL_TEXTURE_MAX_LOD: texture->getSamplerState().maxLod = param; break; + case GL_TEXTURE_WRAP_S: texture->setWrapS(uiround<GLenum>(param)); break; + case GL_TEXTURE_WRAP_T: texture->setWrapT(uiround<GLenum>(param)); break; + case GL_TEXTURE_WRAP_R: texture->setWrapR(uiround<GLenum>(param)); break; + case GL_TEXTURE_MIN_FILTER: texture->setMinFilter(uiround<GLenum>(param)); break; + case GL_TEXTURE_MAG_FILTER: texture->setMagFilter(uiround<GLenum>(param)); break; + case GL_TEXTURE_USAGE_ANGLE: texture->setUsage(uiround<GLenum>(param)); break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: texture->setMaxAnisotropy(std::min(param, context->getExtensions().maxTextureAnisotropy)); break; + case GL_TEXTURE_COMPARE_MODE: texture->setCompareMode(uiround<GLenum>(param)); break; + case GL_TEXTURE_COMPARE_FUNC: texture->setCompareFunc(uiround<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_R: texture->setSwizzleRed(uiround<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_G: texture->setSwizzleGreen(uiround<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_B: texture->setSwizzleBlue(uiround<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_A: texture->setSwizzleAlpha(uiround<GLenum>(param)); break; + case GL_TEXTURE_BASE_LEVEL: texture->setBaseLevel(uiround<GLuint>(param)); break; + case GL_TEXTURE_MAX_LEVEL: texture->setMaxLevel(uiround<GLuint>(param)); break; + case GL_TEXTURE_MIN_LOD: texture->setMinLod(param); break; + case GL_TEXTURE_MAX_LOD: texture->setMaxLod(param); break; default: UNREACHABLE(); break; } + // clang-format on } } @@ -3693,6 +3531,12 @@ void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param) Context *context = GetValidGlobalContext(); if (context) { + if (!ValidTextureTarget(context, target)) + { + context->recordError(Error(GL_INVALID_ENUM, "Invalid Texture target")); + return; + } + if (!ValidateTexParamParameters(context, pname, param)) { return; @@ -3706,27 +3550,29 @@ void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param) return; } + // clang-format off switch (pname) { - case GL_TEXTURE_WRAP_S: texture->getSamplerState().wrapS = (GLenum)param; break; - case GL_TEXTURE_WRAP_T: texture->getSamplerState().wrapT = (GLenum)param; break; - case GL_TEXTURE_WRAP_R: texture->getSamplerState().wrapR = (GLenum)param; break; - case GL_TEXTURE_MIN_FILTER: texture->getSamplerState().minFilter = (GLenum)param; break; - case GL_TEXTURE_MAG_FILTER: texture->getSamplerState().magFilter = (GLenum)param; break; - case GL_TEXTURE_USAGE_ANGLE: texture->setUsage((GLenum)param); break; - case GL_TEXTURE_MAX_ANISOTROPY_EXT: texture->getSamplerState().maxAnisotropy = std::min((float)param, context->getExtensions().maxTextureAnisotropy); break; - case GL_TEXTURE_COMPARE_MODE: texture->getSamplerState().compareMode = (GLenum)param; break; - case GL_TEXTURE_COMPARE_FUNC: texture->getSamplerState().compareFunc = (GLenum)param; break; - case GL_TEXTURE_SWIZZLE_R: texture->getSamplerState().swizzleRed = (GLenum)param; break; - case GL_TEXTURE_SWIZZLE_G: texture->getSamplerState().swizzleGreen = (GLenum)param; break; - case GL_TEXTURE_SWIZZLE_B: texture->getSamplerState().swizzleBlue = (GLenum)param; break; - case GL_TEXTURE_SWIZZLE_A: texture->getSamplerState().swizzleAlpha = (GLenum)param; break; - case GL_TEXTURE_BASE_LEVEL: texture->getSamplerState().baseLevel = param; break; - case GL_TEXTURE_MAX_LEVEL: texture->getSamplerState().maxLevel = param; break; - case GL_TEXTURE_MIN_LOD: texture->getSamplerState().minLod = (GLfloat)param; break; - case GL_TEXTURE_MAX_LOD: texture->getSamplerState().maxLod = (GLfloat)param; break; + case GL_TEXTURE_WRAP_S: texture->setWrapS(static_cast<GLenum>(param)); break; + case GL_TEXTURE_WRAP_T: texture->setWrapT(static_cast<GLenum>(param)); break; + case GL_TEXTURE_WRAP_R: texture->setWrapR(static_cast<GLenum>(param)); break; + case GL_TEXTURE_MIN_FILTER: texture->setMinFilter(static_cast<GLenum>(param)); break; + case GL_TEXTURE_MAG_FILTER: texture->setMagFilter(static_cast<GLenum>(param)); break; + case GL_TEXTURE_USAGE_ANGLE: texture->setUsage(static_cast<GLenum>(param)); break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: texture->setMaxAnisotropy(std::min(static_cast<GLfloat>(param), context->getExtensions().maxTextureAnisotropy)); break; + case GL_TEXTURE_COMPARE_MODE: texture->setCompareMode(static_cast<GLenum>(param)); break; + case GL_TEXTURE_COMPARE_FUNC: texture->setCompareFunc(static_cast<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_R: texture->setSwizzleRed(static_cast<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_G: texture->setSwizzleGreen(static_cast<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_B: texture->setSwizzleBlue(static_cast<GLenum>(param)); break; + case GL_TEXTURE_SWIZZLE_A: texture->setSwizzleAlpha(static_cast<GLenum>(param)); break; + case GL_TEXTURE_BASE_LEVEL: texture->setBaseLevel(static_cast<GLuint>(param)); break; + case GL_TEXTURE_MAX_LEVEL: texture->setMaxLevel(static_cast<GLuint>(param)); break; + case GL_TEXTURE_MIN_LOD: texture->setMinLod(static_cast<GLfloat>(param)); break; + case GL_TEXTURE_MAX_LOD: texture->setMaxLod(static_cast<GLfloat>(param)); break; default: UNREACHABLE(); break; } + // clang-format on } } @@ -3754,8 +3600,8 @@ void GL_APIENTRY TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint } if (context->getClientVersion() >= 3 && - !ValidateES3TexImageParameters(context, target, level, GL_NONE, false, true, - xoffset, yoffset, 0, width, height, 1, 0, format, type, pixels)) + !ValidateES3TexImage2DParameters(context, target, level, GL_NONE, false, true, xoffset, + yoffset, 0, width, height, 1, 0, format, type, pixels)) { return; } @@ -3768,7 +3614,7 @@ void GL_APIENTRY TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint Box area(xoffset, yoffset, 0, width, height, 1); Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); - Error error = texture->setSubImage(target, level, area, format, type, context->getState().getUnpackState(), + Error error = texture->setSubImage(context, target, level, area, format, type, reinterpret_cast<const uint8_t *>(pixels)); if (error.isError()) { @@ -4060,20 +3906,11 @@ void GL_APIENTRY ValidateProgram(GLuint program) Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } programObject->validate(context->getCaps()); diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.cpp b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.cpp index d41c5a4da5..7df6fcb0cd 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.cpp +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.cpp @@ -27,6 +27,57 @@ namespace gl { +void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint *ids) +{ + EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGenQueriesEXT(context, n, ids)) + { + return; + } + + for (GLsizei i = 0; i < n; i++) + { + ids[i] = context->createQuery(); + } + } +} + +void GL_APIENTRY DeleteQueriesEXT(GLsizei n, const GLuint *ids) +{ + EVENT("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateDeleteQueriesEXT(context, n, ids)) + { + return; + } + + for (int i = 0; i < n; i++) + { + context->deleteQuery(ids[i]); + } + } +} + +GLboolean GL_APIENTRY IsQueryEXT(GLuint id) +{ + EVENT("(GLuint id = %d)", id); + + Context *context = GetValidGlobalContext(); + if (context) + { + return (context->getQuery(id, false, GL_NONE) != NULL) ? GL_TRUE : GL_FALSE; + } + + return GL_FALSE; +} + void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id) { EVENT("(GLenum target = 0x%X, GLuint %d)", target, id); @@ -34,7 +85,7 @@ void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id) Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateBeginQuery(context, target, id)) + if (!ValidateBeginQueryEXT(context, target, id)) { return; } @@ -48,59 +99,78 @@ void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id) } } -void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint* fences) +void GL_APIENTRY EndQueryEXT(GLenum target) { - EVENT("(GLsizei n = %d, const GLuint* fences = 0x%0.8p)", n, fences); + EVENT("GLenum target = 0x%X)", target); Context *context = GetValidGlobalContext(); if (context) { - if (n < 0) + if (!ValidateEndQueryEXT(context, target)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } - for (int i = 0; i < n; i++) + Error error = context->endQuery(target); + if (error.isError()) { - context->deleteFenceNV(fences[i]); + context->recordError(error); + return; } } } -void GL_APIENTRY DeleteQueriesEXT(GLsizei n, const GLuint *ids) +void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target) { - EVENT("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids); + EVENT("GLuint id = %d, GLenum target = 0x%X)", id, target); Context *context = GetValidGlobalContext(); if (context) { - if (n < 0) + if (!ValidateQueryCounterEXT(context, id, target)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } - for (int i = 0; i < n; i++) + Error error = context->queryCounter(id, target); + if (error.isError()) { - context->deleteQuery(ids[i]); + context->recordError(error); + return; } } } -void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount) +void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params) { - EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)", mode, first, count, primcount); + EVENT("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, + params); Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateDrawArraysInstancedANGLE(context, mode, first, count, primcount)) + if (!ValidateGetQueryivEXT(context, target, pname, params)) { return; } - Error error = context->drawArrays(mode, first, count, primcount); + context->getQueryiv(target, pname, params); + } +} + +void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params) +{ + EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGetQueryObjectivEXT(context, id, pname, params)) + { + return; + } + + Error error = context->getQueryObjectiv(id, pname, params); if (error.isError()) { context->recordError(error); @@ -109,21 +179,19 @@ void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei coun } } -void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount) +void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params) { - EVENT("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p, GLsizei primcount = %d)", - mode, count, type, indices, primcount); + EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params); Context *context = GetValidGlobalContext(); if (context) { - rx::RangeUI indexRange; - if (!ValidateDrawElementsInstancedANGLE(context, mode, count, type, indices, primcount, &indexRange)) + if (!ValidateGetQueryObjectuivEXT(context, id, pname, params)) { return; } - Error error = context->drawElements(mode, count, type, indices, primcount, indexRange); + Error error = context->getQueryObjectuiv(id, pname, params); if (error.isError()) { context->recordError(error); @@ -132,19 +200,19 @@ void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum t } } -void GL_APIENTRY EndQueryEXT(GLenum target) +void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params) { - EVENT("GLenum target = 0x%X)", target); + EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.16p)", id, pname, params); Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateEndQuery(context, target)) + if (!ValidateGetQueryObjecti64vEXT(context, id, pname, params)) { return; } - Error error = context->endQuery(target); + Error error = context->getQueryObjecti64v(id, pname, params); if (error.isError()) { context->recordError(error); @@ -153,34 +221,30 @@ void GL_APIENTRY EndQueryEXT(GLenum target) } } -void GL_APIENTRY FinishFenceNV(GLuint fence) +void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params) { - EVENT("(GLuint fence = %d)", fence); + EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.16p)", id, pname, params); Context *context = GetValidGlobalContext(); if (context) { - FenceNV *fenceObject = context->getFenceNV(fence); - - if (fenceObject == NULL) + if (!ValidateGetQueryObjectui64vEXT(context, id, pname, params)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - if (fenceObject->isFence() != GL_TRUE) + Error error = context->getQueryObjectui64v(id, pname, params); + if (error.isError()) { - context->recordError(Error(GL_INVALID_OPERATION)); + context->recordError(error); return; } - - fenceObject->finishFence(); } } -void GL_APIENTRY GenFencesNV(GLsizei n, GLuint* fences) +void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint *fences) { - EVENT("(GLsizei n = %d, GLuint* fences = 0x%0.8p)", n, fences); + EVENT("(GLsizei n = %d, const GLuint* fences = 0x%0.8p)", n, fences); Context *context = GetValidGlobalContext(); if (context) @@ -193,14 +257,95 @@ void GL_APIENTRY GenFencesNV(GLsizei n, GLuint* fences) for (int i = 0; i < n; i++) { - fences[i] = context->createFenceNV(); + context->deleteFenceNV(fences[i]); } } } -void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint* ids) +void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei primcount) { - EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids); + EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)", + mode, first, count, primcount); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateDrawArraysInstancedANGLE(context, mode, first, count, primcount)) + { + return; + } + + Error error = context->drawArraysInstanced(mode, first, count, primcount); + if (error.isError()) + { + context->recordError(error); + return; + } + } +} + +void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + GLsizei primcount) +{ + EVENT( + "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = " + "0x%0.8p, GLsizei primcount = %d)", + mode, count, type, indices, primcount); + + Context *context = GetValidGlobalContext(); + if (context) + { + IndexRange indexRange; + if (!ValidateDrawElementsInstancedANGLE(context, mode, count, type, indices, primcount, + &indexRange)) + { + return; + } + + Error error = + context->drawElementsInstanced(mode, count, type, indices, primcount, indexRange); + if (error.isError()) + { + context->recordError(error); + return; + } + } +} + +void GL_APIENTRY FinishFenceNV(GLuint fence) +{ + EVENT("(GLuint fence = %d)", fence); + + Context *context = GetValidGlobalContext(); + if (context) + { + FenceNV *fenceObject = context->getFenceNV(fence); + + if (fenceObject == NULL) + { + context->recordError(Error(GL_INVALID_OPERATION)); + return; + } + + if (fenceObject->isSet() != GL_TRUE) + { + context->recordError(Error(GL_INVALID_OPERATION)); + return; + } + + fenceObject->finish(); + } +} + +void GL_APIENTRY GenFencesNV(GLsizei n, GLuint *fences) +{ + EVENT("(GLsizei n = %d, GLuint* fences = 0x%0.8p)", n, fences); Context *context = GetValidGlobalContext(); if (context) @@ -211,9 +356,9 @@ void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint* ids) return; } - for (GLsizei i = 0; i < n; i++) + for (int i = 0; i < n; i++) { - ids[i] = context->createQuery(); + fences[i] = context->createFenceNV(); } } } @@ -233,7 +378,7 @@ void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params) return; } - if (fenceObject->isFence() != GL_TRUE) + if (fenceObject->isSet() != GL_TRUE) { context->recordError(Error(GL_INVALID_OPERATION)); return; @@ -249,7 +394,7 @@ void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params) GLboolean status = GL_TRUE; if (fenceObject->getStatus() != GL_TRUE) { - Error error = fenceObject->testFence(&status); + Error error = fenceObject->test(&status); if (error.isError()) { context->recordError(error); @@ -289,84 +434,6 @@ GLenum GL_APIENTRY GetGraphicsResetStatusEXT(void) return GL_NO_ERROR; } -void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params) -{ - EVENT("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, params); - - Context *context = GetValidGlobalContext(); - if (context) - { - if (!ValidQueryType(context, target)) - { - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - - switch (pname) - { - case GL_CURRENT_QUERY_EXT: - params[0] = context->getState().getActiveQueryId(target); - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - } -} - -void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params) -{ - EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params); - - Context *context = GetValidGlobalContext(); - if (context) - { - Query *queryObject = context->getQuery(id, false, GL_NONE); - - if (!queryObject) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (context->getState().getActiveQueryId(queryObject->getType()) == id) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - switch(pname) - { - case GL_QUERY_RESULT_EXT: - { - Error error = queryObject->getResult(params); - if (error.isError()) - { - context->recordError(error); - return; - } - } - break; - - case GL_QUERY_RESULT_AVAILABLE_EXT: - { - Error error = queryObject->isResultAvailable(params); - if (error.isError()) - { - context->recordError(error); - return; - } - } - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - } -} - void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) { EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = 0x%0.8p)", @@ -389,7 +456,6 @@ void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader, GLsizei bufsize, return; } - // Only returns extra info if ANGLE_GENERATE_SHADER_DEBUG_INFO is defined shaderObject->getTranslatedSourceWithDebugInfo(bufsize, length, source); } } @@ -448,20 +514,9 @@ GLboolean GL_APIENTRY IsFenceNV(GLuint fence) return GL_FALSE; } - return fenceObject->isFence(); - } - - return GL_FALSE; -} - -GLboolean GL_APIENTRY IsQueryEXT(GLuint id) -{ - EVENT("(GLuint id = %d)", id); - - Context *context = GetValidGlobalContext(); - if (context) - { - return (context->getQuery(id, false, GL_NONE) != NULL) ? GL_TRUE : GL_FALSE; + // GL_NV_fence spec: + // A name returned by GenFencesNV, but not yet set via SetFenceNV, is not the name of an existing fence. + return fenceObject->isSet(); } return GL_FALSE; @@ -478,28 +533,13 @@ void GL_APIENTRY ReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, Context *context = GetValidGlobalContext(); if (context) { - if (width < 0 || height < 0 || bufSize < 0) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - - if (!ValidateReadPixelsParameters(context, x, y, width, height, - format, type, &bufSize, data)) + if (!context->skipValidation() && + !ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data)) { return; } - Framebuffer *framebufferObject = context->getState().getReadFramebuffer(); - ASSERT(framebufferObject); - - Rectangle area(x, y, width, height); - Error error = framebufferObject->readPixels(context->getState(), area, format, type, data); - if (error.isError()) - { - context->recordError(error); - return; - } + context->readPixels(x, y, width, height, format, type, data); } } @@ -548,7 +588,7 @@ void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition) return; } - Error error = fenceObject->setFence(condition); + Error error = fenceObject->set(condition); if (error.isError()) { context->recordError(error); @@ -572,14 +612,14 @@ GLboolean GL_APIENTRY TestFenceNV(GLuint fence) return GL_TRUE; } - if (fenceObject->isFence() != GL_TRUE) + if (fenceObject->isSet() != GL_TRUE) { context->recordError(Error(GL_INVALID_OPERATION)); return GL_TRUE; } GLboolean result; - Error error = fenceObject->testFence(&result); + Error error = fenceObject->test(&result); if (error.isError()) { context->recordError(error); @@ -613,7 +653,8 @@ void GL_APIENTRY TexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalf } if (context->getClientVersion() >= 3 && - !ValidateES3TexStorageParameters(context, target, levels, internalformat, width, height, 1)) + !ValidateES3TexStorage2DParameters(context, target, levels, internalformat, width, + height, 1)) { return; } @@ -642,6 +683,21 @@ void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor) return; } + if (context->getLimitations().attributeZeroRequiresZeroDivisorInEXT) + { + if (index == 0 && divisor != 0) + { + const char *errorMessage = "The current context doesn't support setting a non-zero divisor on the attribute with index zero. " + "Please reorder the attributes in your vertex shader so that attribute zero can have a zero divisor."; + context->recordError(Error(GL_INVALID_OPERATION, errorMessage)); + + // We also output an error message to the debugger window if tracing is active, so that developers can see the error message. + ERR("%s", errorMessage); + + return; + } + } + context->setVertexAttribDivisor(index, divisor); } } @@ -657,32 +713,32 @@ void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLi Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateBlitFramebufferParameters(context, srcX0, srcY0, srcX1, srcY1, - dstX0, dstY0, dstX1, dstY1, mask, filter, -#ifndef ANGLE_ENABLE_WINDOWS_STORE - true)) -#else - false)) -#endif + if (!context->skipValidation() && + !ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, + dstY1, mask, filter)) { return; } - Framebuffer *readFramebuffer = context->getState().getReadFramebuffer(); - ASSERT(readFramebuffer); - - Framebuffer *drawFramebuffer = context->getState().getDrawFramebuffer(); - ASSERT(drawFramebuffer); + context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); + } +} - Rectangle srcArea(srcX0, srcY0, srcX1 - srcX0, srcY1 - srcY0); - Rectangle dstArea(dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0); +void GL_APIENTRY DiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) +{ + EVENT("(GLenum target = 0x%X, GLsizei numAttachments = %d, attachments = 0x%0.8p)", target, numAttachments, attachments); - Error error = drawFramebuffer->blit(context->getState(), srcArea, dstArea, mask, filter, readFramebuffer); - if (error.isError()) + Context *context = GetValidGlobalContext(); + if (context) + { + if (!context->skipValidation() && + !ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments)) { - context->recordError(error); return; } + + context->discardFramebuffer(target, numAttachments, attachments); } } @@ -705,14 +761,14 @@ void GL_APIENTRY GetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *l Context *context = GetValidGlobalContext(); if (context) { - Program *programObject = context->getProgram(program); - - if (!programObject || !programObject->isLinked()) + if (!ValidateGetProgramBinaryOES(context, program, bufSize, length, binaryFormat, binary)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } + Program *programObject = context->getProgram(program); + ASSERT(programObject != nullptr); + Error error = programObject->saveBinary(binaryFormat, binary, bufSize, length); if (error.isError()) { @@ -730,19 +786,13 @@ void GL_APIENTRY ProgramBinaryOES(GLuint program, GLenum binaryFormat, const voi Context *context = GetValidGlobalContext(); if (context) { - const std::vector<GLenum> &programBinaryFormats = context->getCaps().programBinaryFormats; - if (std::find(programBinaryFormats.begin(), programBinaryFormats.end(), binaryFormat) == programBinaryFormats.end()) + if (!ValidateProgramBinaryOES(context, program, binaryFormat, binary, length)) { - context->recordError(Error(GL_INVALID_ENUM)); return; } Program *programObject = context->getProgram(program); - if (!programObject) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } + ASSERT(programObject != nullptr); Error error = programObject->loadBinary(binaryFormat, binary, length); if (error.isError()) @@ -760,45 +810,12 @@ void GL_APIENTRY DrawBuffersEXT(GLsizei n, const GLenum *bufs) Context *context = GetValidGlobalContext(); if (context) { - if (n < 0 || static_cast<GLuint>(n) > context->getCaps().maxDrawBuffers) + if (!context->skipValidation() && !ValidateDrawBuffersEXT(context, n, bufs)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } - ASSERT(context->getState().getDrawFramebuffer()); - - if (context->getState().getDrawFramebuffer()->id() == 0) - { - if (n != 1) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (bufs[0] != GL_NONE && bufs[0] != GL_BACK) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - } - else - { - for (int colorAttachment = 0; colorAttachment < n; colorAttachment++) - { - const GLenum attachment = GL_COLOR_ATTACHMENT0_EXT + colorAttachment; - if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != attachment) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - } - } - - Framebuffer *framebuffer = context->getState().getDrawFramebuffer(); - ASSERT(framebuffer); - - framebuffer->setDrawBuffers(n, bufs); + context->drawBuffers(n, bufs); } } @@ -867,7 +884,7 @@ void *GL_APIENTRY MapBufferOES(GLenum target, GLenum access) return NULL; } - Error error = buffer->mapRange(0, buffer->getSize(), GL_MAP_WRITE_BIT); + Error error = buffer->map(access); if (error.isError()) { context->recordError(error); @@ -901,16 +918,15 @@ GLboolean GL_APIENTRY UnmapBufferOES(GLenum target) return GL_FALSE; } - // TODO: detect if we had corruption. if so, throw an error and return false. - - Error error = buffer->unmap(); + GLboolean result; + Error error = buffer->unmap(&result); if (error.isError()) { context->recordError(error); return GL_FALSE; } - return GL_TRUE; + return result; } return GL_FALSE; @@ -1059,4 +1075,464 @@ void GL_APIENTRY FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsiz } } +void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const char *marker) +{ + // Don't run an EVENT() macro on the EXT_debug_marker entry points. + // It can interfere with the debug events being set by the caller. + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!context->getExtensions().debugMarker) + { + // The debug marker calls should not set error state + // However, it seems reasonable to set an error state if the extension is not enabled + context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled")); + return; + } + + if (!ValidateInsertEventMarkerEXT(context, length, marker)) + { + return; + } + + context->insertEventMarker(length, marker); + } +} + +void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const char *marker) +{ + // Don't run an EVENT() macro on the EXT_debug_marker entry points. + // It can interfere with the debug events being set by the caller. + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!context->getExtensions().debugMarker) + { + // The debug marker calls should not set error state + // However, it seems reasonable to set an error state if the extension is not enabled + context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled")); + return; + } + + if (!ValidatePushGroupMarkerEXT(context, length, marker)) + { + return; + } + + if (marker == nullptr) + { + // From the EXT_debug_marker spec, + // "If <marker> is null then an empty string is pushed on the stack." + context->pushGroupMarker(length, ""); + } + else + { + context->pushGroupMarker(length, marker); + } + } +} + +void GL_APIENTRY PopGroupMarkerEXT() +{ + // Don't run an EVENT() macro on the EXT_debug_marker entry points. + // It can interfere with the debug events being set by the caller. + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!context->getExtensions().debugMarker) + { + // The debug marker calls should not set error state + // However, it seems reasonable to set an error state if the extension is not enabled + context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled")); + return; + } + + context->popGroupMarker(); + } +} + +ANGLE_EXPORT void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%0.8p)", target, image); + + Context *context = GetValidGlobalContext(); + if (context) + { + egl::Display *display = egl::GetGlobalDisplay(); + egl::Image *imageObject = reinterpret_cast<egl::Image *>(image); + if (!ValidateEGLImageTargetTexture2DOES(context, display, target, imageObject)) + { + return; + } + + Texture *texture = context->getTargetTexture(target); + Error error = texture->setEGLImageTarget(target, imageObject); + if (error.isError()) + { + context->recordError(error); + return; + } + } +} + +ANGLE_EXPORT void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target, + GLeglImageOES image) +{ + EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%0.8p)", target, image); + + Context *context = GetValidGlobalContext(); + if (context) + { + egl::Display *display = egl::GetGlobalDisplay(); + egl::Image *imageObject = reinterpret_cast<egl::Image *>(image); + if (!ValidateEGLImageTargetRenderbufferStorageOES(context, display, target, imageObject)) + { + return; + } + + Renderbuffer *renderbuffer = context->getState().getCurrentRenderbuffer(); + Error error = renderbuffer->setStorageEGLImageTarget(imageObject); + if (error.isError()) + { + context->recordError(error); + return; + } + } +} + +void GL_APIENTRY BindVertexArrayOES(GLuint array) +{ + EVENT("(GLuint array = %u)", array); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateBindVertexArrayOES(context, array)) + { + return; + } + + context->bindVertexArray(array); + } +} + +void GL_APIENTRY DeleteVertexArraysOES(GLsizei n, const GLuint *arrays) +{ + EVENT("(GLsizei n = %d, const GLuint* arrays = 0x%0.8p)", n, arrays); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateDeleteVertexArraysOES(context, n)) + { + return; + } + + for (int arrayIndex = 0; arrayIndex < n; arrayIndex++) + { + if (arrays[arrayIndex] != 0) + { + context->deleteVertexArray(arrays[arrayIndex]); + } + } + } +} + +void GL_APIENTRY GenVertexArraysOES(GLsizei n, GLuint *arrays) +{ + EVENT("(GLsizei n = %d, GLuint* arrays = 0x%0.8p)", n, arrays); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGenVertexArraysOES(context, n)) + { + return; + } + + for (int arrayIndex = 0; arrayIndex < n; arrayIndex++) + { + arrays[arrayIndex] = context->createVertexArray(); + } + } +} + +GLboolean GL_APIENTRY IsVertexArrayOES(GLuint array) +{ + EVENT("(GLuint array = %u)", array); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateIsVertexArrayOES(context)) + { + return GL_FALSE; + } + + if (array == 0) + { + return GL_FALSE; + } + + VertexArray *vao = context->getVertexArray(array); + + return (vao != nullptr ? GL_TRUE : GL_FALSE); + } + + return GL_FALSE; +} + +void GL_APIENTRY DebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled) +{ + EVENT( + "(GLenum source = 0x%X, GLenum type = 0x%X, GLenum severity = 0x%X, GLsizei count = %d, " + "GLint *ids = 0x%0.8p, GLboolean enabled = %d)", + source, type, severity, count, ids, enabled); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled)) + { + return; + } + + std::vector<GLuint> idVector(ids, ids + count); + context->getState().getDebug().setMessageControl( + source, type, severity, std::move(idVector), (enabled != GL_FALSE)); + } +} + +void GL_APIENTRY DebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf) +{ + EVENT( + "(GLenum source = 0x%X, GLenum type = 0x%X, GLint id = %d, GLenum severity = 0x%X, GLsizei " + "length = %d, const GLchar *buf = 0x%0.8p)", + source, type, id, severity, length, buf); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf)) + { + return; + } + + std::string msg(buf, (length > 0) ? static_cast<size_t>(length) : strlen(buf)); + context->getState().getDebug().insertMessage(source, type, id, severity, std::move(msg)); + } +} + +void GL_APIENTRY DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam) +{ + EVENT("(GLDEBUGPROCKHR callback = 0x%0.8p, const void *userParam = 0x%0.8p)", callback, + userParam); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateDebugMessageCallbackKHR(context, callback, userParam)) + { + return; + } + + context->getState().getDebug().setCallback(callback, userParam); + } +} + +GLuint GL_APIENTRY GetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog) +{ + EVENT( + "(GLsizei count = %d, GLsizei bufSize = %d, GLenum *sources, GLenum *types = 0x%0.8p, " + "GLuint *ids = 0x%0.8p, GLenum *severities = 0x%0.8p, GLsizei *lengths = 0x%0.8p, GLchar " + "*messageLog = 0x%0.8p)", + count, bufSize, sources, types, ids, severities, lengths, messageLog); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types, ids, severities, + lengths, messageLog)) + { + return 0; + } + + return static_cast<GLuint>(context->getState().getDebug().getMessages( + count, bufSize, sources, types, ids, severities, lengths, messageLog)); + } + + return 0; +} + +void GL_APIENTRY PushDebugGroupKHR(GLenum source, GLuint id, GLsizei length, const GLchar *message) +{ + EVENT( + "(GLenum source = 0x%X, GLuint id = 0x%X, GLsizei length = %d, const GLchar *message = " + "0x%0.8p)", + source, id, length, message); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidatePushDebugGroupKHR(context, source, id, length, message)) + { + return; + } + + std::string msg(message, (length > 0) ? static_cast<size_t>(length) : strlen(message)); + context->getState().getDebug().pushGroup(source, id, std::move(msg)); + } +} + +void GL_APIENTRY PopDebugGroupKHR(void) +{ + EVENT("()"); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidatePopDebugGroupKHR(context)) + { + return; + } + + context->getState().getDebug().popGroup(); + } +} + +void GL_APIENTRY ObjectLabelKHR(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) +{ + EVENT( + "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei length = %d, const GLchar *label = " + "0x%0.8p)", + identifier, name, length, label); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateObjectLabelKHR(context, identifier, name, length, label)) + { + return; + } + + LabeledObject *object = context->getLabeledObject(identifier, name); + ASSERT(object != nullptr); + + std::string lbl(label, (length > 0) ? static_cast<size_t>(length) : strlen(label)); + object->setLabel(lbl); + } +} + +void GL_APIENTRY +GetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + EVENT( + "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei bufSize = %d, GLsizei *length = " + "0x%0.8p, GLchar *label = 0x%0.8p)", + identifier, name, bufSize, length, label); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label)) + { + return; + } + + LabeledObject *object = context->getLabeledObject(identifier, name); + ASSERT(object != nullptr); + + const std::string &objectLabel = object->getLabel(); + size_t writeLength = std::min(static_cast<size_t>(bufSize) - 1, objectLabel.length()); + std::copy(objectLabel.begin(), objectLabel.begin() + writeLength, label); + label[writeLength] = '\0'; + *length = static_cast<GLsizei>(writeLength); + } +} + +void GL_APIENTRY ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label) +{ + EVENT("(const void *ptr = 0x%0.8p, GLsizei length = %d, const GLchar *label = 0x%0.8p)", ptr, + length, label); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateObjectPtrLabelKHR(context, ptr, length, label)) + { + return; + } + + LabeledObject *object = context->getLabeledObjectFromPtr(ptr); + ASSERT(object != nullptr); + + std::string lbl(label, (length > 0) ? static_cast<size_t>(length) : strlen(label)); + object->setLabel(lbl); + } +} + +void GL_APIENTRY GetObjectPtrLabelKHR(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + EVENT( + "(const void *ptr = 0x%0.8p, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLchar " + "*label = 0x%0.8p)", + ptr, bufSize, length, label); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label)) + { + return; + } + + LabeledObject *object = context->getLabeledObjectFromPtr(ptr); + ASSERT(object != nullptr); + + const std::string &objectLabel = object->getLabel(); + size_t writeLength = std::min(static_cast<size_t>(bufSize) - 1, objectLabel.length()); + std::copy(objectLabel.begin(), objectLabel.begin() + writeLength, label); + label[writeLength] = '\0'; + *length = static_cast<GLsizei>(writeLength); + } +} + +void GL_APIENTRY GetPointervKHR(GLenum pname, void **params) +{ + EVENT("(GLenum pname = 0x%X, void **params = 0x%0.8p)", pname, params); + + Context *context = GetValidGlobalContext(); + if (context) + { + if (!ValidateGetPointervKHR(context, pname, params)) + { + return; + } + + context->getPointerv(pname, params); + } +} } diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.h b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.h index 816519fe1f..a2fb9c5e80 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.h +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_2_0_ext.h @@ -22,6 +22,9 @@ ANGLE_EXPORT void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLi // GL_ANGLE_framebuffer_multisample ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +// GL_EXT_discard_framebuffer +ANGLE_EXPORT void GL_APIENTRY DiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments); + // GL_NV_fence ANGLE_EXPORT void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint* fences); ANGLE_EXPORT void GL_APIENTRY GenFencesNV(GLsizei n, GLuint* fences); @@ -52,6 +55,12 @@ ANGLE_EXPORT void GL_APIENTRY EndQueryEXT(GLenum target); ANGLE_EXPORT void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params); ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params); +// GL_EXT_disjoint_timer_query +ANGLE_EXPORT void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target); +ANGLE_EXPORT void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params); +ANGLE_EXPORT void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params); + // GL_EXT_draw_buffers ANGLE_EXPORT void GL_APIENTRY DrawBuffersEXT(GLsizei n, const GLenum *bufs); @@ -73,6 +82,64 @@ ANGLE_EXPORT void GL_APIENTRY GetBufferPointervOES(GLenum target, GLenum pname, ANGLE_EXPORT void *GL_APIENTRY MapBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length); +// GL_EXT_debug_marker +ANGLE_EXPORT void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const char *marker); +ANGLE_EXPORT void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const char *marker); +ANGLE_EXPORT void GL_APIENTRY PopGroupMarkerEXT(); + +// GL_OES_EGL_image +ANGLE_EXPORT void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); +ANGLE_EXPORT void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target, + GLeglImageOES image); + +// GL_OES_vertex_array_object +ANGLE_EXPORT void GL_APIENTRY BindVertexArrayOES(GLuint array); +ANGLE_EXPORT void GL_APIENTRY DeleteVertexArraysOES(GLsizei n, const GLuint *arrays); +ANGLE_EXPORT void GL_APIENTRY GenVertexArraysOES(GLsizei n, GLuint *arrays); +ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArrayOES(GLuint array); + +// GL_KHR_debug +ANGLE_EXPORT void GL_APIENTRY DebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled); +ANGLE_EXPORT void GL_APIENTRY DebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf); +ANGLE_EXPORT void GL_APIENTRY DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, + const void *userParam); +ANGLE_EXPORT GLuint GL_APIENTRY GetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog); +ANGLE_EXPORT void GL_APIENTRY PushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar *message); +ANGLE_EXPORT void GL_APIENTRY PopDebugGroupKHR(void); +ANGLE_EXPORT void GL_APIENTRY ObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label); +ANGLE_EXPORT void GL_APIENTRY +GetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label); +ANGLE_EXPORT void GL_APIENTRY ObjectPtrLabelKHR(const void *ptr, + GLsizei length, + const GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GetObjectPtrLabelKHR(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GetPointervKHR(GLenum pname, void **params); } #endif // LIBGLESV2_ENTRYPOINTGLES20EXT_H_ diff --git a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_3_0.cpp b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_3_0.cpp index d8bdcd2e50..856129aa07 100644 --- a/src/3rdparty/angle/src/libGLESv2/entry_points_gles_3_0.cpp +++ b/src/3rdparty/angle/src/libGLESv2/entry_points_gles_3_0.cpp @@ -35,13 +35,12 @@ void GL_APIENTRY ReadBuffer(GLenum mode) Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateReadBuffer(context, mode)) + if (!context->skipValidation() && !ValidateReadBuffer(context, mode)) { return; } - Framebuffer *readFBO = context->getState().getReadFramebuffer(); - readFBO->setReadBuffer(mode); + context->readBuffer(mode); } } @@ -59,7 +58,7 @@ void GL_APIENTRY DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsize return; } - rx::RangeUI indexRange; + IndexRange indexRange; if (!ValidateDrawElements(context, mode, count, type, indices, 0, &indexRange)) { return; @@ -75,7 +74,8 @@ void GL_APIENTRY DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsize // a drawRangeElements call - the GL back-end is free to choose to call drawRangeElements based on the // validated index range. If index validation is removed, adding drawRangeElements to the context interface // should be reconsidered. - Error error = context->drawElements(mode, count, type, indices, 0, indexRange); + Error error = + context->drawRangeElements(mode, start, end, count, type, indices, indexRange); if (error.isError()) { context->recordError(error); @@ -101,15 +101,16 @@ void GL_APIENTRY TexImage3D(GLenum target, GLint level, GLint internalformat, GL } // validateES3TexImageFormat sets the error code if there is an error - if (!ValidateES3TexImageParameters(context, target, level, internalformat, false, false, - 0, 0, 0, width, height, depth, border, format, type, pixels)) + if (!ValidateES3TexImage3DParameters(context, target, level, internalformat, false, false, + 0, 0, 0, width, height, depth, border, format, type, + pixels)) { return; } Extents size(width, height, depth); Texture *texture = context->getTargetTexture(target); - Error error = texture->setImage(target, level, internalformat, size, format, type, context->getState().getUnpackState(), + Error error = texture->setImage(context, target, level, internalformat, size, format, type, reinterpret_cast<const uint8_t *>(pixels)); if (error.isError()) { @@ -136,9 +137,9 @@ void GL_APIENTRY TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint } // validateES3TexImageFormat sets the error code if there is an error - if (!ValidateES3TexImageParameters(context, target, level, GL_NONE, false, true, - xoffset, yoffset, zoffset, width, height, depth, 0, - format, type, pixels)) + if (!ValidateES3TexImage3DParameters(context, target, level, GL_NONE, false, true, xoffset, + yoffset, zoffset, width, height, depth, 0, format, + type, pixels)) { return; } @@ -151,7 +152,7 @@ void GL_APIENTRY TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint Box area(xoffset, yoffset, zoffset, width, height, depth); Texture *texture = context->getTargetTexture(target); - Error error = texture->setSubImage(target, level, area, format, type, context->getState().getUnpackState(), + Error error = texture->setSubImage(context, target, level, area, format, type, reinterpret_cast<const uint8_t *>(pixels)); if (error.isError()) { @@ -170,29 +171,14 @@ void GL_APIENTRY CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GL Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (!ValidateES3CopyTexImageParameters(context, target, level, GL_NONE, true, xoffset, yoffset, zoffset, - x, y, width, height, 0)) + if (!context->skipValidation() && + !ValidateCopyTexSubImage3D(context, target, level, xoffset, yoffset, zoffset, x, y, + width, height)) { return; } - Offset destOffset(xoffset, yoffset, zoffset); - Rectangle sourceArea(x, y, width, height); - - const Framebuffer *framebuffer = context->getState().getReadFramebuffer(); - Texture *texture = context->getTargetTexture(target); - Error error = texture->copySubImage(target, level, destOffset, sourceArea, framebuffer); - if (error.isError()) - { - context->recordError(error); - return; - } + context->copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); } } @@ -206,30 +192,17 @@ void GL_APIENTRY CompressedTexImage3D(GLenum target, GLint level, GLenum interna Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - const InternalFormat &formatInfo = GetInternalFormatInfo(internalformat); - if (imageSize < 0 || static_cast<GLuint>(imageSize) != formatInfo.computeBlockSize(GL_UNSIGNED_BYTE, width, height)) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - - // validateES3TexImageFormat sets the error code if there is an error - if (!ValidateES3TexImageParameters(context, target, level, internalformat, true, false, - 0, 0, 0, width, height, depth, border, GL_NONE, GL_NONE, data)) + if (!ValidateCompressedTexImage3D(context, target, level, internalformat, width, height, + depth, border, imageSize, data)) { return; } Extents size(width, height, depth); Texture *texture = context->getTargetTexture(target); - Error error = texture->setCompressedImage(target, level, internalformat, size, context->getState().getUnpackState(), - reinterpret_cast<const uint8_t *>(data)); + Error error = + texture->setCompressedImage(context, target, level, internalformat, size, imageSize, + reinterpret_cast<const uint8_t *>(data)); if (error.isError()) { context->recordError(error); @@ -268,8 +241,8 @@ void GL_APIENTRY CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffs } // validateES3TexImageFormat sets the error code if there is an error - if (!ValidateES3TexImageParameters(context, target, level, GL_NONE, true, true, - 0, 0, 0, width, height, depth, 0, GL_NONE, GL_NONE, data)) + if (!ValidateES3TexImage3DParameters(context, target, level, GL_NONE, true, true, 0, 0, 0, + width, height, depth, 0, GL_NONE, GL_NONE, data)) { return; } @@ -282,8 +255,9 @@ void GL_APIENTRY CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffs Box area(xoffset, yoffset, zoffset, width, height, depth); Texture *texture = context->getTargetTexture(target); - Error error = texture->setCompressedSubImage(target, level, area, format, context->getState().getUnpackState(), - reinterpret_cast<const uint8_t *>(data)); + Error error = + texture->setCompressedSubImage(context, target, level, area, format, imageSize, + reinterpret_cast<const uint8_t *>(data)); if (error.isError()) { context->recordError(error); @@ -299,15 +273,8 @@ void GL_APIENTRY GenQueries(GLsizei n, GLuint* ids) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (n < 0) + if (!ValidateGenQueries(context, n, ids)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -325,19 +292,12 @@ void GL_APIENTRY DeleteQueries(GLsizei n, const GLuint* ids) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateDeleteQueries(context, n, ids)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - if (n < 0) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - - for (GLsizei i = 0; i < n; i++) + for (int i = 0; i < n; i++) { context->deleteQuery(ids[i]); } @@ -370,12 +330,6 @@ void GL_APIENTRY BeginQuery(GLenum target, GLuint id) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - if (!ValidateBeginQuery(context, target, id)) { return; @@ -397,12 +351,6 @@ void GL_APIENTRY EndQuery(GLenum target) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - if (!ValidateEndQuery(context, target)) { return; @@ -424,28 +372,12 @@ void GL_APIENTRY GetQueryiv(GLenum target, GLenum pname, GLint* params) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateGetQueryiv(context, target, pname, params)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - if (!ValidQueryType(context, target)) - { - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - - switch (pname) - { - case GL_CURRENT_QUERY: - params[0] = static_cast<GLint>(context->getState().getActiveQueryId(target)); - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); - return; - } + context->getQueryiv(target, pname, params); } } @@ -456,52 +388,15 @@ void GL_APIENTRY GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateGetQueryObjectuiv(context, id, pname, params)) { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - Query *queryObject = context->getQuery(id, false, GL_NONE); - - if (!queryObject) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (context->getState().getActiveQueryId(queryObject->getType()) == id) - { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - switch(pname) + Error error = context->getQueryObjectuiv(id, pname, params); + if (error.isError()) { - case GL_QUERY_RESULT_EXT: - { - Error error = queryObject->getResult(params); - if (error.isError()) - { - context->recordError(error); - return; - } - } - break; - - case GL_QUERY_RESULT_AVAILABLE_EXT: - { - Error error = queryObject->isResultAvailable(params); - if (error.isError()) - { - context->recordError(error); - return; - } - } - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); + context->recordError(error); return; } } @@ -548,13 +443,12 @@ void GL_APIENTRY DrawBuffers(GLsizei n, const GLenum* bufs) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!context->skipValidation() && !ValidateDrawBuffers(context, n, bufs)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - DrawBuffersEXT(n, bufs); + context->drawBuffers(n, bufs); } } @@ -675,34 +569,15 @@ void GL_APIENTRY BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint sr Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!context->skipValidation() && + !ValidateBlitFramebuffer(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, + dstY1, mask, filter)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - if (!ValidateBlitFramebufferParameters(context, srcX0, srcY0, srcX1, srcY1, - dstX0, dstY0, dstX1, dstY1, mask, filter, - false)) - { - return; - } - - Framebuffer *readFramebuffer = context->getState().getReadFramebuffer(); - ASSERT(readFramebuffer); - - Framebuffer *drawFramebuffer = context->getState().getDrawFramebuffer(); - ASSERT(drawFramebuffer); - - Rectangle srcArea(srcX0, srcY0, srcX1 - srcX0, srcY1 - srcY0); - Rectangle dstArea(dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0); - - Error error = drawFramebuffer->blit(context->getState(), srcArea, dstArea, mask, filter, readFramebuffer); - if (error.isError()) - { - context->recordError(error); - return; - } + context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); } } @@ -738,37 +613,13 @@ void GL_APIENTRY FramebufferTextureLayer(GLenum target, GLenum attachment, GLuin Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateFramebufferTextureLayer(context, target, attachment, texture, - level, layer)) + if (!context->skipValidation() && + !ValidateFramebufferTextureLayer(context, target, attachment, texture, level, layer)) { return; } - Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); - ASSERT(framebuffer); - - if (texture != 0) - { - Texture *textureObject = context->getTexture(texture); - - ImageIndex index = ImageIndex::MakeInvalid(); - - if (textureObject->getTarget() == GL_TEXTURE_3D) - { - index = ImageIndex::Make3D(level, layer); - } - else - { - ASSERT(textureObject->getTarget() == GL_TEXTURE_2D_ARRAY); - index = ImageIndex::Make2DArray(level, layer); - } - - framebuffer->setTextureAttachment(attachment, textureObject, index); - } - else - { - framebuffer->setNULLAttachment(attachment); - } + context->framebufferTextureLayer(target, attachment, texture, level, layer); } } @@ -816,19 +667,8 @@ void GL_APIENTRY BindVertexArray(GLuint array) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - VertexArray *vao = context->getVertexArray(array); - - if (!vao) + if (!ValidateBindVertexArray(context, array)) { - // The default VAO should always exist - ASSERT(array != 0); - context->recordError(Error(GL_INVALID_OPERATION)); return; } @@ -843,15 +683,8 @@ void GL_APIENTRY DeleteVertexArrays(GLsizei n, const GLuint* arrays) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (n < 0) + if (!ValidateDeleteVertexArrays(context, n)) { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -872,15 +705,8 @@ void GL_APIENTRY GenVertexArrays(GLsizei n, GLuint* arrays) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateGenVertexArrays(context, n)) { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (n < 0) - { - context->recordError(Error(GL_INVALID_VALUE)); return; } @@ -898,9 +724,8 @@ GLboolean GL_APIENTRY IsVertexArray(GLuint array) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateIsVertexArray(context)) { - context->recordError(Error(GL_INVALID_OPERATION)); return GL_FALSE; } @@ -1026,7 +851,7 @@ void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode) TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback(); ASSERT(transformFeedback != NULL); - if (transformFeedback->isStarted()) + if (transformFeedback->isActive()) { context->recordError(Error(GL_INVALID_OPERATION)); return; @@ -1038,7 +863,7 @@ void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode) } else { - transformFeedback->start(primitiveMode); + transformFeedback->begin(primitiveMode); } } } @@ -1059,13 +884,13 @@ void GL_APIENTRY EndTransformFeedback(void) TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback(); ASSERT(transformFeedback != NULL); - if (!transformFeedback->isStarted()) + if (!transformFeedback->isActive()) { context->recordError(Error(GL_INVALID_OPERATION)); return; } - transformFeedback->stop(); + transformFeedback->end(); } } @@ -1126,7 +951,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi // Cannot bind a transform feedback buffer if the current transform feedback is active (3.0.4 pg 91 section 2.15.2) TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback(); - if (curTransformFeedback && curTransformFeedback->isStarted()) + if (curTransformFeedback && curTransformFeedback->isActive()) { context->recordError(Error(GL_INVALID_OPERATION)); return; @@ -1200,7 +1025,7 @@ void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer) { // Cannot bind a transform feedback buffer if the current transform feedback is active (3.0.4 pg 91 section 2.15.2) TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback(); - if (curTransformFeedback && curTransformFeedback->isStarted()) + if (curTransformFeedback && curTransformFeedback->isActive()) { context->recordError(Error(GL_INVALID_OPERATION)); return; @@ -1258,14 +1083,12 @@ void GL_APIENTRY TransformFeedbackVaryings(GLuint program, GLsizei count, const return; } - if (!ValidProgram(context, program)) + Program *programObject = GetValidProgram(context, program); + if (!programObject) { return; } - Program *programObject = context->getProgram(program); - ASSERT(programObject); - programObject->setTransformFeedbackVaryings(count, varyings, bufferMode); } } @@ -1291,14 +1114,12 @@ void GL_APIENTRY GetTransformFeedbackVarying(GLuint program, GLuint index, GLsiz return; } - if (!ValidProgram(context, program)) + Program *programObject = GetValidProgram(context, program); + if (!programObject) { return; } - Program *programObject = context->getProgram(program); - ASSERT(programObject); - if (index >= static_cast<GLuint>(programObject->getTransformFeedbackVaryingCount())) { context->recordError(Error(GL_INVALID_VALUE)); @@ -1714,43 +1535,13 @@ void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* val Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateClearBuffer(context)) - { - return; - } - - switch (buffer) + if (!context->skipValidation() && + !ValidateClearBufferiv(context, buffer, drawbuffer, value)) { - case GL_COLOR: - if (drawbuffer < 0 || static_cast<GLuint>(drawbuffer) >= context->getCaps().maxDrawBuffers) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - break; - - case GL_STENCIL: - if (drawbuffer != 0) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); return; } - Framebuffer *framebufferObject = context->getState().getDrawFramebuffer(); - ASSERT(framebufferObject); - - Error error = framebufferObject->clearBufferiv(context->getState(), buffer, drawbuffer, value); - if (error.isError()) - { - context->recordError(error); - return; - } + context->clearBufferiv(buffer, drawbuffer, value); } } @@ -1762,35 +1553,13 @@ void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* v Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateClearBuffer(context)) + if (!context->skipValidation() && + !ValidateClearBufferuiv(context, buffer, drawbuffer, value)) { return; } - switch (buffer) - { - case GL_COLOR: - if (drawbuffer < 0 || static_cast<GLuint>(drawbuffer) >= context->getCaps().maxDrawBuffers) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - - Framebuffer *framebufferObject = context->getState().getDrawFramebuffer(); - ASSERT(framebufferObject); - - Error error = framebufferObject->clearBufferuiv(context->getState(), buffer, drawbuffer, value); - if (error.isError()) - { - context->recordError(error); - return; - } + context->clearBufferuiv(buffer, drawbuffer, value); } } @@ -1802,43 +1571,13 @@ void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* v Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateClearBuffer(context)) + if (!context->skipValidation() && + !ValidateClearBufferfv(context, buffer, drawbuffer, value)) { return; } - switch (buffer) - { - case GL_COLOR: - if (drawbuffer < 0 || static_cast<GLuint>(drawbuffer) >= context->getCaps().maxDrawBuffers) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - break; - - case GL_DEPTH: - if (drawbuffer != 0) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - - Framebuffer *framebufferObject = context->getState().getDrawFramebuffer(); - ASSERT(framebufferObject); - - Error error = framebufferObject->clearBufferfv(context->getState(), buffer, drawbuffer, value); - if (error.isError()) - { - context->recordError(error); - return; - } + context->clearBufferfv(buffer, drawbuffer, value); } } @@ -1850,35 +1589,13 @@ void GL_APIENTRY ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, G Context *context = GetValidGlobalContext(); if (context) { - if (!ValidateClearBuffer(context)) + if (!context->skipValidation() && + !ValidateClearBufferfi(context, buffer, drawbuffer, depth, stencil)) { return; } - switch (buffer) - { - case GL_DEPTH_STENCIL: - if (drawbuffer != 0) - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } - break; - - default: - context->recordError(Error(GL_INVALID_ENUM)); - return; - } - - Framebuffer *framebufferObject = context->getState().getDrawFramebuffer(); - ASSERT(framebufferObject); - - Error error = framebufferObject->clearBufferfi(context->getState(), buffer, drawbuffer, depth, stencil); - if (error.isError()) - { - context->recordError(error); - return; - } + context->clearBufferfi(buffer, drawbuffer, depth, stencil); } } @@ -1996,20 +1713,11 @@ void GL_APIENTRY GetUniformIndices(GLuint program, GLsizei uniformCount, const G return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (!programObject->isLinked()) @@ -2049,20 +1757,11 @@ void GL_APIENTRY GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } switch (pname) @@ -2120,20 +1819,10 @@ GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program, const GLchar* uniformBlo return GL_INVALID_INDEX; } - Program *programObject = context->getProgram(program); - + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return GL_INVALID_INDEX; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return GL_INVALID_INDEX; - } + return GL_INVALID_INDEX; } return programObject->getUniformBlockIndex(uniformBlockName); @@ -2155,20 +1844,11 @@ void GL_APIENTRY GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockInde context->recordError(Error(GL_INVALID_OPERATION)); return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (uniformBlockIndex >= programObject->getActiveUniformBlockCount()) @@ -2213,20 +1893,11 @@ void GL_APIENTRY GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIn return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } if (uniformBlockIndex >= programObject->getActiveUniformBlockCount()) @@ -2259,20 +1930,11 @@ void GL_APIENTRY UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, G return; } - Program *programObject = context->getProgram(program); + Program *programObject = GetValidProgram(context, program); if (!programObject) { - if (context->getShader(program)) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - else - { - context->recordError(Error(GL_INVALID_VALUE)); - return; - } + return; } // if never linked, there won't be any uniform blocks @@ -2305,7 +1967,7 @@ void GL_APIENTRY DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GL return; } - Error error = context->drawArrays(mode, first, count, instanceCount); + Error error = context->drawArraysInstanced(mode, first, count, instanceCount); if (error.isError()) { context->recordError(error); @@ -2328,13 +1990,14 @@ void GL_APIENTRY DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, return; } - rx::RangeUI indexRange; + IndexRange indexRange; if (!ValidateDrawElementsInstanced(context, mode, count, type, indices, instanceCount, &indexRange)) { return; } - Error error = context->drawElements(mode, count, type, indices, instanceCount, indexRange); + Error error = + context->drawElementsInstanced(mode, count, type, indices, instanceCount, indexRange); if (error.isError()) { context->recordError(error); @@ -2371,7 +2034,7 @@ GLsync GL_APIENTRY FenceSync_(GLenum condition, GLbitfield flags) GLsync fenceSync = context->createFenceSync(); FenceSync *fenceSyncObject = context->getFenceSync(fenceSync); - Error error = fenceSyncObject->set(condition); + Error error = fenceSyncObject->set(condition, flags); if (error.isError()) { context->deleteFenceSync(fenceSync); @@ -2575,7 +2238,7 @@ void GL_APIENTRY GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* { case GL_OBJECT_TYPE: values[0] = static_cast<GLint>(GL_SYNC_FENCE); break; case GL_SYNC_CONDITION: values[0] = static_cast<GLint>(fenceSync->getCondition()); break; - case GL_SYNC_FLAGS: values[0] = 0; break; + case GL_SYNC_FLAGS: values[0] = static_cast<GLint>(fenceSync->getFlags()); break; case GL_SYNC_STATUS: { @@ -3005,16 +2668,18 @@ void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id) { // Cannot bind a transform feedback object if the current one is started and not paused (3.0.2 pg 85 section 2.14.1) TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback(); - if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused()) + if (curTransformFeedback && curTransformFeedback->isActive() && !curTransformFeedback->isPaused()) { context->recordError(Error(GL_INVALID_OPERATION)); return; } // Cannot bind a transform feedback object that does not exist (3.0.2 pg 85 section 2.14.1) - if (context->getTransformFeedback(id) == NULL) + if (!context->isTransformFeedbackGenerated(id)) { - context->recordError(Error(GL_INVALID_OPERATION)); + context->recordError( + Error(GL_INVALID_OPERATION, + "Cannot bind a transform feedback object that does not exist.")); return; } @@ -3082,7 +2747,15 @@ GLboolean GL_APIENTRY IsTransformFeedback(GLuint id) return GL_FALSE; } - return ((context->getTransformFeedback(id) != NULL) ? GL_TRUE : GL_FALSE); + if (id == 0) + { + // The 3.0.4 spec [section 6.1.11] states that if ID is zero, IsTransformFeedback + // returns FALSE + return GL_FALSE; + } + + const TransformFeedback *transformFeedback = context->getTransformFeedback(id); + return ((transformFeedback != nullptr) ? GL_TRUE : GL_FALSE); } return GL_FALSE; @@ -3104,8 +2777,8 @@ void GL_APIENTRY PauseTransformFeedback(void) TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback(); ASSERT(transformFeedback != NULL); - // Current transform feedback must be started and not paused in order to pause (3.0.2 pg 86) - if (!transformFeedback->isStarted() || transformFeedback->isPaused()) + // Current transform feedback must be active and not paused in order to pause (3.0.2 pg 86) + if (!transformFeedback->isActive() || transformFeedback->isPaused()) { context->recordError(Error(GL_INVALID_OPERATION)); return; @@ -3131,8 +2804,8 @@ void GL_APIENTRY ResumeTransformFeedback(void) TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback(); ASSERT(transformFeedback != NULL); - // Current transform feedback must be started and paused in order to resume (3.0.2 pg 86) - if (!transformFeedback->isStarted() || !transformFeedback->isPaused()) + // Current transform feedback must be active and paused in order to resume (3.0.2 pg 86) + if (!transformFeedback->isActive() || !transformFeedback->isPaused()) { context->recordError(Error(GL_INVALID_OPERATION)); return; @@ -3150,14 +2823,20 @@ void GL_APIENTRY GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* leng Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateGetProgramBinary(context, program, bufSize, length, binaryFormat, binary)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - // TODO: Pipe through to the OES extension for now, needs proper validation - return GetProgramBinaryOES(program, bufSize, length, binaryFormat, binary); + Program *programObject = context->getProgram(program); + ASSERT(programObject != nullptr); + + Error error = programObject->saveBinary(binaryFormat, binary, bufSize, length); + if (error.isError()) + { + context->recordError(error); + return; + } } } @@ -3169,14 +2848,20 @@ void GL_APIENTRY ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateProgramBinary(context, program, binaryFormat, binary, length)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - // TODO: Pipe through to the OES extension for now, needs proper validation - return ProgramBinaryOES(program, binaryFormat, binary, length); + Program *programObject = context->getProgram(program); + ASSERT(programObject != nullptr); + + Error error = programObject->loadBinary(binaryFormat, binary, length); + if (error.isError()) + { + context->recordError(error); + return; + } } } @@ -3188,14 +2873,23 @@ void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value) Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!ValidateProgramParameter(context, program, pname, value)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - // glProgramParameteri - UNIMPLEMENTED(); + gl::Program *programObject = context->getProgram(program); + ASSERT(programObject != nullptr); + + switch (pname) + { + case GL_PROGRAM_BINARY_RETRIEVABLE_HINT: + programObject->setBinaryRetrievableHint(value != GL_FALSE); + break; + + default: + UNREACHABLE(); + } } } @@ -3207,29 +2901,13 @@ void GL_APIENTRY InvalidateFramebuffer(GLenum target, GLsizei numAttachments, co Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) - { - context->recordError(Error(GL_INVALID_OPERATION)); - return; - } - - if (!ValidateInvalidateFramebufferParameters(context, target, numAttachments, attachments)) + if (!context->skipValidation() && + !ValidateInvalidateFramebuffer(context, target, numAttachments, attachments)) { return; } - Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); - ASSERT(framebuffer); - - if (framebuffer->checkStatus(context->getData()) == GL_FRAMEBUFFER_COMPLETE) - { - Error error = framebuffer->invalidate(numAttachments, attachments); - if (error.isError()) - { - context->recordError(error); - return; - } - } + context->invalidateFramebuffer(target, numAttachments, attachments); } } @@ -3242,30 +2920,13 @@ void GL_APIENTRY InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, Context *context = GetValidGlobalContext(); if (context) { - if (context->getClientVersion() < 3) + if (!context->skipValidation() && + !ValidateInvalidateFramebuffer(context, target, numAttachments, attachments)) { - context->recordError(Error(GL_INVALID_OPERATION)); return; } - if (!ValidateInvalidateFramebufferParameters(context, target, numAttachments, attachments)) - { - return; - } - - Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target); - ASSERT(framebuffer); - - if (framebuffer->checkStatus(context->getData()) == GL_FRAMEBUFFER_COMPLETE) - { - Rectangle area(x, y, width, height); - Error error = framebuffer->invalidateSub(numAttachments, attachments, area); - if (error.isError()) - { - context->recordError(error); - return; - } - } + context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); } } @@ -3283,7 +2944,8 @@ void GL_APIENTRY TexStorage2D(GLenum target, GLsizei levels, GLenum internalform return; } - if (!ValidateES3TexStorageParameters(context, target, levels, internalformat, width, height, 1)) + if (!ValidateES3TexStorage2DParameters(context, target, levels, internalformat, width, + height, 1)) { return; } @@ -3314,7 +2976,8 @@ void GL_APIENTRY TexStorage3D(GLenum target, GLsizei levels, GLenum internalform return; } - if (!ValidateES3TexStorageParameters(context, target, levels, internalformat, width, height, depth)) + if (!ValidateES3TexStorage3DParameters(context, target, levels, internalformat, width, + height, depth)) { return; } @@ -3369,7 +3032,7 @@ void GL_APIENTRY GetInternalformativ(GLenum target, GLenum internalformat, GLenu case GL_NUM_SAMPLE_COUNTS: if (bufSize != 0) { - *params = formatCaps.sampleCounts.size(); + *params = static_cast<GLint>(formatCaps.sampleCounts.size()); } break; diff --git a/src/3rdparty/angle/src/libGLESv2/global_state.cpp b/src/3rdparty/angle/src/libGLESv2/global_state.cpp index 686f0bf49b..b99c3e1ca9 100644 --- a/src/3rdparty/angle/src/libGLESv2/global_state.cpp +++ b/src/3rdparty/angle/src/libGLESv2/global_state.cpp @@ -55,13 +55,6 @@ Current *AllocateCurrent() return current; } -void DeallocateCurrent() -{ - Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS)); - SafeDelete(current); - SetTLSValue(currentTLS, NULL); -} - Current *GetCurrentData() { // Create a TLS index if one has not been created for this DLL @@ -78,6 +71,14 @@ Current *GetCurrentData() } #ifdef ANGLE_PLATFORM_WINDOWS + +void DeallocateCurrent() +{ + Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS)); + SafeDelete(current); + SetTLSValue(currentTLS, NULL); +} + extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD reason, LPVOID) { switch (reason) diff --git a/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp b/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp index e69e04aa60..42b749f373 100644 --- a/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp +++ b/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp @@ -9,7 +9,6 @@ #include "libGLESv2/entry_points_gles_2_0.h" #include "libGLESv2/entry_points_gles_2_0_ext.h" #include "libGLESv2/entry_points_gles_3_0.h" -#include "libGLESv2/entry_points_gles_3_0_ext.h" #include "common/event_tracer.h" @@ -1256,6 +1255,11 @@ void GL_APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei sa return gl::RenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height); } +void GL_APIENTRY glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) +{ + return gl::DiscardFramebufferEXT(target, numAttachments, attachments); +} + void GL_APIENTRY glDeleteFencesNV(GLsizei n, const GLuint* fences) { return gl::DeleteFencesNV(n, fences); @@ -1346,16 +1350,36 @@ void GL_APIENTRY glEndQueryEXT(GLenum target) return gl::EndQueryEXT(target); } +void GL_APIENTRY glQueryCounterEXT(GLuint id, GLenum target) +{ + return gl::QueryCounterEXT(id, target); +} + void GL_APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params) { return gl::GetQueryivEXT(target, pname, params); } +void GL_APIENTRY glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params) +{ + return gl::GetQueryObjectivEXT(id, pname, params); +} + void GL_APIENTRY glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params) { return gl::GetQueryObjectuivEXT(id, pname, params); } +void GL_APIENTRY glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params) +{ + return gl::GetQueryObjecti64vEXT(id, pname, params); +} + +void GL_APIENTRY glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params) +{ + return gl::GetQueryObjectui64vEXT(id, pname, params); +} + void GL_APIENTRY glDrawBuffersEXT(GLsizei n, const GLenum *bufs) { return gl::DrawBuffersEXT(n, bufs); @@ -1411,11 +1435,131 @@ void GL_APIENTRY glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLs return gl::FlushMappedBufferRangeEXT(target, offset, length); } -void GL_APIENTRY SetTraceFunctionPointers(GetCategoryEnabledFlagFunc getCategoryEnabledFlag, - AddTraceEventFunc addTraceEvent) +void GL_APIENTRY glInsertEventMarkerEXT(GLsizei length, const char *marker) +{ + return gl::InsertEventMarkerEXT(length, marker); +} + +void GL_APIENTRY glPushGroupMarkerEXT(GLsizei length, const char *marker) +{ + return gl::PushGroupMarkerEXT(length, marker); +} + +void GL_APIENTRY glPopGroupMarkerEXT() +{ + return gl::PopGroupMarkerEXT(); +} + +void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + return gl::EGLImageTargetTexture2DOES(target, image); +} + +void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) +{ + return gl::EGLImageTargetRenderbufferStorageOES(target, image); +} + +void GL_APIENTRY glBindVertexArrayOES(GLuint array) +{ + return gl::BindVertexArrayOES(array); +} + +void GL_APIENTRY glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) +{ + return gl::DeleteVertexArraysOES(n, arrays); +} + +void GL_APIENTRY glGenVertexArraysOES(GLsizei n, GLuint *arrays) { - gl::g_getCategoryEnabledFlag = getCategoryEnabledFlag; - gl::g_addTraceEvent = addTraceEvent; + return gl::GenVertexArraysOES(n, arrays); } +GLboolean GL_APIENTRY glIsVertexArrayOES(GLuint array) +{ + return gl::IsVertexArrayOES(array); +} + +void GL_APIENTRY glDebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled) +{ + return gl::DebugMessageControlKHR(source, type, severity, count, ids, enabled); +} + +void GL_APIENTRY glDebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf) +{ + return gl::DebugMessageInsertKHR(source, type, id, severity, length, buf); +} + +void GL_APIENTRY glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam) +{ + return gl::DebugMessageCallbackKHR(callback, userParam); +} + +GLuint GL_APIENTRY glGetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog) +{ + return gl::GetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths, + messageLog); +} + +void GL_APIENTRY glPushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar *message) +{ + return gl::PushDebugGroupKHR(source, id, length, message); +} + +void GL_APIENTRY glPopDebugGroupKHR(void) +{ + return gl::PopDebugGroupKHR(); +} + +void GL_APIENTRY glObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label) +{ + return gl::ObjectLabelKHR(identifier, name, length, label); +} + +void GL_APIENTRY +glGetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + return gl::GetObjectLabelKHR(identifier, name, bufSize, length, label); +} + +void GL_APIENTRY glObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label) +{ + return gl::ObjectPtrLabelKHR(ptr, length, label); +} + +void GL_APIENTRY glGetObjectPtrLabelKHR(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + return gl::GetObjectPtrLabelKHR(ptr, bufSize, length, label); +} + +void GL_APIENTRY glGetPointervKHR(GLenum pname, void **params) +{ + return gl::GetPointervKHR(pname, params); +} } diff --git a/src/3rdparty/angle/src/libGLESv2/libGLESv2.def b/src/3rdparty/angle/src/libGLESv2/libGLESv2.def index 9c6dc497d0..0aebb6c864 100644 --- a/src/3rdparty/angle/src/libGLESv2/libGLESv2.def +++ b/src/3rdparty/angle/src/libGLESv2/libGLESv2.def @@ -177,6 +177,31 @@ EXPORTS glGetBufferPointervOES @287 glMapBufferRangeEXT @288 glFlushMappedBufferRangeEXT @289 + glDiscardFramebufferEXT @293 + glInsertEventMarkerEXT @294 + glPushGroupMarkerEXT @295 + glPopGroupMarkerEXT @296 + glEGLImageTargetTexture2DOES @297 + glEGLImageTargetRenderbufferStorageOES @298 + glBindVertexArrayOES @299 + glDeleteVertexArraysOES @300 + glGenVertexArraysOES @301 + glIsVertexArrayOES @302 + glDebugMessageControlKHR @303 + glDebugMessageInsertKHR @304 + glDebugMessageCallbackKHR @305 + glGetDebugMessageLogKHR @306 + glPushDebugGroupKHR @307 + glPopDebugGroupKHR @308 + glObjectLabelKHR @309 + glGetObjectLabelKHR @310 + glObjectPtrLabelKHR @311 + glGetObjectPtrLabelKHR @312 + glGetPointervKHR @313 + glQueryCounterEXT @314 + glGetQueryObjectivEXT @315 + glGetQueryObjecti64vEXT @316 + glGetQueryObjectui64vEXT @317 ; GLES 3.0 Functions glReadBuffer @180 @@ -284,5 +309,7 @@ EXPORTS glTexStorage3D @282 glGetInternalformativ @283 - ; Setting up TRACE macro callbacks - SetTraceFunctionPointers @284 + ; ANGLE Platform Implementation + ANGLEPlatformCurrent @290 + ANGLEPlatformInitialize @291 + ANGLEPlatformShutdown @292 diff --git a/src/3rdparty/angle/src/libGLESv2/libGLESv2_mingw32.def b/src/3rdparty/angle/src/libGLESv2/libGLESv2_mingw32.def index e02b85bcf2..db17bb487b 100644 --- a/src/3rdparty/angle/src/libGLESv2/libGLESv2_mingw32.def +++ b/src/3rdparty/angle/src/libGLESv2/libGLESv2_mingw32.def @@ -177,6 +177,31 @@ EXPORTS glGetBufferPointervOES@12 @287 glMapBufferRangeEXT@16 @288 glFlushMappedBufferRangeEXT@12 @289 + glDiscardFramebufferEXT@12 @293 + glInsertEventMarkerEXT@8 @294 + glPushGroupMarkerEXT@8 @295 + glPopGroupMarkerEXT@0 @296 + glEGLImageTargetTexture2DOES@8 @297 + glEGLImageTargetRenderbufferStorageOES@8 @298 + glBindVertexArrayOES@4 @299 + glDeleteVertexArraysOES@8 @300 + glGenVertexArraysOES@8 @301 + glIsVertexArrayOES@4 @302 + glDebugMessageControlKHR@24 @303 + glDebugMessageInsertKHR@24 @304 + glDebugMessageCallbackKHR@8 @305 + glGetDebugMessageLogKHR@32 @306 + glPushDebugGroupKHR@16 @307 + glPopDebugGroupKHR@0 @308 + glObjectLabelKHR@16 @309 + glGetObjectLabelKHR@20 @310 + glObjectPtrLabelKHR@12 @311 + glGetObjectPtrLabelKHR@16 @312 + glGetPointervKHR@8 @313 + glQueryCounterEXT@8 @314 + glGetQueryObjectivEXT@12 @315 + glGetQueryObjecti64vEXT@12 @316 + glGetQueryObjectui64vEXT@12 @317 ; GLES 3.0 Functions glReadBuffer@4 @180 @@ -284,5 +309,8 @@ EXPORTS glTexStorage3D@24 @282 glGetInternalformativ@20 @283 - ; Setting up TRACE macro callbacks - SetTraceFunctionPointers@8 @284 + ; ANGLE Platform Implementation + ANGLEPlatformCurrent@0 @290 + ANGLEPlatformInitialize@4 @291 + ANGLEPlatformShutdown@0 @292 +
\ No newline at end of file diff --git a/src/3rdparty/angle/src/libGLESv2/libGLESv2d.def b/src/3rdparty/angle/src/libGLESv2/libGLESv2d.def index d35309c6ce..e0c3823abf 100644 --- a/src/3rdparty/angle/src/libGLESv2/libGLESv2d.def +++ b/src/3rdparty/angle/src/libGLESv2/libGLESv2d.def @@ -177,6 +177,31 @@ EXPORTS glGetBufferPointervOES @287 glMapBufferRangeEXT @288 glFlushMappedBufferRangeEXT @289 + glDiscardFramebufferEXT @293 + glInsertEventMarkerEXT @294 + glPushGroupMarkerEXT @295 + glPopGroupMarkerEXT @296 + glEGLImageTargetTexture2DOES @297 + glEGLImageTargetRenderbufferStorageOES @298 + glBindVertexArrayOES @299 + glDeleteVertexArraysOES @300 + glGenVertexArraysOES @301 + glIsVertexArrayOES @302 + glDebugMessageControlKHR @303 + glDebugMessageInsertKHR @304 + glDebugMessageCallbackKHR @305 + glGetDebugMessageLogKHR @306 + glPushDebugGroupKHR @307 + glPopDebugGroupKHR @308 + glObjectLabelKHR @309 + glGetObjectLabelKHR @310 + glObjectPtrLabelKHR @311 + glGetObjectPtrLabelKHR @312 + glGetPointervKHR @313 + glQueryCounterEXT @314 + glGetQueryObjectivEXT @315 + glGetQueryObjecti64vEXT @316 + glGetQueryObjectui64vEXT @317 ; GLES 3.0 Functions glReadBuffer @180 @@ -284,5 +309,7 @@ EXPORTS glTexStorage3D @282 glGetInternalformativ @283 - ; Setting up TRACE macro callbacks - SetTraceFunctionPointers @284 + ; ANGLE Platform Implementation + ANGLEPlatformCurrent @290 + ANGLEPlatformInitialize @291 + ANGLEPlatformShutdown @292 diff --git a/src/3rdparty/angle/src/libGLESv2/libGLESv2d_mingw32.def b/src/3rdparty/angle/src/libGLESv2/libGLESv2d_mingw32.def index e2b2c333a1..5a4966f66d 100644 --- a/src/3rdparty/angle/src/libGLESv2/libGLESv2d_mingw32.def +++ b/src/3rdparty/angle/src/libGLESv2/libGLESv2d_mingw32.def @@ -177,6 +177,31 @@ EXPORTS glGetBufferPointervOES@12 @287 glMapBufferRangeEXT@16 @288 glFlushMappedBufferRangeEXT@12 @289 + glDiscardFramebufferEXT@12 @293 + glInsertEventMarkerEXT@8 @294 + glPushGroupMarkerEXT@8 @295 + glPopGroupMarkerEXT@0 @296 + glEGLImageTargetTexture2DOES@8 @297 + glEGLImageTargetRenderbufferStorageOES@8 @298 + glBindVertexArrayOES@4 @299 + glDeleteVertexArraysOES@8 @300 + glGenVertexArraysOES@8 @301 + glIsVertexArrayOES@4 @302 + glDebugMessageControlKHR@24 @303 + glDebugMessageInsertKHR@24 @304 + glDebugMessageCallbackKHR@8 @305 + glGetDebugMessageLogKHR@32 @306 + glPushDebugGroupKHR@16 @307 + glPopDebugGroupKHR@0 @308 + glObjectLabelKHR@16 @309 + glGetObjectLabelKHR@20 @310 + glObjectPtrLabelKHR@12 @311 + glGetObjectPtrLabelKHR@16 @312 + glGetPointervKHR@8 @313 + glQueryCounterEXT@8 @314 + glGetQueryObjectivEXT@12 @315 + glGetQueryObjecti64vEXT@12 @316 + glGetQueryObjectui64vEXT@12 @317 ; GLES 3.0 Functions glReadBuffer@4 @180 @@ -284,5 +309,8 @@ EXPORTS glTexStorage3D@24 @282 glGetInternalformativ@20 @283 - ; Setting up TRACE macro callbacks - SetTraceFunctionPointers@8 @284 + ; ANGLE Platform Implementation + ANGLEPlatformCurrent@0 @290 + ANGLEPlatformInitialize@4 @291 + ANGLEPlatformShutdown@0 @292 +
\ No newline at end of file |