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

* 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_driver.h"

#include <algorithm>

#include "common/common.h"

#include "data/glsl_shaders.h"

#include "driver/shaders/spirv/spirv_compile.h"

#include "jpeg-compressor/jpge.h"

#include "maths/matrix.h"

#include "maths/vec.h"

#include "replay/type_helpers.h"

#include "serialise/string_utils.h"

#include "stb/stb_truetype.h"

#define OPENGL 1

#include "data/glsl/debuguniforms.h"

const int firstChar = int(' ') + 1;

const int lastChar = 127;

const int numChars = lastChar - firstChar;

const float charPixelHeight = 20.0f;

stbtt_bakedchar chardata[numChars];

const char *GLChunkNames[] = {

"WrappedOpenGL::Initialisation",

"glGenTextures",

"glCreateTextures",

"glBindTexture",

"glBindTextures",

"glBindMultiTexture",

"glBindTextureUnit",

"glBindImageTexture",

"glBindImageTextures",

"glActiveTexture",

"glTexStorage1D",

"glTexStorage2D",

"glTexStorage3D",

"glTexStorage2DMultisample",

"glTexStorage3DMultisample",

"glTexImage1D",

"glTexImage2D",

"glTexImage3D",

"glTexSubImage1D",

"glTexSubImage2D",

"glTexSubImage3D",

"glCompressedTexImage1D",

"glCompressedTexImage2D",

"glCompressedTexImage3D",

"glCompressedTexSubImage1D",

"glCompressedTexSubImage2D",

"glCompressedTexSubImage3D",

"glTexBuffer",

"glTexBufferRange",

"glPixelStore",

"glTexParameterf",

"glTexParameterfv",

"glTexParameteri",

"glTexParameteriv",

"glTexParameterIiv",

"glTexParameterIuiv",

"glGenerateMipmap",

"glCopyImageSubData",

"glCopyTexImage1D",

"glCopyTexImage2D",

"glCopyTexSubImage1D",

"glCopyTexSubImage2D",

"glCopyTexSubImage3D",

"glTextureView",

"glCreateShader",

"glCreateProgram",

"glCreateShaderProgramv",

"glCompileShader",

"glShaderSource",

"glAttachShader",

"glDetachShader",

"glUseProgram",

"glProgramParameter",

"glTransformFeedbackVaryings",

"glBindAttribLocation",

"glBindFragDataLocation",

"glBindFragDataLocationIndexed",

"glUniformBlockBinding",

"glShaderStorageBlockBinding",

"glUniformSubroutinesuiv",

"glProgramUniformVector*",

"glProgramUniformMatrix*",

"glLinkProgram",

"glNamedStringARB",

"glDeleteNamedStringARB",

"glCompileShaderIncludeARB",

"glGenTransformFeedbacks",

"glCreateTransformFeedbacks",

"glBindTransformFeedback",

"glBeginTransformFeedback",

"glEndTransformFeedback",

"glPauseTransformFeedback",

"glResumeTransformFeedback",

"glGenProgramPipelines",

"glCreateProgramPipelines",

"glUseProgramStages",

"glBindProgramPipeline",

"glFenceSync",

"glClientWaitSync",

"glWaitSync",

"glGenQueries",

"glCreateQueries",

"glBeginQuery",

"glBeginQueryIndexed",

"glEndQuery",

"glEndQueryIndexed",

"glBeginConditional",

"glEndConditional",

"glQueryCounter",

"glClearColor",

"glClearDepth",

"glClearStencil",

"glClear",

"glClearBufferfv",

"glClearBufferiv",

"glClearBufferuiv",

"glClearBufferfi",

"glClearBufferData",

"glClearBufferSubData",

"glClearTexImage",

"glClearTexSubImage",

"glPolygonMode",

"glPolygonOffset",

"glPolygonOffsetClampEXT",

"glCullFace",

"glHint",

"glEnable",

"glDisable",

"glEnablei",

"glDisablei",

"glFrontFace",

"glBlendFunc",

"glBlendFunci",

"glBlendColor",

"glBlendFuncSeparate",

"glBlendFuncSeparatei",

"glBlendEquation",

"glBlendEquationi",

"glBlendEquationSeparate",

"glBlendEquationSeparatei",

"glBlendBarrierKHR",

"glLogicOp",

"glStencilOp",

"glStencilOpSeparate",

"glStencilFunc",

"glStencilFuncSeparate",

"glStencilMask",

"glStencilMaskSeparate",

"glColorMask",

"glColorMaski",

"glSampleMaski",

"glSampleCoverage",

"glMinSampleShading",

"glRasterSamplesEXT",

"glDepthFunc",

"glDepthMask",

"glDepthRange",

"glDepthRangef",

"glDepthRangeIndexed",

"glDepthRangeArrayv",

"glDepthBounds",

"glClipControl",

"glProvokingVertex",

"glPrimitiveRestartIndex",

"glPatchParameteri",

"glPatchParameterfv",

"glLineWidth",

"glPointSize",

"glPointParameterf",

"glPointParameterfv",

"glPointParameteri",

"glPointParameteriv",

"glViewport",

"glViewportArrayv",

"glScissor",

"glScissorArrayv",

"glBindVertexBuffer",

"glBindVertexBuffers",

"glVertexBindingDivisor",

"glDispatchCompute",

"glDispatchComputeGroupSizeARB",

"glDispatchComputeIndirect",

"glMemoryBarrier",

"glMemoryBarrierByRegion",

"glTextureBarrier",

"glDrawArrays",

"glDrawArraysIndirect",

"glDrawArraysInstanced",

"glDrawArraysInstancedBaseInstance",

"glDrawElements",

"glDrawElementsIndirect",

"glDrawRangeElements",

"glDrawRangeElementsBaseVertex",

"glDrawElementsInstanced",

"glDrawElementsInstancedBaseInstance",

"glDrawElementsBaseVertex",

"glDrawElementsInstancedBaseVertex",

"glDrawElementsInstancedBaseVertexBaseInstance",

"glDrawTransformFeedback",

"glDrawTransformFeedbackInstanced",

"glDrawTransformFeedbackStream",

"glDrawTransformFeedbackStreamInstanced",

"glMultiDrawArrays",

"glMultiDrawElements",

"glMultiDrawElementsBaseVertex",

"glMultiDrawArraysIndirect",

"glMultiDrawElementsIndirect",

"glMultiDrawArraysIndirectCountARB",

"glMultiDrawElementsIndirectCountARB",

"glGenFramebuffers",

"glCreateFramebuffers",

"glFramebufferTexture",

"glFramebufferTexture1D",

"glFramebufferTexture2D",

"glFramebufferTexture3D",

"glFramebufferRenderbuffer",

"glFramebufferTextureLayer",

"glFramebufferParameteri",

"glReadBuffer",

"glBindFramebuffer",

"glDrawBuffer",

"glDrawBuffers",

"glBlitFramebuffer",

"glGenRenderbuffers",

"glCreateRenderbuffers",

"glRenderbufferStorage",

"glRenderbufferStorageMultisample",

"glGenSamplers",

"glCreateSamplers",

"glSamplerParameteri",

"glSamplerParameterf",

"glSamplerParameteriv",

"glSamplerParameterfv",

"glSamplerParameterIiv",

"glSamplerParameterIuiv",

"glBindSampler",

"glBindSamplers",

"glGenBuffers",

"glCreateBuffers",

"glBindBuffer",

"glBindBufferBase",

"glBindBufferRange",

"glBindBuffersBase",

"glBindBuffersRange",

"glBufferStorage",

"glBufferData",

"glBufferSubData",

"glCopyBufferSubData",

"glUnmapBuffer",

"glFlushMappedBufferRange",

"glGenVertexArrays",

"glCreateVertexArrays",

"glBindVertexArray",

"glVertexAttrib*",

"glVertexAttribPointer",

"glVertexAttribIPointer",

"glVertexAttribLPointer",

"glEnableVertexAttribArray",

"glDisableVertexAttribArray",

"glVertexAttribFormat",

"glVertexAttribIFormat",

"glVertexAttribLFormat",

"glVertexAttribDivisor",

"glVertexAttribBinding",

"glVertexArrayElementBuffer",

"glTransformFeedbackBufferBase",

"glTransformFeedbackBufferRange",

"glObjectLabel",

"glPushDebugGroup",

"glDebugMessageInsert",

"glPopDebugGroup",

"DebugMessageList",

"Capture",

"BeginCapture",

"EndCapture",

"wglDXRegisterObjectNV",

"wglDXLockObjectsNV",

"glPrimitiveBoundingBox",

"glFramebufferTexture2DMultisample",

"glFramebufferTextureMultiviewOVR",

"glFramebufferTextureMultisampleMultiviewOVR",

};

