/******************************************************************************

* The MIT License (MIT)

*

* Copyright (c) 2015-2017 Baldur Karlsson

* Copyright (c) 2014 Crytek

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

******************************************************************************/

#include "gl_common.h"

#include "core/core.h"

#include "serialise/string_utils.h"

#include "gl_driver.h"

bool HasExt[GLExtension_Count] = {};

bool VendorCheck[VendorCheck_Count] = {};

int GLCoreVersion = 0;

bool GLIsCore = false;

bool IsGLES = false;

bool CheckReplayContext(PFNGLGETSTRINGPROC getStr, PFNGLGETINTEGERVPROC getInt,

PFNGLGETSTRINGIPROC getStri)

{

// we can't do without these extensions, but they should be present on any reasonable driver

// as they should have minimal or no hardware requirement. They were present on mesa 10.6

// for all drivers which dates to mid 2015.

#undef EXT_TO_CHECK

#define EXT_TO_CHECK(ver, glesver, ext) ext,

enum

{

EXTENSION_CHECKS() ext_count,

};

bool exts[ext_count] = {};

if(getStr)

RDCLOG("Running GL replay on: %s / %s / %s", getStr(eGL_VENDOR), getStr(eGL_RENDERER),

getStr(eGL_VERSION));

string extensionString = "";

GLint numExts = 0;

getInt(eGL_NUM_EXTENSIONS, &numExts);

for(GLint e = 0; e < numExts; e++)

{

const char *ext = (const char *)getStri(eGL_EXTENSIONS, (GLuint)e);

extensionString += StringFormat::Fmt("[%d]: %s, ", e, ext);

if(e > 0 && (e % 100) == 0)

{

RDCLOG("%s", extensionString.c_str());

extensionString = "";

}

// skip the "GL_"

ext += 3;

#undef EXT_TO_CHECK

#define EXT_TO_CHECK(ver, glesver, extname) \

if((!IsGLES && GLCoreVersion >= ver) || (IsGLES && GLCoreVersion >= glesver) || \

!strcmp(ext, STRINGIZE(extname))) \

exts[extname] = true;

EXTENSION_CHECKS()

}

if(!extensionString.empty())

RDCLOG("%s", extensionString.c_str());

string missingExts = "";

#define REQUIRE_EXTENSION(extname) \

if(!exts[extname]) \

missingExts += STRINGIZE(extname) " ";

// we require the below extensions on top of a 3.2 context. Some of these we could in theory

// do without, but support for them is so widespread it's not worthwhile

// used for reflecting out vertex bindings with most generality and remapping from old-style

// Pointer functions

// Should be possible to remove by falling back to reflecting vertex bindings the old way only and

// remapping to 'fake' new-style bindings for representing in the UI

REQUIRE_EXTENSION(ARB_vertex_attrib_binding);

// for program introspection, needed for shader reflection.

// Possible to remove by compiling shaders to SPIR-V and reflecting ourselves.

REQUIRE_EXTENSION(ARB_program_interface_query);

// strangely, this is the extension needed for layout(binding = X) on uniforms, textures, etc.

// Possible to remove by #defining out the layout specifiers and manually setting the uniform

// values.

REQUIRE_EXTENSION(ARB_shading_language_420pack);

// needed for program pipelines, glProgramUniform*, and reflecting shaders on their own

// Possible to remove this with self-compiled SPIR-V for reflection - see above. Likewise

// convenience for our own pipelines when replacing single shaders or such.

REQUIRE_EXTENSION(ARB_separate_shader_objects);

// needed for layout(location = X) on fragment shader outputs

// similar to ARB_shading_language_420pack we could do without this by assigning locations in code

REQUIRE_EXTENSION(ARB_explicit_attrib_location);

// adds sampler objects so we can swap sampling behaviour when sampling from the capture's

// textures

// Possible to remove by manually pushing and popping all of the sampler state that we're

// interested in on each texture instead of binding sampler objects.

REQUIRE_EXTENSION(ARB_sampler_objects);

if(!missingExts.empty())

{

RDCERR("RenderDoc requires these missing extensions: %s. Try updating your drivers.",

missingExts.c_str());

return true;

}

return false;

}

bool ValidateFunctionPointers(const GLHookSet &real)

{

PFNGLGETSTRINGPROC *ptrs = (PFNGLGETSTRINGPROC *)&real;

size_t num = sizeof(real) / sizeof(PFNGLGETSTRINGPROC);

RDCLOG("Function pointers available:");

for(size_t ptr = 0; ptr < num;)

{

uint64_t ptrmask = 0;

for(size_t j = 0; j < 64; j++)

if(ptr + j < num && ptrs[ptr + j])

ptrmask |= 1ULL << (63 - j);

ptr += 64;

RDCLOG("%064llb", ptrmask);

}

// check for the presence of GL functions we will call unconditionally as part of the replay

// process.

// Other functions that are only called to deserialise are checked for presence separately

bool ret = true;

#define CHECK_PRESENT(func) \

if(!real.func) \

{ \

RDCERR( \

"Missing function %s, required for replay. RenderDoc requires a 3.2 context, " \

"and a handful of extensions, see the Documentation.", \

#func); \

ret = false; \

}

// these functions should all be present as part of a 3.2 context plus the extensions we require,

// but let's just be extra-careful

// both GL and GLES, some of them are emulated

CHECK_PRESENT(glActiveTexture)

CHECK_PRESENT(glAttachShader)

CHECK_PRESENT(glBeginQuery)

CHECK_PRESENT(glBindAttribLocation)

CHECK_PRESENT(glBindBuffer)

CHECK_PRESENT(glBindBufferBase)

CHECK_PRESENT(glBindBufferRange)

CHECK_PRESENT(glBindFramebuffer)

CHECK_PRESENT(glBindProgramPipeline)

CHECK_PRESENT(glBindSampler)

CHECK_PRESENT(glBindTexture)

CHECK_PRESENT(glBindVertexArray)

CHECK_PRESENT(glBindVertexBuffer)

CHECK_PRESENT(glBlendColor)

CHECK_PRESENT(glBlendEquationSeparate)

CHECK_PRESENT(glBlendFunc)

CHECK_PRESENT(glBlendFuncSeparate)

CHECK_PRESENT(glBlitFramebuffer)

CHECK_PRESENT(glBufferData)

CHECK_PRESENT(glBufferSubData)

CHECK_PRESENT(glClearBufferData)

CHECK_PRESENT(glClearBufferfi)

CHECK_PRESENT(glClearBufferfv)

CHECK_PRESENT(glClearBufferiv)

CHECK_PRESENT(glClearBufferuiv)

CHECK_PRESENT(glClearColor)

CHECK_PRESENT(glClearDepthf)

CHECK_PRESENT(glColorMaski)

CHECK_PRESENT(glCompileShader)

CHECK_PRESENT(glCopyImageSubData)

CHECK_PRESENT(glCreateProgram)

CHECK_PRESENT(glCreateShader)

CHECK_PRESENT(glCreateShaderProgramv)

CHECK_PRESENT(glCullFace)

CHECK_PRESENT(glDeleteBuffers)

CHECK_PRESENT(glDeleteFramebuffers)

CHECK_PRESENT(glDeleteProgram)

CHECK_PRESENT(glDeleteProgramPipelines)

CHECK_PRESENT(glDeleteQueries)

CHECK_PRESENT(glDeleteSamplers)

CHECK_PRESENT(glDeleteShader)

CHECK_PRESENT(glDeleteTextures)

CHECK_PRESENT(glDeleteVertexArrays)

CHECK_PRESENT(glDepthFunc)

CHECK_PRESENT(glDepthMask)

CHECK_PRESENT(glDetachShader)

CHECK_PRESENT(glDisable)

CHECK_PRESENT(glDisablei)

CHECK_PRESENT(glDisableVertexAttribArray)

CHECK_PRESENT(glDrawArrays)

CHECK_PRESENT(glDrawArraysInstanced)

CHECK_PRESENT(glDrawBuffers)

CHECK_PRESENT(glDrawElements)

CHECK_PRESENT(glDrawElementsBaseVertex)

CHECK_PRESENT(glEnable)

CHECK_PRESENT(glEnablei)

CHECK_PRESENT(glEnableVertexAttribArray)

CHECK_PRESENT(glEndQuery)

CHECK_PRESENT(glFramebufferTexture)

CHECK_PRESENT(glFramebufferTexture2D)

CHECK_PRESENT(glFramebufferTextureLayer)

CHECK_PRESENT(glFrontFace)

CHECK_PRESENT(glGenBuffers)

CHECK_PRESENT(glGenFramebuffers)

CHECK_PRESENT(glGenProgramPipelines)

CHECK_PRESENT(glGenQueries)

CHECK_PRESENT(glGenSamplers)

CHECK_PRESENT(glGenTextures)

CHECK_PRESENT(glGenVertexArrays)

CHECK_PRESENT(glGetActiveUniformBlockiv)

CHECK_PRESENT(glGetAttribLocation)

CHECK_PRESENT(glGetBooleani_v)

CHECK_PRESENT(glGetBooleanv)

CHECK_PRESENT(glGetBufferParameteriv)

CHECK_PRESENT(glGetBufferSubData)

CHECK_PRESENT(glGetError)

CHECK_PRESENT(glGetFloatv)

CHECK_PRESENT(glGetFragDataLocation)

CHECK_PRESENT(glGetFramebufferAttachmentParameteriv)

CHECK_PRESENT(glGetInteger64i_v)

CHECK_PRESENT(glGetIntegeri_v)

CHECK_PRESENT(glGetIntegerv)

CHECK_PRESENT(glGetInternalformativ)

CHECK_PRESENT(glGetProgramInfoLog)

CHECK_PRESENT(glGetProgramInterfaceiv)

CHECK_PRESENT(glGetProgramiv)

CHECK_PRESENT(glGetProgramPipelineiv)

CHECK_PRESENT(glGetProgramResourceIndex)

CHECK_PRESENT(glGetProgramResourceiv)

CHECK_PRESENT(glGetProgramResourceName)

CHECK_PRESENT(glGetQueryObjectuiv)

CHECK_PRESENT(glGetSamplerParameterfv)

CHECK_PRESENT(glGetSamplerParameteriv)

CHECK_PRESENT(glGetShaderInfoLog)

CHECK_PRESENT(glGetShaderiv)

CHECK_PRESENT(glGetString)

CHECK_PRESENT(glGetStringi)

CHECK_PRESENT(glGetTexImage)

CHECK_PRESENT(glGetTexLevelParameteriv)

CHECK_PRESENT(glGetTexParameterfv)

CHECK_PRESENT(glGetTexParameteriv)

CHECK_PRESENT(glGetUniformBlockIndex)

CHECK_PRESENT(glGetUniformfv)

CHECK_PRESENT(glGetUniformiv)

CHECK_PRESENT(glGetUniformLocation)

CHECK_PRESENT(glGetUniformuiv)

CHECK_PRESENT(glGetVertexAttribfv)

CHECK_PRESENT(glGetVertexAttribiv)

CHECK_PRESENT(glHint)

CHECK_PRESENT(glIsEnabled)

CHECK_PRESENT(glIsEnabledi)

CHECK_PRESENT(glLineWidth)

CHECK_PRESENT(glLinkProgram)

CHECK_PRESENT(glMapBufferRange)

CHECK_PRESENT(glPixelStorei)

CHECK_PRESENT(glPolygonOffset)

CHECK_PRESENT(glProgramParameteri)

CHECK_PRESENT(glProgramUniform1fv)

CHECK_PRESENT(glProgramUniform1iv)

CHECK_PRESENT(glProgramUniform1ui)

CHECK_PRESENT(glProgramUniform1uiv)

CHECK_PRESENT(glProgramUniform2fv)

CHECK_PRESENT(glProgramUniform2iv)

CHECK_PRESENT(glProgramUniform2uiv)

CHECK_PRESENT(glProgramUniform3fv)

CHECK_PRESENT(glProgramUniform3iv)

CHECK_PRESENT(glProgramUniform3uiv)

CHECK_PRESENT(glProgramUniform4fv)

CHECK_PRESENT(glProgramUniform4iv)

CHECK_PRESENT(glProgramUniform4ui)

CHECK_PRESENT(glProgramUniform4uiv)

CHECK_PRESENT(glProgramUniformMatrix2fv)

CHECK_PRESENT(glProgramUniformMatrix2x3fv)

CHECK_PRESENT(glProgramUniformMatrix2x4fv)

CHECK_PRESENT(glProgramUniformMatrix3fv)

CHECK_PRESENT(glProgramUniformMatrix3x2fv)

CHECK_PRESENT(glProgramUniformMatrix3x4fv)

CHECK_PRESENT(glProgramUniformMatrix4fv)

CHECK_PRESENT(glProgramUniformMatrix4x2fv)

CHECK_PRESENT(glProgramUniformMatrix4x3fv)

CHECK_PRESENT(glReadBuffer)

CHECK_PRESENT(glReadPixels)

CHECK_PRESENT(glSampleCoverage)

CHECK_PRESENT(glSampleMaski)

CHECK_PRESENT(glSamplerParameteri)

CHECK_PRESENT(glShaderSource)

CHECK_PRESENT(glStencilFuncSeparate)

CHECK_PRESENT(glStencilMask)

CHECK_PRESENT(glStencilMaskSeparate)

CHECK_PRESENT(glStencilOpSeparate)

CHECK_PRESENT(glTexImage2D)

CHECK_PRESENT(glTexParameteri)

CHECK_PRESENT(glUniform1i)

CHECK_PRESENT(glUniform1ui)

CHECK_PRESENT(glUniform2f)

CHECK_PRESENT(glUniform2fv)

CHECK_PRESENT(glUniform4fv)

CHECK_PRESENT(glUniformBlockBinding)

CHECK_PRESENT(glUniformMatrix4fv)

CHECK_PRESENT(glUnmapBuffer)

CHECK_PRESENT(glUseProgram)

CHECK_PRESENT(glUseProgramStages)

CHECK_PRESENT(glVertexAttrib4fv)

CHECK_PRESENT(glVertexAttribBinding)

CHECK_PRESENT(glVertexAttribFormat)

CHECK_PRESENT(glVertexAttribIFormat)

CHECK_PRESENT(glVertexAttribPointer)

CHECK_PRESENT(glVertexBindingDivisor)

CHECK_PRESENT(glViewport)

// GL only

if(!IsGLES)

{

CHECK_PRESENT(glBindFragDataLocation)

CHECK_PRESENT(glEndConditionalRender)

CHECK_PRESENT(glFramebufferTexture3D)

CHECK_PRESENT(glGetCompressedTexImage)

CHECK_PRESENT(glGetDoublev)

CHECK_PRESENT(glGetUniformdv)

CHECK_PRESENT(glLogicOp)

CHECK_PRESENT(glPointParameterf)

CHECK_PRESENT(glPointParameteri)

CHECK_PRESENT(glPointSize)

CHECK_PRESENT(glPolygonMode)

CHECK_PRESENT(glPrimitiveRestartIndex)

CHECK_PRESENT(glProgramUniform1dv)

CHECK_PRESENT(glProgramUniform2dv)

CHECK_PRESENT(glProgramUniform3dv)

CHECK_PRESENT(glProgramUniform4dv)

CHECK_PRESENT(glProgramUniformMatrix2dv)

CHECK_PRESENT(glProgramUniformMatrix2x3dv)

CHECK_PRESENT(glProgramUniformMatrix2x4dv)

CHECK_PRESENT(glProgramUniformMatrix3dv)

CHECK_PRESENT(glProgramUniformMatrix3x2dv)

CHECK_PRESENT(glProgramUniformMatrix3x4dv)

CHECK_PRESENT(glProgramUniformMatrix4dv)

CHECK_PRESENT(glProgramUniformMatrix4x2dv)

CHECK_PRESENT(glProgramUniformMatrix4x3dv)

CHECK_PRESENT(glProvokingVertex)

CHECK_PRESENT(glVertexAttribLFormat)

}

// other functions are either checked for presence explicitly (like

// depth bounds or polygon offset clamp EXT functions), or they are

// only called when such a call is serialised from the logfile, and

// so they are checked for validity separately.

return ret;

}

void CheckExtensions(const GLHookSet &gl)

{

GLint numExts = 0;

if(gl.glGetIntegerv)

gl.glGetIntegerv(eGL_NUM_EXTENSIONS, &numExts);

RDCEraseEl(HasExt);

if(gl.glGetString)

{

const char *vendor = (const char *)gl.glGetString(eGL_VENDOR);

const char *renderer = (const char *)gl.glGetString(eGL_RENDERER);

const char *version = (const char *)gl.glGetString(eGL_VERSION);

// check whether we are using OpenGL ES

// GL_VERSION for OpenGL ES:

// "OpenGL ES N.M vendor-specific information"

if(strncmp(version, "OpenGL ES", 9) == 0)

{

IsGLES = true;

int mj = int(version[10] - '0');

int mn = int(version[12] - '0');

GLCoreVersion = mj * 10 + mn;

}

RDCLOG("Vendor checks for %u (%s / %s / %s)", GLCoreVersion, vendor, renderer, version);

}

if(gl.glGetStringi)

{

for(int i = 0; i < numExts; i++)

{

const char *ext = (const char *)gl.glGetStringi(eGL_EXTENSIONS, (GLuint)i);

if(ext == NULL || !ext[0] || !ext[1] || !ext[2] || !ext[3])

continue;

ext += 3;

#undef EXT_TO_CHECK

#define EXT_TO_CHECK(ver, glesver, extname) \

if((!IsGLES && GLCoreVersion >= ver) || !strcmp(ext, STRINGIZE(extname))) \

HasExt[extname] = true;

EXTENSION_CHECKS()

if(IsGLES)

{

#define EXT_COMP_CHECK(extname, glesextname) \

if(!strcmp(ext, STRINGIZE(glesextname))) \

HasExt[extname] = true;

EXTENSION_COMPATIBILITY_CHECKS()

}

}

}

if(IsGLES)

{

#undef EXT_TO_CHECK

#define EXT_TO_CHECK(ver, glesver, extname) \

if(GLCoreVersion >= glesver) \

HasExt[extname] = true;

EXTENSION_CHECKS()

}

}

void DoVendorChecks(const GLHookSet &gl, GLPlatform &platform, GLWindowingData context)

{

const char *vendor = "";

if(gl.glGetString)

vendor = (const char *)gl.glGetString(eGL_VENDOR);

//////////////////////////////////////////////////////////

// version/driver/vendor specific hacks and checks go here

// doing these in a central place means they're all documented and

// can be removed ASAP from a single place.

// It also means any work done to figure them out is only ever done

// in one place, when first activating a new context, so hopefully

// shouldn't interfere with the running program

// The linux AMD driver doesn't recognise GL_VERTEX_BINDING_BUFFER.

// However it has a "two wrongs make a right" type deal. Instead of returning the buffer that the

// i'th index is bound to (as above, vbslot) for GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, it returns

// the i'th

// vertex buffer which is exactly what we wanted from GL_VERTEX_BINDING_BUFFER!

// see: http://devgurus.amd.com/message/1306745#1306745

RDCEraseEl(VendorCheck);

if(gl.glGetError && gl.glGetIntegeri_v)

{

// clear all error flags.

GLenum err = eGL_NONE;

ClearGLErrors(gl);

GLint dummy = 0;

gl.glGetIntegeri_v(eGL_VERTEX_BINDING_BUFFER, 0, &dummy);

err = gl.glGetError();

if(err != eGL_NONE)

{

// if we got an error trying to query that, we should enable this hack

VendorCheck[VendorCheck_AMD_vertex_buffer_query] = true;

RDCWARN("Using AMD hack to avoid GL_VERTEX_BINDING_BUFFER");

}

}

if(gl.glGetIntegerv && gl.glGetError && !IsGLES)

{

// NOTE: in case of OpenGL ES the GL_NV_polygon_mode extension can be used, however even if the

// driver reports that the extension is supported, it always throws errors when we try to use it

// (at least with the current NVIDIA driver)

// clear all error flags.

GLenum err = eGL_NONE;

ClearGLErrors(gl);

GLint dummy[2] = {0};

gl.glGetIntegerv(eGL_POLYGON_MODE, dummy);

err = gl.glGetError();

if(err != eGL_NONE)

{

// if we got an error trying to query that, we should enable this hack

VendorCheck[VendorCheck_AMD_polygon_mode_query] = true;

RDCWARN("Using AMD hack to avoid GL_POLYGON_MODE");

}

}

// AMD throws an error if we try to copy the mips that are smaller than 4x4.

//

// Intel seems to completely break everything if we even run this check, so we just

// skip this check and assume the hack is enabled.

if(!strcmp(vendor, "Intel") || !strcmp(vendor, "intel") || !strcmp(vendor, "INTEL"))

{

RDCWARN("Using super hack-on-a-hack to avoid glCopyImageSubData tests on intel.");

VendorCheck[VendorCheck_AMD_copy_compressed_tinymips] = true;

VendorCheck[VendorCheck_AMD_copy_compressed_cubemaps] = true;

}

else if(gl.glGetError && gl.glGenTextures && gl.glBindTexture && gl.glCopyImageSubData &&

gl.glTexStorage2D && gl.glTexSubImage2D && gl.glTexParameteri && gl.glDeleteTextures &&

HasExt[ARB_copy_image] && HasExt[ARB_texture_storage] && !IsGLES)

{

GLuint texs[2];

gl.glGenTextures(2, texs);

gl.glBindTexture(eGL_TEXTURE_2D, texs[0]);

gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 1, 1);

gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAX_LEVEL, 0);

gl.glBindTexture(eGL_TEXTURE_2D, texs[1]);

gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 1, 1);

gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAX_LEVEL, 0);

// clear all error flags.

GLenum err = eGL_NONE;

ClearGLErrors(gl);

gl.glCopyImageSubData(texs[0], eGL_TEXTURE_2D, 0, 0, 0, 0, texs[1], eGL_TEXTURE_2D, 0, 0, 0, 0,

1, 1, 1);

err = gl.glGetError();

if(err != eGL_NONE)

{

// if we got an error trying to query that, we should enable this hack

VendorCheck[VendorCheck_AMD_copy_compressed_tinymips] = true;

RDCWARN("Using hack to avoid glCopyImageSubData on lowest mips of compressed texture");

}

gl.glBindTexture(eGL_TEXTURE_2D, 0);

gl.glDeleteTextures(2, texs);

ClearGLErrors(gl);

//////////////////////////////////////////////////////////////////////////

// Check copying cubemaps

gl.glGenTextures(2, texs);

const size_t dim = 32;

char buf[dim * dim / 2];

gl.glBindTexture(eGL_TEXTURE_CUBE_MAP, texs[0]);

gl.glTexStorage2D(eGL_TEXTURE_CUBE_MAP, 1, eGL_COMPRESSED_RGBA_S3TC_DXT1_EXT, dim, dim);

gl.glTexParameteri(eGL_TEXTURE_CUBE_MAP, eGL_TEXTURE_MAX_LEVEL, 0);