GLInitParams::GLInitParams()

{

SerialiseVersion = GL_SERIALISE_VERSION;

colorBits = 32;

depthBits = 32;

stencilBits = 8;

isSRGB = 1;

multiSamples = 1;

width = 32;

height = 32;

}

// handling for these versions is scattered throughout the code (as relevant to enable/disable bits

// of serialisation and set some defaults if necessary).

// Here we list which non-current versions we support, and what changed

const uint32_t GLInitParams::GL_OLD_VERSIONS[GLInitParams::GL_NUM_SUPPORTED_OLD_VERSIONS] = {

0x000010, // from 0x10 to 0x11, we added a dummy marker value used to identify serialised

// data in glUseProgramStages (hack :( )

0x000011, // We added initial contents for buffers in this version, we don't have to do

// anything special to support older logs, just make sure we don't open new logs

// in an older version.

0x000012, // Added support for GL-DX interop

0x000013, // Serialised vertex attribute and fragdata bindings for programs as initial

// contents data

0x000014, // Added support for primitive bounding boxes on GLES

0x000015, // Changed serialisation of client-side index buffers which removed a bool even

// when they aren't used.

};

ReplayStatus GLInitParams::Serialise()

{

SERIALISE_ELEMENT(uint32_t, ver, GL_SERIALISE_VERSION);

SerialiseVersion = ver;

if(ver != GL_SERIALISE_VERSION)

{

bool oldsupported = false;

for(uint32_t i = 0; i < GL_NUM_SUPPORTED_OLD_VERSIONS; i++)

{

if(ver == GL_OLD_VERSIONS[i])

{

oldsupported = true;

RDCWARN(

"Old OpenGL serialise version %d, latest is %d. Loading with possibly degraded "

"features/support.",

ver, GL_SERIALISE_VERSION);

}

}

if(!oldsupported)

{

RDCERR("Incompatible OpenGL serialise version, expected %d got %d", GL_SERIALISE_VERSION, ver);

return ReplayStatus::APIIncompatibleVersion;

}

}

m_pSerialiser->Serialise("Color bits", colorBits);

m_pSerialiser->Serialise("Depth bits", depthBits);

m_pSerialiser->Serialise("Stencil bits", stencilBits);

m_pSerialiser->Serialise("Is SRGB", isSRGB);

m_pSerialiser->Serialise("MSAA samples", multiSamples);

m_pSerialiser->Serialise("Width", width);

m_pSerialiser->Serialise("Height", height);

return ReplayStatus::Succeeded;

}