for(int i = 0; i < 6; i++)

{

memset(buf, 0xba + i, sizeof(buf));

gl.glCompressedTexSubImage2D(GLenum(eGL_TEXTURE_CUBE_MAP_POSITIVE_X + i), 0, 0, 0, dim, dim,

eGL_COMPRESSED_RGBA_S3TC_DXT1_EXT, dim * dim / 2, buf);

}

gl.glBindTexture(eGL_TEXTURE_CUBE_MAP, texs[1]);

gl.glTexStorage2D(eGL_TEXTURE_CUBE_MAP, 1, eGL_COMPRESSED_RGBA_S3TC_DXT1_EXT, dim, dim);

gl.glTexParameteri(eGL_TEXTURE_CUBE_MAP, eGL_TEXTURE_MAX_LEVEL, 0);

gl.glCopyImageSubData(texs[0], eGL_TEXTURE_CUBE_MAP, 0, 0, 0, 0, texs[1], eGL_TEXTURE_CUBE_MAP,

0, 0, 0, 0, dim, dim, 6);

char cmp[dim * dim / 2];

gl.glBindTexture(eGL_TEXTURE_CUBE_MAP, texs[0]);

for(int i = 0; i < 6; i++)

{

memset(buf, 0xba + i, sizeof(buf));

RDCEraseEl(cmp);

gl.glGetCompressedTexImage(GLenum(eGL_TEXTURE_CUBE_MAP_POSITIVE_X + i), 0, cmp);

RDCCOMPILE_ASSERT(sizeof(buf) == sizeof(buf), "Buffers are not matching sizes");

if(memcmp(buf, cmp, sizeof(buf)))

{

RDCERR("glGetTexImage from the source texture returns incorrect data!");

VendorCheck[VendorCheck_AMD_copy_compressed_cubemaps] =

true; // to be safe, enable the hack

}

}