void WrappedOpenGL::BuildGLExtensions()

{

m_GLExtensions.push_back("GL_ARB_arrays_of_arrays");

m_GLExtensions.push_back("GL_ARB_base_instance");

m_GLExtensions.push_back("GL_ARB_blend_func_extended");

m_GLExtensions.push_back("GL_ARB_buffer_storage");

m_GLExtensions.push_back("GL_ARB_clear_buffer_object");

m_GLExtensions.push_back("GL_ARB_clear_texture");

m_GLExtensions.push_back("GL_ARB_clip_control");

m_GLExtensions.push_back("GL_ARB_color_buffer_float");

m_GLExtensions.push_back("GL_ARB_compressed_texture_pixel_storage");

m_GLExtensions.push_back("GL_ARB_compute_shader");

m_GLExtensions.push_back("GL_ARB_compute_variable_group_size");

m_GLExtensions.push_back("GL_ARB_conditional_render_inverted");

m_GLExtensions.push_back("GL_ARB_conservative_depth");

m_GLExtensions.push_back("GL_ARB_copy_buffer");

m_GLExtensions.push_back("GL_ARB_copy_image");

m_GLExtensions.push_back("GL_ARB_cull_distance");

m_GLExtensions.push_back("GL_ARB_debug_output");

m_GLExtensions.push_back("GL_ARB_depth_buffer_float");

m_GLExtensions.push_back("GL_ARB_depth_clamp");

m_GLExtensions.push_back("GL_ARB_depth_texture");

m_GLExtensions.push_back("GL_ARB_derivative_control");

m_GLExtensions.push_back("GL_ARB_direct_state_access");

m_GLExtensions.push_back("GL_ARB_draw_buffers");

m_GLExtensions.push_back("GL_ARB_draw_buffers_blend");

m_GLExtensions.push_back("GL_ARB_draw_elements_base_vertex");

m_GLExtensions.push_back("GL_ARB_draw_indirect");

m_GLExtensions.push_back("GL_ARB_draw_instanced");

m_GLExtensions.push_back("GL_ARB_enhanced_layouts");

m_GLExtensions.push_back("GL_ARB_ES2_compatibility");

m_GLExtensions.push_back("GL_ARB_ES3_1_compatibility");

m_GLExtensions.push_back("GL_ARB_ES3_compatibility");

m_GLExtensions.push_back("GL_ARB_explicit_attrib_location");

m_GLExtensions.push_back("GL_ARB_explicit_uniform_location");

m_GLExtensions.push_back("GL_ARB_fragment_coord_conventions");

m_GLExtensions.push_back("GL_ARB_fragment_layer_viewport");

m_GLExtensions.push_back("GL_ARB_fragment_shader_interlock");

m_GLExtensions.push_back("GL_ARB_framebuffer_no_attachments");

m_GLExtensions.push_back("GL_ARB_framebuffer_object");

m_GLExtensions.push_back("GL_ARB_framebuffer_sRGB");

m_GLExtensions.push_back("GL_ARB_geometry_shader4");

m_GLExtensions.push_back("GL_ARB_get_program_binary");

m_GLExtensions.push_back("GL_ARB_get_texture_sub_image");

m_GLExtensions.push_back("GL_ARB_gpu_shader_fp64");

m_GLExtensions.push_back("GL_ARB_gpu_shader5");

m_GLExtensions.push_back("GL_ARB_half_float_pixel");

m_GLExtensions.push_back("GL_ARB_half_float_vertex");

m_GLExtensions.push_back("GL_ARB_indirect_parameters");

m_GLExtensions.push_back("GL_ARB_instanced_arrays");

m_GLExtensions.push_back("GL_ARB_internalformat_query");

m_GLExtensions.push_back("GL_ARB_internalformat_query2");

m_GLExtensions.push_back("GL_ARB_invalidate_subdata");

m_GLExtensions.push_back("GL_ARB_map_buffer_alignment");

m_GLExtensions.push_back("GL_ARB_map_buffer_range");

m_GLExtensions.push_back("GL_ARB_multi_bind");

m_GLExtensions.push_back("GL_ARB_multi_draw_indirect");

m_GLExtensions.push_back("GL_ARB_multisample");

m_GLExtensions.push_back("GL_ARB_multitexture");

m_GLExtensions.push_back("GL_ARB_occlusion_query");

m_GLExtensions.push_back("GL_ARB_occlusion_query2");

m_GLExtensions.push_back("GL_ARB_pixel_buffer_object");

m_GLExtensions.push_back("GL_ARB_pipeline_statistics_query");

m_GLExtensions.push_back("GL_ARB_point_parameters");

m_GLExtensions.push_back("GL_ARB_point_sprite");

m_GLExtensions.push_back("GL_ARB_post_depth_coverage");

m_GLExtensions.push_back("GL_ARB_program_interface_query");

m_GLExtensions.push_back("GL_ARB_provoking_vertex");

m_GLExtensions.push_back("GL_ARB_query_buffer_object");

m_GLExtensions.push_back("GL_ARB_robust_buffer_access_behavior");

m_GLExtensions.push_back("GL_ARB_robustness");

m_GLExtensions.push_back("GL_ARB_robustness_application_isolation");

m_GLExtensions.push_back("GL_ARB_robustness_share_group_isolation");

m_GLExtensions.push_back("GL_ARB_sample_shading");

m_GLExtensions.push_back("GL_ARB_sampler_objects");

m_GLExtensions.push_back("GL_ARB_seamless_cube_map");

m_GLExtensions.push_back("GL_ARB_seamless_cubemap_per_texture");

m_GLExtensions.push_back("GL_ARB_separate_shader_objects");

m_GLExtensions.push_back("GL_ARB_shader_atomic_counters");

m_GLExtensions.push_back("GL_ARB_shader_atomic_counter_ops");

m_GLExtensions.push_back("GL_ARB_shader_ballot");

m_GLExtensions.push_back("GL_ARB_shader_bit_encoding");

m_GLExtensions.push_back("GL_ARB_shader_clock");

m_GLExtensions.push_back("GL_ARB_shader_draw_parameters");

m_GLExtensions.push_back("GL_ARB_shader_group_vote");

m_GLExtensions.push_back("GL_ARB_shader_image_load_store");

m_GLExtensions.push_back("GL_ARB_shader_image_size");

m_GLExtensions.push_back("GL_ARB_shader_precision");

m_GLExtensions.push_back("GL_ARB_shader_stencil_export");

m_GLExtensions.push_back("GL_ARB_shader_storage_buffer_object");

m_GLExtensions.push_back("GL_ARB_shader_subroutine");

m_GLExtensions.push_back("GL_ARB_shader_texture_image_samples");

m_GLExtensions.push_back("GL_ARB_shader_texture_lod");

m_GLExtensions.push_back("GL_ARB_shader_viewport_layer_array");

m_GLExtensions.push_back("GL_ARB_shading_language_100");

m_GLExtensions.push_back("GL_ARB_shading_language_420pack");

m_GLExtensions.push_back("GL_ARB_shading_language_include");

m_GLExtensions.push_back("GL_ARB_shading_language_packing");

m_GLExtensions.push_back("GL_ARB_shadow");

m_GLExtensions.push_back("GL_ARB_shadow_ambient");

m_GLExtensions.push_back("GL_ARB_stencil_texturing");

m_GLExtensions.push_back("GL_ARB_sync");

m_GLExtensions.push_back("GL_ARB_tessellation_shader");

m_GLExtensions.push_back("GL_ARB_texture_barrier");

m_GLExtensions.push_back("GL_ARB_texture_border_clamp");

m_GLExtensions.push_back("GL_ARB_texture_buffer_object");

m_GLExtensions.push_back("GL_ARB_texture_buffer_object_rgb32");

m_GLExtensions.push_back("GL_ARB_texture_buffer_range");

m_GLExtensions.push_back("GL_ARB_texture_compression");

m_GLExtensions.push_back("GL_ARB_texture_compression_bptc");

m_GLExtensions.push_back("GL_ARB_texture_compression_rgtc");

m_GLExtensions.push_back("GL_ARB_texture_cube_map");

m_GLExtensions.push_back("GL_ARB_texture_cube_map_array");

m_GLExtensions.push_back("GL_ARB_texture_float");

m_GLExtensions.push_back("GL_ARB_texture_gather");

m_GLExtensions.push_back("GL_ARB_texture_mirror_clamp_to_edge");

m_GLExtensions.push_back("GL_ARB_texture_mirrored_repeat");

m_GLExtensions.push_back("GL_ARB_texture_multisample");

m_GLExtensions.push_back("GL_ARB_texture_non_power_of_two");

m_GLExtensions.push_back("GL_ARB_texture_query_levels");

m_GLExtensions.push_back("GL_ARB_texture_query_lod");

m_GLExtensions.push_back("GL_ARB_texture_rectangle");

m_GLExtensions.push_back("GL_ARB_texture_rg");

m_GLExtensions.push_back("GL_ARB_texture_rgb10_a2ui");

m_GLExtensions.push_back("GL_ARB_texture_stencil8");

m_GLExtensions.push_back("GL_ARB_texture_storage");

m_GLExtensions.push_back("GL_ARB_texture_storage_multisample");

m_GLExtensions.push_back("GL_ARB_texture_swizzle");

m_GLExtensions.push_back("GL_ARB_texture_view");

m_GLExtensions.push_back("GL_ARB_timer_query");

m_GLExtensions.push_back("GL_ARB_transform_feedback_instanced");

m_GLExtensions.push_back("GL_ARB_transform_feedback_overflow_query");

m_GLExtensions.push_back("GL_ARB_transform_feedback2");

m_GLExtensions.push_back("GL_ARB_transform_feedback3");

m_GLExtensions.push_back("GL_ARB_uniform_buffer_object");

m_GLExtensions.push_back("GL_ARB_vertex_array_bgra");

m_GLExtensions.push_back("GL_ARB_vertex_array_object");

m_GLExtensions.push_back("GL_ARB_vertex_attrib_64bit");

m_GLExtensions.push_back("GL_ARB_vertex_attrib_binding");

m_GLExtensions.push_back("GL_ARB_vertex_buffer_object");

m_GLExtensions.push_back("GL_ARB_vertex_program");

m_GLExtensions.push_back("GL_ARB_vertex_type_10f_11f_11f_rev");

m_GLExtensions.push_back("GL_ARB_vertex_type_2_10_10_10_rev");

m_GLExtensions.push_back("GL_ARB_viewport_array");

m_GLExtensions.push_back("GL_EXT_bgra");

m_GLExtensions.push_back("GL_EXT_blend_color");

m_GLExtensions.push_back("GL_EXT_blend_equation_separate");

m_GLExtensions.push_back("GL_EXT_blend_func_separate");

m_GLExtensions.push_back("GL_EXT_blend_minmax");

m_GLExtensions.push_back("GL_EXT_blend_subtract");

m_GLExtensions.push_back("GL_EXT_debug_label");

m_GLExtensions.push_back("GL_EXT_debug_marker");

m_GLExtensions.push_back("GL_EXT_depth_bounds_test");

m_GLExtensions.push_back("GL_EXT_direct_state_access");

m_GLExtensions.push_back("GL_EXT_draw_buffers2");

m_GLExtensions.push_back("GL_EXT_draw_instanced");

m_GLExtensions.push_back("GL_EXT_draw_range_elements");

m_GLExtensions.push_back("GL_EXT_framebuffer_blit");

m_GLExtensions.push_back("GL_EXT_framebuffer_multisample");

m_GLExtensions.push_back("GL_EXT_framebuffer_multisample_blit_scaled");

m_GLExtensions.push_back("GL_EXT_framebuffer_object");

m_GLExtensions.push_back("GL_EXT_framebuffer_sRGB");

m_GLExtensions.push_back("GL_EXT_gpu_shader4");

m_GLExtensions.push_back("GL_EXT_multisample");

m_GLExtensions.push_back("GL_EXT_multi_draw_arrays");

m_GLExtensions.push_back("GL_EXT_packed_depth_stencil");

m_GLExtensions.push_back("GL_EXT_packed_float");

m_GLExtensions.push_back("GL_EXT_pixel_buffer_object");

m_GLExtensions.push_back("GL_EXT_pixel_buffer_object");

m_GLExtensions.push_back("GL_EXT_point_parameters");

m_GLExtensions.push_back("GL_EXT_polygon_offset_clamp");

m_GLExtensions.push_back("GL_EXT_post_depth_coverage");

m_GLExtensions.push_back("GL_EXT_provoking_vertex");

m_GLExtensions.push_back("GL_EXT_raster_multisample");

m_GLExtensions.push_back("GL_EXT_shader_image_load_store");

m_GLExtensions.push_back("GL_EXT_shader_image_load_formatted");

m_GLExtensions.push_back("GL_EXT_shader_integer_mix");

m_GLExtensions.push_back("GL_EXT_shadow_funcs");

m_GLExtensions.push_back("GL_EXT_stencil_wrap");

m_GLExtensions.push_back("GL_EXT_texture_array");

m_GLExtensions.push_back("GL_EXT_texture_buffer_object");

m_GLExtensions.push_back("GL_EXT_texture_compression_dxt1");

m_GLExtensions.push_back("GL_EXT_texture_compression_rgtc");

m_GLExtensions.push_back("GL_EXT_texture_compression_s3tc");

m_GLExtensions.push_back("GL_EXT_texture_cube_map");

m_GLExtensions.push_back("GL_EXT_texture_edge_clamp");

m_GLExtensions.push_back("GL_EXT_texture_filter_anisotropic");

m_GLExtensions.push_back("GL_EXT_texture_filter_minmax");

m_GLExtensions.push_back("GL_EXT_texture_integer");

m_GLExtensions.push_back("GL_EXT_texture_lod_bias");

m_GLExtensions.push_back("GL_EXT_texture_mirror_clamp");

m_GLExtensions.push_back("GL_EXT_texture_shared_exponent");

m_GLExtensions.push_back("GL_EXT_texture_snorm");

m_GLExtensions.push_back("GL_EXT_texture_sRGB");

m_GLExtensions.push_back("GL_EXT_texture_sRGB_decode");

m_GLExtensions.push_back("GL_EXT_texture_swizzle");

m_GLExtensions.push_back("GL_EXT_texture3D");

m_GLExtensions.push_back("GL_EXT_timer_query");

m_GLExtensions.push_back("GL_EXT_transform_feedback");

m_GLExtensions.push_back("GL_EXT_vertex_attrib_64bit");

m_GLExtensions.push_back("GL_GREMEDY_frame_terminator");

m_GLExtensions.push_back("GL_GREMEDY_string_marker");

m_GLExtensions.push_back("GL_KHR_blend_equation_advanced");

m_GLExtensions.push_back("GL_KHR_blend_equation_advanced_coherent");

m_GLExtensions.push_back("GL_KHR_context_flush_control");

m_GLExtensions.push_back("GL_KHR_debug");

m_GLExtensions.push_back("GL_KHR_no_error");

m_GLExtensions.push_back("GL_KHR_robustness");

m_GLExtensions.push_back("GL_KHR_robust_buffer_access_behavior");

// this WGL extension is advertised in the gl ext string instead of via the wgl ext string,

// return it just in case anyone is checking for it via this place. On non-windows platforms

// it won't be reported as we do the intersection of renderdoc supported extensions and

// implementation supported extensions.

m_GLExtensions.push_back("WGL_EXT_swap_control");

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

Extensions I plan to support, but haven't implemented yet for one reason or another.

Usually complexity/time considerations.

Vendor specific extensions aren't listed here, or below in the 'will never support' list.

Only very important/commonly used vendor extensions will be supported, generally I'll

stick to ARB, EXT and KHR.

* GL_ARB_bindless_texture

* GL_ARB_cl_event

* GL_ARB_sparse_buffer

* GL_ARB_sparse_texture

* GL_EXT_sparse_texture2

* GL_ARB_sparse_texture2

* GL_ARB_sparse_texture_clamp <- this one is free, but no point exposing until other spares exts

* GL_EXT_x11_sync_object

* GL_KHR_texture_compression_astc_hdr <- without support for astc textures on PC hardware this

* GL_KHR_texture_compression_astc_ldr <- could be difficult. Maybe falls into the category of

'only

support if it's supported on replaying driver'?

* GL_ARB_ES3_2_compatibility

* GL_ARB_gpu_shader_int64

* GL_ARB_parallel_shader_compile

* GL_ARB_sample_locations

* GL_ARB_texture_filter_minmax

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

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

Extensions I never plan to support due to only referring to old/outdated functionality listed

below.

I'm not sure what to do about GL_ARB_imaging, it seems like it's somewhat used in modern GL? For

now

I'm hoping I can get away with not reporting it but implementing the functionality it still

describes.

* GL_ARB_compatibility

* GL_ARB_fragment_program

* GL_ARB_fragment_program_shadow

* GL_ARB_fragment_shader

* GL_ARB_matrix_palette

* GL_ARB_shader_objects

* GL_ARB_texture_env_add

* GL_ARB_texture_env_combine

* GL_ARB_texture_env_crossbar

* GL_ARB_texture_env_dot3

* GL_ARB_transpose_matrix

* GL_ARB_vertex_blend

* GL_ARB_vertex_program

* GL_ARB_vertex_shader

* GL_ARB_window_pos

* GL_ATI_draw_buffers

* GL_ATI_texture_float

* GL_ATI_texture_mirror_once

* GL_EXT_422_pixels

* GL_EXT_abgr

* GL_EXT_bindable_uniform

* GL_EXT_blend_logic_op

* GL_EXT_Cg_shader

* GL_EXT_clip_volume_hint

* GL_EXT_cmyka

* GL_EXT_color_subtable

* GL_EXT_compiled_vertex_array

* GL_EXT_convolution

* GL_EXT_coordinate_frame

* GL_EXT_copy_texture

* GL_EXT_cull_vertex

* GL_EXT_fog_coord

* GL_EXT_fragment_lighting

* GL_EXT_geometry_shader4

* GL_EXT_gpu_program_parameters

* GL_EXT_histogram

* GL_EXT_import_sync_object

* GL_EXT_index_array_formats

* GL_EXT_index_func

* GL_EXT_index_material

* GL_EXT_index_texture

* GL_EXT_light_texture

* GL_EXT_misc_attribute

* GL_EXT_packed_pixels

* GL_EXT_paletted_texture

* GL_EXT_pixel_transform

* GL_EXT_pixel_transform_color_table

* GL_EXT_rescale_normal

* GL_EXT_scene_marker

* GL_EXT_secondary_color

* GL_EXT_separate_shader_objects

* GL_EXT_separate_specular_color

* GL_EXT_shared_texture_palette

* GL_EXT_stencil_clear_tag

* GL_EXT_stencil_two_side

* GL_EXT_subtexture

* GL_EXT_texture_compression_latc

* GL_EXT_texture_env_add

* GL_EXT_texture_env_combine

* GL_EXT_texture_env_dot3

* GL_EXT_texture_lod

* GL_EXT_texture_object

* GL_EXT_texture_perturb_normal

* GL_EXT_texture_storage

* GL_EXT_vertex_array

* GL_EXT_vertex_array_bgra

* GL_EXT_vertex_shader

* GL_EXT_vertex_weighting

* GL_S3_s3tc

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

// we'll be sorting the implementation extension array, so make sure the

// sorts are identical so we can do the intersection easily

std::sort(m_GLExtensions.begin(), m_GLExtensions.end());

}