gl.glBindTexture(eGL_TEXTURE_CUBE_MAP, texs[1]);

for(int i = 0; i < 6; i++)

{

memset(buf, 0xba + i, sizeof(buf));

RDCEraseEl(cmp);

gl.glGetCompressedTexImage(GLenum(eGL_TEXTURE_CUBE_MAP_POSITIVE_X + i), 0, cmp);

RDCCOMPILE_ASSERT(sizeof(buf) == sizeof(buf), "Buffers are not matching sizes");

if(memcmp(buf, cmp, sizeof(buf)))

{

RDCWARN("Using hack to avoid glCopyImageSubData on cubemap textures");

VendorCheck[VendorCheck_AMD_copy_compressed_cubemaps] = true;

break;

}

}

gl.glBindTexture(eGL_TEXTURE_CUBE_MAP, 0);

gl.glDeleteTextures(2, texs);

ClearGLErrors(gl);

}

if(gl.glGetError && gl.glGenProgramPipelines && gl.glDeleteProgramPipelines &&

gl.glGetProgramPipelineiv && HasExt[ARB_compute_shader] && HasExt[ARB_program_interface_query])

{

GLuint pipe = 0;

gl.glGenProgramPipelines(1, &pipe);

// clear all error flags.

GLenum err = eGL_NONE;

ClearGLErrors(gl);

GLint dummy = 0;

gl.glGetProgramPipelineiv(pipe, eGL_COMPUTE_SHADER, &dummy);

err = gl.glGetError();

if(err != eGL_NONE)

{

// if we got an error trying to query that, we should enable this hack

VendorCheck[VendorCheck_AMD_pipeline_compute_query] = true;

RDCWARN("Using hack to avoid glGetProgramPipelineiv with GL_COMPUTE_SHADER");

}

gl.glDeleteProgramPipelines(1, &pipe);

}