void WrappedOpenGL::BuildGLESExtensions()

{

m_GLESExtensions.push_back("GL_ARM_rgba8");

m_GLESExtensions.push_back("GL_EXT_base_instance");

m_GLESExtensions.push_back("GL_EXT_blend_minmax");

m_GLESExtensions.push_back("GL_EXT_clip_cull_distance");

m_GLESExtensions.push_back("GL_EXT_color_buffer_float");

m_GLESExtensions.push_back("GL_EXT_color_buffer_half_float");

m_GLESExtensions.push_back("GL_EXT_copy_image");

m_GLESExtensions.push_back("GL_EXT_debug_label");

m_GLESExtensions.push_back("GL_EXT_debug_marker");

m_GLESExtensions.push_back("GL_EXT_discard_framebuffer");

m_GLESExtensions.push_back("GL_EXT_disjoint_timer_query");

m_GLESExtensions.push_back("GL_EXT_draw_buffers");

m_GLESExtensions.push_back("GL_EXT_draw_buffers_indexed");

m_GLESExtensions.push_back("GL_EXT_draw_elements_base_vertex");

m_GLESExtensions.push_back("GL_EXT_geometry_point_size");

m_GLESExtensions.push_back("GL_EXT_geometry_shader");

m_GLESExtensions.push_back("GL_EXT_gpu_shader5");

m_GLESExtensions.push_back("GL_EXT_multisampled_render_to_texture");

m_GLESExtensions.push_back("GL_EXT_primitive_bounding_box");

m_GLESExtensions.push_back("GL_EXT_pvrtc_sRGB");

m_GLESExtensions.push_back("GL_EXT_robustness");

m_GLESExtensions.push_back("GL_EXT_separate_shader_objects");

m_GLESExtensions.push_back("GL_EXT_shader_framebuffer_fetch");

m_GLESExtensions.push_back("GL_EXT_shader_group_vote");

m_GLESExtensions.push_back("GL_EXT_shader_implicit_conversions");

m_GLESExtensions.push_back("GL_EXT_shader_integer_mix");

m_GLESExtensions.push_back("GL_EXT_shader_io_blocks");

m_GLESExtensions.push_back("GL_EXT_shader_non_constant_global_initializers");

m_GLESExtensions.push_back("GL_EXT_shader_texture_lod");

m_GLESExtensions.push_back("GL_EXT_shadow_samplers");

m_GLESExtensions.push_back("GL_EXT_sRGB");

m_GLESExtensions.push_back("GL_EXT_sRGB_write_control");

m_GLESExtensions.push_back("GL_EXT_tessellation_shader");

m_GLESExtensions.push_back("GL_EXT_texture_border_clamp");

m_GLESExtensions.push_back("GL_EXT_texture_buffer");

m_GLESExtensions.push_back("GL_EXT_texture_compression_astc_decode_mode");

m_GLESExtensions.push_back("GL_EXT_texture_compression_dxt1");

m_GLESExtensions.push_back("GL_EXT_texture_compression_s3tc");

m_GLESExtensions.push_back("GL_EXT_texture_cube_map_array");

m_GLESExtensions.push_back("GL_EXT_texture_filter_anisotropic");

m_GLESExtensions.push_back("GL_EXT_texture_filter_minmax");

m_GLESExtensions.push_back("GL_EXT_texture_format_BGRA8888");

m_GLESExtensions.push_back("GL_EXT_texture_norm16");

m_GLESExtensions.push_back("GL_EXT_texture_rg");

m_GLESExtensions.push_back("GL_EXT_texture_sRGB_decode");

m_GLESExtensions.push_back("GL_EXT_texture_sRGB_R8");

m_GLESExtensions.push_back("GL_EXT_texture_sRGB_RG8");

m_GLESExtensions.push_back("GL_EXT_texture_storage");

m_GLESExtensions.push_back("GL_EXT_texture_type_2_10_10_10_REV");

m_GLESExtensions.push_back("GL_EXT_texture_view");

m_GLESExtensions.push_back("GL_KHR_blend_equation_advanced");

m_GLESExtensions.push_back("GL_KHR_blend_equation_advanced_coherent");

m_GLESExtensions.push_back("GL_KHR_context_flush_control");

m_GLESExtensions.push_back("GL_KHR_debug");

m_GLESExtensions.push_back("GL_KHR_no_error");

m_GLESExtensions.push_back("GL_KHR_robust_buffer_access_behavior");

m_GLESExtensions.push_back("GL_KHR_texture_compression_astc_hdr");

m_GLESExtensions.push_back("GL_KHR_texture_compression_astc_ldr");

m_GLESExtensions.push_back("GL_KHR_texture_compression_astc_sliced_3d");

m_GLESExtensions.push_back("GL_NV_viewport_array");

m_GLESExtensions.push_back("GL_OES_compressed_ETC1_RGB8_texture");

m_GLESExtensions.push_back("GL_OES_copy_image");

m_GLESExtensions.push_back("GL_OES_depth24");

m_GLESExtensions.push_back("GL_OES_depth32");

m_GLESExtensions.push_back("GL_OES_depth_texture");

m_GLESExtensions.push_back("GL_OES_depth_texture_cube_map");

m_GLESExtensions.push_back("GL_OES_draw_buffers_indexed");

m_GLESExtensions.push_back("GL_OES_draw_elements_base_vertex");

m_GLESExtensions.push_back("GL_OES_fbo_render_mipmap");

m_GLESExtensions.push_back("GL_OES_geometry_shader");

m_GLESExtensions.push_back("GL_OES_gpu_shader5");

m_GLESExtensions.push_back("GL_OES_mapbuffer");

m_GLESExtensions.push_back("GL_OES_packed_depth_stencil");

m_GLESExtensions.push_back("GL_OES_primitive_bounding_box");

m_GLESExtensions.push_back("GL_OES_rgb8_rgba8");

m_GLESExtensions.push_back("GL_OES_sample_shading");

m_GLESExtensions.push_back("GL_OES_standard_derivatives");

m_GLESExtensions.push_back("GL_OES_tessellation_shader");

m_GLESExtensions.push_back("GL_OES_texture_3D");

m_GLESExtensions.push_back("GL_OES_texture_border_clamp");

m_GLESExtensions.push_back("GL_OES_texture_buffer");

m_GLESExtensions.push_back("GL_OES_texture_compression_astc");

m_GLESExtensions.push_back("GL_OES_texture_cube_map_array");

m_GLESExtensions.push_back("GL_OES_texture_float");

m_GLESExtensions.push_back("GL_OES_texture_float_linear");

m_GLESExtensions.push_back("GL_OES_texture_half_float");

m_GLESExtensions.push_back("GL_OES_texture_half_float_linear");

m_GLESExtensions.push_back("GL_OES_texture_npot");

m_GLESExtensions.push_back("GL_OES_texture_stencil8");

m_GLESExtensions.push_back("GL_OES_texture_storage_multisample_2d_array");

m_GLESExtensions.push_back("GL_OES_texture_view");

m_GLESExtensions.push_back("GL_OES_vertex_array_object");

m_GLESExtensions.push_back("GL_OES_vertex_half_float");

m_GLESExtensions.push_back("GL_OES_viewport_array");

m_GLESExtensions.push_back("GL_OVR_multiview");

m_GLESExtensions.push_back("GL_OVR_multiview2");

m_GLESExtensions.push_back("GL_OVR_multiview_multisampled_render_to_texture");

// advertise EGL extensions in the gl ext string, just in case anyone is checking it for

// this way.

m_GLESExtensions.push_back("EGL_KHR_create_context");

m_GLESExtensions.push_back("EGL_KHR_surfaceless_context");

// we'll be sorting the implementation extension array, so make sure the

// sorts are identical so we can do the intersection easily

std::sort(m_GLESExtensions.begin(), m_GLESExtensions.end());

}

WrappedOpenGL::WrappedOpenGL(const char *logfile, const GLHookSet &funcs, GLPlatform &platform)

: m_Real(funcs), m_Platform(platform)

{

if(RenderDoc::Inst().GetCrashHandler())

RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(this, sizeof(WrappedOpenGL));

BuildGLExtensions();

BuildGLESExtensions();

// by default we assume OpenGL driver

SetDriverType(RDC_OpenGL);

m_Replay.SetDriver(this);

m_FrameCounter = 0;

m_NoCtxFrames = 0;

m_FailedFrame = 0;

m_FailedReason = CaptureSucceeded;

m_Failures = 0;

m_SuccessfulCapture = true;

m_FailureReason = CaptureSucceeded;

m_AppControlledCapture = false;

m_RealDebugFunc = NULL;

m_RealDebugFuncParam = NULL;

m_SuppressDebugMessages = false;

m_DrawcallStack.push_back(&m_ParentDrawcall);

m_CurEventID = 0;

m_CurDrawcallID = 0;

m_FirstEventID = 0;

m_LastEventID = ~0U;

m_FetchCounters = false;

RDCEraseEl(m_ActiveQueries);

m_ActiveConditional = false;

m_ActiveFeedback = false;

if(RenderDoc::Inst().IsReplayApp())

{

m_State = READING;

if(logfile)

{

m_pSerialiser = new Serialiser(logfile, Serialiser::READING, false);

}

else

{

byte dummy[4];

m_pSerialiser = new Serialiser(4, dummy, false);

}

GLMarkerRegion::gl = &m_Real;

// once GL driver is more tested, this can be disabled

if(HasExt[KHR_debug] && m_Real.glDebugMessageCallback)

{

m_Real.glDebugMessageCallback(&DebugSnoopStatic, this);

#if ENABLED(RDOC_DEVEL)

m_Real.glEnable(eGL_DEBUG_OUTPUT_SYNCHRONOUS);

#endif

}

}

else

{

m_State = WRITING_IDLE;

m_pSerialiser = new Serialiser(NULL, Serialiser::WRITING, false);

}

m_DeviceRecord = NULL;

m_ResourceManager = new GLResourceManager(m_State, m_pSerialiser, this);

m_DeviceResourceID =

GetResourceManager()->RegisterResource(GLResource(NULL, eResSpecial, eSpecialResDevice));

m_ContextResourceID =

GetResourceManager()->RegisterResource(GLResource(NULL, eResSpecial, eSpecialResContext));

if(!RenderDoc::Inst().IsReplayApp())

{

m_DeviceRecord = GetResourceManager()->AddResourceRecord(m_DeviceResourceID);

m_DeviceRecord->DataInSerialiser = false;

m_DeviceRecord->Length = 0;

m_DeviceRecord->SpecialResource = true;

m_ContextRecord = GetResourceManager()->AddResourceRecord(m_ContextResourceID);

m_ContextRecord->DataInSerialiser = false;

m_ContextRecord->Length = 0;

m_ContextRecord->SpecialResource = true;

// register VAO 0 as a special VAO, so that it can be tracked if the app uses it

// we immediately mark it dirty since the vertex array tracking functions expect a proper VAO

m_FakeVAOID = GetResourceManager()->RegisterResource(VertexArrayRes(NULL, 0));

GetResourceManager()->AddResourceRecord(m_FakeVAOID);

GetResourceManager()->MarkDirtyResource(m_FakeVAOID);

}

else

{

m_DeviceRecord = m_ContextRecord = NULL;

ResourceIDGen::SetReplayResourceIDs();

InitSPIRVCompiler();

RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler);

}