// only do this when we have a proper context e.g. on windows where an old

// context is first created. Check to see if FBOs or VAOs are shared between

// contexts.

if((IsGLES || GLCoreVersion >= 32) && gl.glGenVertexArrays && gl.glBindVertexArray &&

gl.glDeleteVertexArrays && gl.glGenFramebuffers && gl.glBindFramebuffer &&

gl.glDeleteFramebuffers)

{

// gen & create an FBO and VAO

GLuint fbo = 0;

GLuint vao = 0;

gl.glGenFramebuffers(1, &fbo);

gl.glBindFramebuffer(eGL_DRAW_FRAMEBUFFER, fbo);

gl.glGenVertexArrays(1, &vao);

gl.glBindVertexArray(vao);

// make a context that shares with the current one, and switch to it

GLWindowingData child = platform.MakeContext(context);

if(child.ctx)

{

// switch to child

platform.MakeContextCurrent(child);

// these shouldn't be visible

VendorCheck[VendorCheck_EXT_fbo_shared] = (gl.glIsFramebuffer(fbo) != GL_FALSE);

VendorCheck[VendorCheck_EXT_vao_shared] = (gl.glIsVertexArray(vao) != GL_FALSE);

if(VendorCheck[VendorCheck_EXT_fbo_shared])

RDCWARN("FBOs are shared on this implementation");

if(VendorCheck[VendorCheck_EXT_vao_shared])

RDCWARN("VAOs are shared on this implementation");

// switch back to context

platform.MakeContextCurrent(context);

platform.DeleteContext(child);

}

gl.glDeleteFramebuffers(1, &fbo);

gl.glDeleteVertexArrays(1, &vao);

}

// don't have a test for this, just have to enable it all the time, for now.

VendorCheck[VendorCheck_NV_avoid_D32S8_copy] = true;

// On 32-bit calling this function could actually lead to crashes (issues with

// esp being saved across the call), so since the work-around is low-cost of just

// emulating that function we just always enable it.

//

// NOTE: Vendor Checks are initialised after the function pointers will be set up

// so we have to do this unconditionally, this value isn't checked anywhere.

// Search for where this is applied in gl_emulated.cpp

VendorCheck[VendorCheck_NV_ClearNamedFramebufferfiBugs] = true;

// glVertexArrayElementBuffer doesn't update the GL_ELEMENT_ARRAY_BUFFER_BINDING global query,

// when binding the VAO subsequently *will*.

// I'm not sure if that's correct (weird) behaviour or buggy, but we can work around it just by

// avoiding use of the DSA function and always doing our emulated version.

VendorCheck[VendorCheck_AMD_vertex_array_elem_buffer_query] = true;

if(IsGLES)

{

// Check whether reading from the depth, stencil and depth-stencil buffers using glReadPixels is

// supported or not.

if(!HasExt[NV_read_depth])

RDCWARN(

"Reading from the depth buffer using glReadPixels is not supported (GL_NV_read_depth)");

if(!HasExt[NV_read_stencil])

RDCWARN(

"Reading from the stencil buffer using glReadPixels is not supported "

"(GL_NV_read_stencil)");

if(!HasExt[NV_read_depth_stencil])

RDCWARN(

"Reading from the packed depth-stencil buffers using glReadPixels is not supported "

"(GL_NV_read_depth_stencil)");

}

}

const GLHookSet *GLMarkerRegion::gl;

GLMarkerRegion::GLMarkerRegion(const std::string &marker)

{

Begin(marker);

}

GLMarkerRegion::~GLMarkerRegion()

{

End();

}

void GLMarkerRegion::Begin(const std::string &marker)

{

if(gl == NULL || !HasExt[KHR_debug] || !gl->glPushDebugGroup)

return;

gl->glPushDebugGroup(eGL_DEBUG_SOURCE_APPLICATION, 0, -1, marker.c_str());

}

void GLMarkerRegion::Set(const std::string &marker)

{

if(gl == NULL || !HasExt[KHR_debug] || !gl->glDebugMessageInsert)

return;

gl->glDebugMessageInsert(eGL_DEBUG_SOURCE_APPLICATION, eGL_DEBUG_TYPE_MARKER, 0,

eGL_DEBUG_SEVERITY_NOTIFICATION, -1, marker.c_str());

}

void GLMarkerRegion::End()

{

if(gl == NULL || !HasExt[KHR_debug] || !gl->glPopDebugGroup)

return;

gl->glPopDebugGroup();

}

size_t BufferIdx(GLenum buf)

{

switch(buf)

{

case eGL_ARRAY_BUFFER: return 0;

case eGL_ATOMIC_COUNTER_BUFFER: return 1;

case eGL_COPY_READ_BUFFER: return 2;

case eGL_COPY_WRITE_BUFFER: return 3;

case eGL_DRAW_INDIRECT_BUFFER: return 4;

case eGL_DISPATCH_INDIRECT_BUFFER: return 5;

case eGL_ELEMENT_ARRAY_BUFFER: return 6;

case eGL_PIXEL_PACK_BUFFER: return 7;

case eGL_PIXEL_UNPACK_BUFFER: return 8;

case eGL_QUERY_BUFFER: return 9;

case eGL_SHADER_STORAGE_BUFFER: return 10;

case eGL_TEXTURE_BUFFER: return 11;

case eGL_TRANSFORM_FEEDBACK_BUFFER: return 12;

case eGL_UNIFORM_BUFFER: return 13;

case eGL_PARAMETER_BUFFER_ARB: return 14;

default: RDCERR("Unexpected enum as buffer target: %s", ToStr::Get(buf).c_str());

}

return 0;

}

GLenum BufferEnum(size_t idx)

{

GLenum enums[] = {

eGL_ARRAY_BUFFER,

eGL_ATOMIC_COUNTER_BUFFER,

eGL_COPY_READ_BUFFER,

eGL_COPY_WRITE_BUFFER,

eGL_DRAW_INDIRECT_BUFFER,

eGL_DISPATCH_INDIRECT_BUFFER,

eGL_ELEMENT_ARRAY_BUFFER,

eGL_PIXEL_PACK_BUFFER,

eGL_PIXEL_UNPACK_BUFFER,

eGL_QUERY_BUFFER,

eGL_SHADER_STORAGE_BUFFER,

eGL_TEXTURE_BUFFER,

eGL_TRANSFORM_FEEDBACK_BUFFER,

eGL_UNIFORM_BUFFER,

eGL_PARAMETER_BUFFER_ARB,

};

if(idx < ARRAY_COUNT(enums))

return enums[idx];

return eGL_NONE;

}

size_t QueryIdx(GLenum query)

{

size_t idx = 0;

switch(query)

{

case eGL_SAMPLES_PASSED: idx = 0; break;

case eGL_ANY_SAMPLES_PASSED: idx = 1; break;

case eGL_ANY_SAMPLES_PASSED_CONSERVATIVE: idx = 2; break;

case eGL_PRIMITIVES_GENERATED: idx = 3; break;

case eGL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: idx = 4; break;

case eGL_TIME_ELAPSED: idx = 5; break;

case eGL_VERTICES_SUBMITTED_ARB: idx = 6; break;

case eGL_PRIMITIVES_SUBMITTED_ARB: idx = 7; break;

case eGL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB: idx = 8; break;

case eGL_CLIPPING_INPUT_PRIMITIVES_ARB: idx = 9; break;

case eGL_CLIPPING_OUTPUT_PRIMITIVES_ARB: idx = 10; break;

case eGL_VERTEX_SHADER_INVOCATIONS_ARB: idx = 11; break;

case eGL_TESS_CONTROL_SHADER_PATCHES_ARB: idx = 12; break;

case eGL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB: idx = 13; break;

case eGL_GEOMETRY_SHADER_INVOCATIONS: idx = 14; break;

case eGL_FRAGMENT_SHADER_INVOCATIONS_ARB: idx = 15; break;

case eGL_COMPUTE_SHADER_INVOCATIONS_ARB: idx = 16; break;

default: RDCERR("Unexpected enum as query target: %s", ToStr::Get(query).c_str());

}

if(idx >= WrappedOpenGL::MAX_QUERIES)

RDCERR("Query index for enum %s out of range %d", ToStr::Get(query).c_str(), idx);

return idx;

}

GLenum QueryEnum(size_t idx)