m_FakeBB_FBO = 0;

m_FakeBB_Color = 0;

m_FakeBB_DepthStencil = 0;

m_FakeVAO = 0;

m_FakeIdxSize = 0;

m_CurChunkOffset = 0;

m_AddedDrawcall = false;

RDCDEBUG("Debug Text enabled - for development! remove before release!");

m_pSerialiser->SetDebugText(true);

m_pSerialiser->SetChunkNameLookup(&GetChunkName);

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

// Compile time asserts

RDCCOMPILE_ASSERT(ARRAY_COUNT(GLChunkNames) == NUM_OPENGL_CHUNKS - FIRST_CHUNK_ID,

"Not right number of chunk names");

}

void WrappedOpenGL::Initialise(GLInitParams &params)

{

// deliberately want to go through our own wrappers to set up e.g. m_Textures members

WrappedOpenGL &gl = *this;

m_InitParams = params;

// as a concession to compatibility, generate a 'fake' VBO to act as VBO 0.

// consider making it an error/warning for programs to use this?

gl.glGenVertexArrays(1, &m_FakeVAO);

gl.glBindVertexArray(m_FakeVAO);

gl.glBindVertexArray(0);

gl.glGenFramebuffers(1, &m_FakeBB_FBO);

gl.glBindFramebuffer(eGL_FRAMEBUFFER, m_FakeBB_FBO);

GLenum colfmt = eGL_RGBA8;

if(params.colorBits == 32)

colfmt = params.isSRGB ? eGL_SRGB8_ALPHA8 : eGL_RGBA8;

else if(params.colorBits == 24)

colfmt = params.isSRGB ? eGL_SRGB8 : eGL_RGB8;

else

RDCERR("Unexpected # colour bits: %d", params.colorBits);

GLenum target = eGL_TEXTURE_2D;

if(params.multiSamples > 1)

target = eGL_TEXTURE_2D_MULTISAMPLE;

gl.glGenTextures(1, &m_FakeBB_Color);

gl.glBindTexture(target, m_FakeBB_Color);