{

GLenum enums[] = {eGL_SAMPLES_PASSED,

eGL_ANY_SAMPLES_PASSED,

eGL_ANY_SAMPLES_PASSED_CONSERVATIVE,

eGL_PRIMITIVES_GENERATED,

eGL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN,

eGL_TIME_ELAPSED,

eGL_VERTICES_SUBMITTED_ARB,

eGL_PRIMITIVES_SUBMITTED_ARB,

eGL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB,

eGL_CLIPPING_INPUT_PRIMITIVES_ARB,

eGL_CLIPPING_OUTPUT_PRIMITIVES_ARB,

eGL_VERTEX_SHADER_INVOCATIONS_ARB,

eGL_TESS_CONTROL_SHADER_PATCHES_ARB,

eGL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB,

eGL_GEOMETRY_SHADER_INVOCATIONS,

eGL_FRAGMENT_SHADER_INVOCATIONS_ARB,

eGL_COMPUTE_SHADER_INVOCATIONS_ARB};

if(idx < ARRAY_COUNT(enums))

return enums[idx];

return eGL_NONE;

}

size_t GLTypeSize(GLenum type)

{

switch(type)

{

case eGL_UNSIGNED_BYTE:

case eGL_BYTE: return 1;

case eGL_UNSIGNED_SHORT:

case eGL_SHORT:

case eGL_HALF_FLOAT_OES:

case eGL_HALF_FLOAT: return 2;

case eGL_UNSIGNED_INT:

case eGL_INT:

case eGL_FLOAT: return 4;

case eGL_DOUBLE: return 8;

default: RDCWARN("Unhandled element type %s", ToStr::Get(type).c_str());

}

return 0;

}

size_t ShaderIdx(GLenum buf)

{

switch(buf)

{

case eGL_VERTEX_SHADER: return 0;

case eGL_TESS_CONTROL_SHADER: return 1;

case eGL_TESS_EVALUATION_SHADER: return 2;

case eGL_GEOMETRY_SHADER: return 3;

case eGL_FRAGMENT_SHADER: return 4;

case eGL_COMPUTE_SHADER: return 5;

default: RDCERR("Unexpected enum as shader enum: %s", ToStr::Get(buf).c_str());

}

return 0;

}

GLenum ShaderBit(size_t idx)

{

GLenum enums[] = {

eGL_VERTEX_SHADER_BIT, eGL_TESS_CONTROL_SHADER_BIT, eGL_TESS_EVALUATION_SHADER_BIT,

eGL_GEOMETRY_SHADER_BIT, eGL_FRAGMENT_SHADER_BIT, eGL_COMPUTE_SHADER_BIT,

};

if(idx < ARRAY_COUNT(enums))

return enums[idx];

return eGL_NONE;

}

GLenum ShaderEnum(size_t idx)

{

GLenum enums[] = {

eGL_VERTEX_SHADER, eGL_TESS_CONTROL_SHADER, eGL_TESS_EVALUATION_SHADER,

eGL_GEOMETRY_SHADER, eGL_FRAGMENT_SHADER, eGL_COMPUTE_SHADER,

};

if(idx < ARRAY_COUNT(enums))

return enums[idx];

return eGL_NONE;

}

void ClearGLErrors(const GLHookSet &gl)

{

int i = 0;

GLenum err = gl.glGetError();

while(err)

{

err = gl.glGetError();

i++;

if(i > 100)

{

RDCERR("Couldn't clear GL errors - something very wrong!");

return;

}

}

}

GLuint GetBoundVertexBuffer(const GLHookSet &gl, GLuint i)

{

GLuint buffer = 0;

if(VendorCheck[VendorCheck_AMD_vertex_buffer_query])

gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, (GLint *)&buffer);

else

gl.glGetIntegeri_v(eGL_VERTEX_BINDING_BUFFER, i, (GLint *)&buffer);

return buffer;

}

BufferCategory MakeBufferCategory(GLenum bufferTarget)

{

switch(bufferTarget)

{

case eGL_ARRAY_BUFFER: return BufferCategory::Vertex; break;

case eGL_ELEMENT_ARRAY_BUFFER: return BufferCategory::Index; break;

case eGL_UNIFORM_BUFFER: return BufferCategory::Constants; break;

case eGL_SHADER_STORAGE_BUFFER: return BufferCategory::ReadWrite; break;

case eGL_DRAW_INDIRECT_BUFFER:

case eGL_DISPATCH_INDIRECT_BUFFER:

case eGL_PARAMETER_BUFFER_ARB: return BufferCategory::Indirect; break;

default: break;

}

return BufferCategory::NoFlags;

}

AddressMode MakeAddressMode(GLenum addr)

{

switch(addr)

{

case eGL_REPEAT: return AddressMode::Wrap;

case eGL_MIRRORED_REPEAT: return AddressMode::Mirror;

case eGL_CLAMP_TO_EDGE: return AddressMode::ClampEdge;

case eGL_CLAMP_TO_BORDER: return AddressMode::ClampBorder;

case eGL_MIRROR_CLAMP_TO_EDGE: return AddressMode::MirrorOnce;

default: break;

}