diff options
Diffstat (limited to 'Samples/CommonSrc/Render/Render_GL_Device.cpp')
| -rw-r--r-- | Samples/CommonSrc/Render/Render_GL_Device.cpp | 801 |
1 files changed, 646 insertions, 155 deletions
diff --git a/Samples/CommonSrc/Render/Render_GL_Device.cpp b/Samples/CommonSrc/Render/Render_GL_Device.cpp index 54a2b9b..64da492 100644 --- a/Samples/CommonSrc/Render/Render_GL_Device.cpp +++ b/Samples/CommonSrc/Render/Render_GL_Device.cpp @@ -5,7 +5,7 @@ Content : RenderDevice implementation for OpenGL Created : September 10, 2012 Authors : Andrew Reisse -Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved. +Copyright : Copyright 2012 Oculus VR, LLC All Rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -54,6 +54,7 @@ void (*GetFunction(const char *functionName))( void ) #endif +PFNGLGETSTRINGIPROC glGetStringi; PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers; PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers; PFNGLDELETESHADERPROC glDeleteShader; @@ -95,6 +96,7 @@ PFNGLUNIFORM3FVPROC glUniform3fv; PFNGLUNIFORM2FVPROC glUniform2fv; PFNGLUNIFORM1FVPROC glUniform1fv; PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample; PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage; PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer; PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers; @@ -102,6 +104,7 @@ PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers; PFNGLGENVERTEXARRAYSPROC glGenVertexArrays; PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays; PFNGLBINDVERTEXARRAYPROC glBindVertexArray; +PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebuffer; void InitGLExtensions() { @@ -115,6 +118,7 @@ void InitGLExtensions() glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) GetFunction("glXSwapIntervalEXT"); #endif + glGetStringi = (PFNGLGETSTRINGIPROC) GetFunction("glGetStringi"); glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) GetFunction("glGenFramebuffersEXT"); glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) GetFunction("glDeleteFramebuffersEXT"); glDeleteShader = (PFNGLDELETESHADERPROC) GetFunction("glDeleteShader"); @@ -156,6 +160,7 @@ void InitGLExtensions() glUniform2fv = (PFNGLUNIFORM2FVPROC) GetFunction("glUniform2fv"); glUniform1fv = (PFNGLUNIFORM1FVPROC) GetFunction("glUniform1fv"); glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) GetFunction("glCompressedTexImage2D"); + glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) GetFunction("glTexImage2DMultisample"); glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) GetFunction("glRenderbufferStorageEXT"); glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) GetFunction("glBindRenderbufferEXT"); glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) GetFunction("glGenRenderbuffersEXT"); @@ -163,13 +168,14 @@ void InitGLExtensions() glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) GetFunction("glGenVertexArrays"); glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) GetFunction("glDeleteVertexArrays"); glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) GetFunction("glBindVertexArray"); + glBlitFramebuffer = (PFNGLBLITFRAMEBUFFEREXTPROC) GetFunction("glBlitFramebufferEXT"); } #endif static const char* StdVertexShaderSrc = - "#version 110\n" - +"#version 110\n" + "uniform mat4 Proj;\n" "uniform mat4 View;\n" @@ -252,28 +258,28 @@ static const char* TextureFragShaderSrc = " discard;\n" "}\n"; -#define LIGHTING_COMMON \ +#define LIGHTING_COMMON \ "#version 110\n" \ - "uniform vec3 Ambient;\n" \ - "uniform vec4 LightPos[8];\n" \ - "uniform vec4 LightColor[8];\n" \ - "uniform float LightCount;\n" \ + "uniform vec3 Ambient;\n" \ + "uniform vec4 LightPos[8];\n" \ + "uniform vec4 LightColor[8];\n" \ + "uniform float LightCount;\n" \ "varying vec4 oColor;\n" \ "varying vec2 oTexCoord;\n" \ "varying vec3 oNormal;\n" \ "varying vec3 oVPos;\n" \ - "vec4 DoLight()\n" \ - "{\n" \ - " vec3 norm = normalize(oNormal);\n" \ - " vec3 light = Ambient;\n" \ - " for (int i = 0; i < int(LightCount); i++)\n" \ - " {\n" \ - " vec3 ltp = (LightPos[i].xyz - oVPos);\n" \ - " float ldist = length(ltp);\n" \ - " ltp = normalize(ltp);\n" \ + "vec4 DoLight()\n" \ + "{\n" \ + " vec3 norm = normalize(oNormal);\n" \ + " vec3 light = Ambient;\n" \ + " for (int i = 0; i < int(LightCount); i++)\n" \ + " {\n" \ + " vec3 ltp = (LightPos[i].xyz - oVPos);\n" \ + " float ldist = length(ltp);\n" \ + " ltp = normalize(ltp);\n" \ " light += clamp(LightColor[i].rgb * oColor.rgb * (dot(norm, ltp) / ldist), 0.0,1.0);\n" \ - " }\n" \ - " return vec4(light, oColor.a);\n" \ + " }\n" \ + " return vec4(light, oColor.a);\n" \ "}\n" static const char* LitSolidFragShaderSrc = @@ -308,21 +314,21 @@ static const char* AlphaTextureFragShaderSrc = "}\n"; static const char* AlphaBlendedTextureFragShaderSrc = - "#version 110\n" - - "uniform sampler2D Texture0;\n" + "#version 110\n" - "varying vec4 oColor;\n" - "varying vec2 oTexCoord;\n" + "uniform sampler2D Texture0;\n" - "void main()\n" - "{\n" + "varying vec4 oColor;\n" + "varying vec2 oTexCoord;\n" + + "void main()\n" + "{\n" " vec4 finalColor = oColor;\n" " finalColor *= texture2D(Texture0, oTexCoord);\n" // Blend state expects premultiplied alpha " finalColor.rgb *= finalColor.a;\n" - " gl_FragColor = finalColor;\n" - "}\n"; + " gl_FragColor = finalColor;\n" + "}\n"; static const char* MultiTextureFragShaderSrc = "#version 110\n" @@ -336,15 +342,15 @@ static const char* MultiTextureFragShaderSrc = "void main()\n" "{\n" - " vec4 color = texture2D(Texture0, oTexCoord);\n" + " vec4 color = texture2D(Texture0, oTexCoord);\n" - " gl_FragColor = texture2D(Texture1, oTexCoord1);\n" - " gl_FragColor.rgb = gl_FragColor.rgb * mix(1.9, 1.2, clamp(length(gl_FragColor.rgb),0.0,1.0));\n" + " gl_FragColor = texture2D(Texture1, oTexCoord1);\n" + " gl_FragColor.rgb = gl_FragColor.rgb * mix(1.9, 1.2, clamp(length(gl_FragColor.rgb),0.0,1.0));\n" - " gl_FragColor = color * gl_FragColor;\n" + " gl_FragColor = color * gl_FragColor;\n" - " if (gl_FragColor.a <= 0.6)\n" - " discard;\n" + " if (gl_FragColor.a <= 0.6)\n" + " discard;\n" "}\n"; static const char* PostProcessMeshFragShaderSrc = @@ -455,12 +461,12 @@ static const char* PostProcessMeshTimewarpVertexShaderSrc = // Accurate time warp lerp vs. faster #if 0 // Apply the two 3x3 timewarp rotations to these vectors. - " vec3 TransformedRStart = (EyeRotationStart * vec4(TanEyeAngleR, 0)).xyz;\n" - " vec3 TransformedGStart = (EyeRotationStart * vec4(TanEyeAngleG, 0)).xyz;\n" - " vec3 TransformedBStart = (EyeRotationStart * vec4(TanEyeAngleB, 0)).xyz;\n" - " vec3 TransformedREnd = (EyeRotationEnd * vec4(TanEyeAngleR, 0)).xyz;\n" - " vec3 TransformedGEnd = (EyeRotationEnd * vec4(TanEyeAngleG, 0)).xyz;\n" - " vec3 TransformedBEnd = (EyeRotationEnd * vec4(TanEyeAngleB, 0)).xyz;\n" + " vec3 TransformedRStart = (EyeRotationStart * vec4(TanEyeAngleR, 0)).xyz;\n" + " vec3 TransformedGStart = (EyeRotationStart * vec4(TanEyeAngleG, 0)).xyz;\n" + " vec3 TransformedBStart = (EyeRotationStart * vec4(TanEyeAngleB, 0)).xyz;\n" + " vec3 TransformedREnd = (EyeRotationEnd * vec4(TanEyeAngleR, 0)).xyz;\n" + " vec3 TransformedGEnd = (EyeRotationEnd * vec4(TanEyeAngleG, 0)).xyz;\n" + " vec3 TransformedBEnd = (EyeRotationEnd * vec4(TanEyeAngleB, 0)).xyz;\n" // And blend between them. " vec3 TransformedR = mix ( TransformedRStart, TransformedREnd, Color.a );\n" " vec3 TransformedG = mix ( TransformedGStart, TransformedGEnd, Color.a );\n" @@ -526,7 +532,7 @@ PostProcessMeshTimewarpVertexShaderSrc; "{\n" " vec2 eyeToSourceTexCoord = inTexCoord * EyeToSourceUVScale + EyeToSourceUVOffset;\n" " eyeToSourceTexCoord.y = 1.0 - eyeToSourceTexCoord.y;\n" - " float depth = texelFetch(Texture0, ivec2(eyeToSourceTexCoord * DepthDimSize), 0).x;\n" //FIXME: Use Texture2DLod for #version 110 support. + " float depth = texelFetch(Texture0, ivec2(eyeToSourceTexCoord * DepthDimSize), 0).x;\n" //FIXME: Use Texture2DLod for #version 110 support. " float linearDepth = DepthProjector.y / (depth - DepthProjector.x);\n" " vec4 retVal = vec4(inTexCoord, 1, 1);\n" " retVal.xyz *= linearDepth;\n" @@ -616,7 +622,7 @@ PostProcessMeshTimewarpVertexShaderSrc; " lerpedEyeRot[1] = mix(EyeXformStart[1], EyeXformEnd[1], timewarpLerpFactor);\n" " lerpedEyeRot[2] = mix(EyeXformStart[2], EyeXformEnd[2], timewarpLerpFactor);\n" " lerpedEyeRot[3] = mix(EyeXformStart[3], EyeXformEnd[3], timewarpLerpFactor);\n" - //" float4x4 lerpedEyeRot = EyeXformStart;\n" + //" float4x4 lerpedEyeRot = EyeXformStart;\n" // warped positions are a bit more involved, hence a separate function " gl_Position = TimewarpPos(Position.xy, oTexCoord0, lerpedEyeRot);\n" @@ -641,8 +647,8 @@ static const char* PostProcessFragShaderWithChromAbSrc = "varying vec4 oPosition;\n" "varying vec2 oTexCoord;\n" - - "void main()\n" + + "void main()\n" "{\n" // Input oTexCoord is [-1,1] across the half of the screen used for a single eye. " vec2 TanEyeAngleDistorted = oTexCoord * TanEyeAngleScale + TanEyeAngleOffset;\n" // Scales to tan(thetaX),tan(thetaY), but still distorted (i.e. only the center is correct) @@ -661,15 +667,15 @@ static const char* PostProcessFragShaderWithChromAbSrc = // Scale them into ([0,0.5],[0,1]) or ([0.5,0],[0,1]) UV lookup space (depending on eye) " vec2 SourceCoordR = TanEyeAngleR * EyeToSourceUVScale + EyeToSourceUVOffset;\n" - " SourceCoordR.y = 1.0 - SourceCoordR.y;\n" + " SourceCoordR.y = 1.0 - SourceCoordR.y;\n" " vec2 SourceCoordG = TanEyeAngleG * EyeToSourceUVScale + EyeToSourceUVOffset;\n" - " SourceCoordG.y = 1.0 - SourceCoordG.y;\n" + " SourceCoordG.y = 1.0 - SourceCoordG.y;\n" " vec2 SourceCoordB = TanEyeAngleB * EyeToSourceUVScale + EyeToSourceUVOffset;\n" - " SourceCoordB.y = 1.0 - SourceCoordB.y;\n" + " SourceCoordB.y = 1.0 - SourceCoordB.y;\n" // Find the distance to the nearest edge. " vec2 NDCCoord = TanEyeAngleG * EyeToSourceNDCScale + EyeToSourceNDCOffset;\n" - " float EdgeFadeIn = clamp ( EdgeFadeScale, 0.0, 1e5 ) * ( 1.0 - max ( abs ( NDCCoord.x ), abs ( NDCCoord.y ) ) );\n" + " float EdgeFadeIn = clamp ( EdgeFadeScale, 0.0, 1e5 ) * ( 1.0 - max ( abs ( NDCCoord.x ), abs ( NDCCoord.y ) ) );\n" " if ( EdgeFadeIn < 0.0 )\n" " {\n" " gl_FragColor = vec4(DistortionClearColor.r, DistortionClearColor.g, DistortionClearColor.b, 1.0);\n" @@ -692,7 +698,7 @@ static const char* VShaderSrcs[VShader_Count] = DirectVertexShaderSrc, StdVertexShaderSrc, PostProcessVertexShaderSrc, - PostProcessMeshVertexShaderSrc, + PostProcessMeshVertexShaderSrc, PostProcessMeshTimewarpVertexShaderSrc, PostProcessMeshPositionalTimewarpVertexShaderSrc, PostProcessHeightmapTimewarpVertexShaderSrc, @@ -703,7 +709,7 @@ static const char* FShaderSrcs[FShader_Count] = GouraudFragShaderSrc, TextureFragShaderSrc, AlphaTextureFragShaderSrc, - AlphaBlendedTextureFragShaderSrc, + AlphaBlendedTextureFragShaderSrc, PostProcessFragShaderWithChromAbSrc, LitSolidFragShaderSrc, LitTextureFragShaderSrc, @@ -716,11 +722,25 @@ static const char* FShaderSrcs[FShader_Count] = RenderDevice::RenderDevice(const RendererParams&) + : VertexShaders(), + FragShaders(), + DefaultFill(), + Proj(), + Vao(0), + CurRenderTarget(), + DepthBuffers(), + CurrentFbo(0), + MsaaFbo(0), + GLVersionInfo(), + DebugCallbackControl(), + Lighting(NULL) { + DebugCallbackControl.Initialize(); + GetGLVersionAndExtensions(GLVersionInfo); OVR_ASSERT(GLVersionInfo.MajorVersion >= 2); - + for (int i = 0; i < VShader_Count; i++) { OVR_ASSERT ( VShaderSrcs[i] != NULL ); // You forgot a shader! @@ -732,13 +752,14 @@ RenderDevice::RenderDevice(const RendererParams&) OVR_ASSERT ( FShaderSrcs[i] != NULL ); // You forgot a shader! FragShaders[i] = *new Shader(this, Shader_Fragment, FShaderSrcs[i]); } - + Ptr<ShaderSet> gouraudShaders = *new ShaderSet(); gouraudShaders->SetShader(VertexShaders[VShader_MVP]); gouraudShaders->SetShader(FragShaders[FShader_Gouraud]); DefaultFill = *new ShaderFill(gouraudShaders); glGenFramebuffers(1, &CurrentFbo); + glGenFramebuffers(1, &MsaaFbo); if (GLVersionInfo.SupportsVAO) { @@ -758,7 +779,8 @@ void RenderDevice::Shutdown() // This runs before the subclass's Shutdown(), where the context, etc, may be deleted. - glDeleteFramebuffers(1, &CurrentFbo); + glDeleteFramebuffers(1, &CurrentFbo); + glDeleteFramebuffers(1, &MsaaFbo); if (GLVersionInfo.SupportsVAO) { @@ -777,12 +799,14 @@ void RenderDevice::Shutdown() DefaultFill.Clear(); DepthBuffers.Clear(); + + DebugCallbackControl.Shutdown(); } void RenderDevice::FillTexturedRect(float left, float top, float right, float bottom, float ul, float vt, float ur, float vb, Color c, Ptr<OVR::Render::Texture> tex) { - Render::RenderDevice::FillTexturedRect(left, top, right, bottom, ul, vb, ur, vt, c, tex); + Render::RenderDevice::FillTexturedRect(left, top, right, bottom, ul, vt, ur, vb, c, tex); } @@ -829,12 +853,7 @@ void RenderDevice::SetDepthMode(bool enable, bool write, CompareFunc func) void RenderDevice::SetViewport(const Recti& vp) { - int wh; - if (CurRenderTarget) - wh = CurRenderTarget->Height; - else - wh = WindowHeight; - glViewport(vp.x, wh - vp.y - vp.h, vp.w, vp.h); + glViewport(vp.x, vp.y, vp.w, vp.h); } void RenderDevice::Flush() @@ -844,14 +863,14 @@ void RenderDevice::Flush() void RenderDevice::WaitUntilGpuIdle() { - glFlush(); - glFinish(); + glFlush(); + glFinish(); } void RenderDevice::Clear(float r, float g, float b, float a, float depth, bool clearColor /*= true*/, bool clearDepth /*= true*/) { - glClearColor(r,g,b,a); - glClearDepth(depth); + glClearColor(r,g,b,a); + glClearDepth(depth); glClear( ( clearColor ? ( GL_COLOR_BUFFER_BIT ) : 0 ) | ( clearDepth ? ( GL_DEPTH_BUFFER_BIT ) : 0 ) @@ -869,6 +888,31 @@ Texture* RenderDevice::GetDepthBuffer(int w, int h, int ms) return newDepth.GetPtr(); } +void RenderDevice::ResolveMsaa(OVR::Render::Texture* msaaTex, OVR::Render::Texture* outputTex) +{ + bool isMsaaTarget = msaaTex->GetSamples() > 1; + glBindFramebuffer( GL_READ_FRAMEBUFFER, MsaaFbo ); + glFramebufferTexture2D( GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + isMsaaTarget ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D, + ((Texture*)msaaTex)->TexId, 0); + glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); + OVR_ASSERT(glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); + + glBindFramebuffer( GL_DRAW_FRAMEBUFFER, CurrentFbo ); + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ((Texture*)outputTex)->TexId, 0); + glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); + + OVR_ASSERT(glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); + + //glReadBuffer(GL_TEXTURE_2D_MULTISAMPLE); + //glDrawBuffer(GL_COLOR_ATTACHMENT0); + glBlitFramebuffer( 0, 0, msaaTex->GetWidth(), msaaTex->GetHeight(), + 0, 0, outputTex->GetWidth(), outputTex->GetHeight(), GL_COLOR_BUFFER_BIT, GL_NEAREST ); + glBindFramebuffer( GL_FRAMEBUFFER, 0 ); + GLint err = glGetError(); + OVR_ASSERT(!err); OVR_UNUSED(err); +} + void RenderDevice::SetRenderTarget(Render::Texture* color, Render::Texture* depth, Render::Texture* stencil) { OVR_UNUSED(stencil); @@ -879,14 +923,19 @@ void RenderDevice::SetRenderTarget(Render::Texture* color, Render::Texture* dept glBindFramebuffer(GL_FRAMEBUFFER, 0); return; } - - if (depth == NULL) - depth = GetDepthBuffer(color->GetWidth(), color->GetHeight(), CurRenderTarget->GetSamples()); + + int sampleCount = CurRenderTarget->GetSamples(); + + if (depth == NULL) + depth = GetDepthBuffer(color->GetWidth(), color->GetHeight(), sampleCount); glBindFramebuffer(GL_FRAMEBUFFER, CurrentFbo); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ((Texture*)color)->TexId, 0); + + GLenum texTarget = (sampleCount > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D; + + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texTarget, ((Texture*)color)->TexId, 0); if (depth) - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, ((Texture*)depth)->TexId, 0); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, texTarget, ((Texture*)depth)->TexId, 0); else glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); @@ -904,7 +953,7 @@ void RenderDevice::SetWorldUniforms(const Matrix4f& proj) void RenderDevice::SetTexture(Render::ShaderStage, int slot, const Texture* t) { glActiveTexture(GL_TEXTURE0 + slot); - glBindTexture(GL_TEXTURE_2D, ((Texture*)t)->TexId); + glBindTexture((t->GetSamples() > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D, ((Texture*)t)->TexId); } Buffer* RenderDevice::CreateBuffer() @@ -979,11 +1028,11 @@ void RenderDevice::Render(const Fill* fill, Render::Buffer* vertices, Render::Bu Lighting->Set(shaders); } - glBindBuffer(GL_ARRAY_BUFFER, ((Buffer*)vertices)->GLBuffer); - for (int i = 0; i < 5; i++) - glEnableVertexAttribArray(i); + glBindBuffer(GL_ARRAY_BUFFER, ((Buffer*)vertices)->GLBuffer); + for (int i = 0; i < 5; i++) + glEnableVertexAttribArray(i); - switch (meshType) + switch (meshType) { case Mesh_Distortion: glVertexAttribPointer(0, 2, GL_FLOAT, false, sizeof(DistortionVertex), reinterpret_cast<char*>(offset) + offsetof(DistortionVertex, Pos)); @@ -1016,8 +1065,8 @@ void RenderDevice::Render(const Fill* fill, Render::Buffer* vertices, Render::Bu glDrawArrays(prim, 0, count); } - for (int i = 0; i < 5; i++) - glDisableVertexAttribArray(i); + for (int i = 0; i < 5; i++) + glDisableVertexAttribArray(i); } void RenderDevice::RenderWithAlpha(const Fill* fill, Render::Buffer* vertices, Render::Buffer* indices, @@ -1104,8 +1153,16 @@ bool Shader::Compile(const char* src) return 1; } -ShaderSet::ShaderSet() +ShaderSet::ShaderSet() : + //Prog(0), + UniformInfo(), + ProjLoc(0), + ViewLoc(0), + //TexLoc[8]; + UsesLighting(false), + LightingVer(0) { + memset(TexLoc, 0, sizeof(TexLoc)); Prog = glCreateProgram(); } ShaderSet::~ShaderSet() @@ -1155,9 +1212,9 @@ bool ShaderSet::Link() LightingVer = 0; UsesLighting = 0; - GLint uniformCount = 0; - glGetProgramiv(Prog, GL_ACTIVE_UNIFORMS, &uniformCount); - OVR_ASSERT(uniformCount >= 0); + GLint uniformCount = 0; + glGetProgramiv(Prog, GL_ACTIVE_UNIFORMS, &uniformCount); + OVR_ASSERT(uniformCount >= 0); for(GLuint i = 0; i < (GLuint)uniformCount; i++) { @@ -1260,7 +1317,7 @@ bool ShaderSet::SetUniform4x4f(const char* name, const Matrix4f& m) return 0; } -Texture::Texture(RenderDevice* r, int w, int h) : Ren(r), Width(w), Height(h) +Texture::Texture(RenderDevice* r, int w, int h, int samples) : Ren(r), Width(w), Height(h), Samples(samples) { glGenTextures(1, &TexId); } @@ -1278,7 +1335,7 @@ void Texture::Set(int slot, Render::ShaderStage stage) const void Texture::SetSampleMode(int sm) { - glBindTexture(GL_TEXTURE_2D, TexId); + glBindTexture((GetSamples() > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D, TexId); switch (sm & Sample_FilterMask) { case Sample_Linear: @@ -1294,7 +1351,7 @@ void Texture::SetSampleMode(int sm) break; case Sample_Nearest: - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1); break; @@ -1321,8 +1378,8 @@ void Texture::SetSampleMode(int sm) ovrTexture Texture::Get_ovrTexture() { - ovrTexture tex; - OVR::Sizei newRTSize(Width, Height); + ovrTexture tex; + OVR::Sizei newRTSize(Width, Height); ovrGLTextureData* texData = (ovrGLTextureData*)&tex; texData->Header.API = ovrRenderAPI_OpenGL; @@ -1330,7 +1387,7 @@ ovrTexture Texture::Get_ovrTexture() texData->Header.RenderViewport = Recti(newRTSize); texData->TexId = TexId; - return tex; + return tex; } Texture* RenderDevice::CreateTexture(int format, int width, int height, const void* data, int mipcount) @@ -1340,23 +1397,34 @@ Texture* RenderDevice::CreateTexture(int format, int width, int height, const vo { case Texture_RGBA: glformat = GL_RGBA; break; case Texture_R: glformat = GL_RED; break; - case Texture_Depth: glformat = GL_DEPTH_COMPONENT; gltype = GL_FLOAT; break; + case Texture_Depth: glformat = GL_DEPTH_COMPONENT; gltype = GL_FLOAT; break; case Texture_DXT1: glformat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break; case Texture_DXT3: glformat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break; case Texture_DXT5: glformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break; default: return NULL; } - Texture* NewTex = new Texture(this, width, height); - glBindTexture(GL_TEXTURE_2D, NewTex->TexId); - GLint err = glGetError(); + int samples = format & Texture_SamplesMask; + if(samples < 1 || + GLVersionInfo.WholeVersion < 302) // disallow MSAA for low GL context versions + { + samples = 1; + } + + GLenum textureTarget = (samples > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D; + + Texture* NewTex = new Texture(this, width, height, samples); + glBindTexture(textureTarget, NewTex->TexId); + GLint err = glGetError(); + #if ! defined(OVR_OS_MAC) OVR_ASSERT(!err); + #endif - if( err ) - { - printf("%d\n", err); - } + if( err ) + { + printf("RenderDevice::CreateTexture glGetError result: %d\n", err); + } if (format & Texture_Compressed) { @@ -1374,14 +1442,17 @@ Texture* RenderDevice::CreateTexture(int format, int width, int height, const vo if (h < 1) h = 1; } } - else - { - bool isSRGB = ((format & Texture_TypeMask) == Texture_RGBA && (format & Texture_SRGB) != 0); - bool isDepth = ((format & Texture_Depth) != 0); - GLenum internalFormat = (isSRGB) ? GL_SRGB_ALPHA : (isDepth) ? GL_DEPTH_COMPONENT32F : glformat; + else + { + bool isSRGB = ((format & Texture_TypeMask) == Texture_RGBA && (format & Texture_SRGB) != 0); + bool isDepth = ((format & Texture_Depth) != 0); + GLenum internalFormat = (isSRGB) ? GL_SRGB8_ALPHA8 : (isDepth) ? GL_DEPTH_COMPONENT32F : glformat; - glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, glformat, gltype, data); - } + if (samples > 1) + glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, internalFormat, width, height, false); + else + glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, glformat, gltype, data); + } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); @@ -1435,9 +1506,397 @@ RBuffer::~RBuffer() } -//// GLVersion -static void ParseGLVersion(GLVersionAndExtensions& versionInfo) + + + +DebugCallback::DebugCallback() + : Initialized(false), + MinLogSeverity(SeverityHigh), + MinAssertSeverity(SeverityHigh), + glDebugMessageCallback(NULL), + glDebugMessageControl(NULL), + glDebugMessageCallbackARB(NULL), + glDebugMessageControlARB(NULL), + glDebugMessageCallbackAMD(NULL), + glDebugMessageControlAMD(NULL) +{ +} + + +DebugCallback::~DebugCallback() +{ + Shutdown(); +} + + +bool DebugCallback::GetGLDebugCallback(PFNGLDEBUGMESSAGECALLBACKPROC* debugCallback, const void** userParam) const +{ + // Curiously, the KHR and ARB callbacks use the same glGetPointerv defines, which means you can only have + // one of them active concurrently. This also implies that an OpenGL implementation which implements both + // KHR and ARB implements the latter as simply a passthrough (or alias) of the former. + #if defined(GL_ARB_debug_output) || defined(GL_KHR_debug) + // glGetPointerv requires at least OpenGL 4.3 headers and implementation, + // but will be present in the headers if GL_ARB_debug_output or GL_KHR_debug are. + if(glDebugMessageCallback || glDebugMessageCallbackARB) + { + glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION, reinterpret_cast<GLvoid**>(debugCallback)); + glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM, const_cast<GLvoid**>(userParam)); + return true; + } + #endif + + // AMD_debug_output doesn't provide an option to get the debug callback. + debugCallback = NULL; + userParam = NULL; + return false; +} + + +void DebugCallback::DebugCallbackInternal(Severity s, const char* pSource, const char* pType, GLuint id, const char* pSeverity, const char* message) +{ + if(s >= MinLogSeverity) + { + OVR::LogError("{ERR-xxxx} [GL Error] %s %s %#x %s: %s", pSource, pType, id, pSeverity, message); + } + + if(s >= MinAssertSeverity) + { + OVR_ASSERT(s < MinAssertSeverity); // Unilateral fail. + } +} + + +void DebugCallback::Initialize() +{ + if(!Initialized) + { + Initialized = true; + + int err = glGetError(); + OVR_UNUSED(err); + + // Used to see if a callback was already registered. + PFNGLDEBUGMESSAGECALLBACKPROC debugCallbackPrev = NULL; + const void* userParamPrev = NULL; + + // Try getting the KHR interface. + #if defined(OVR_OS_MAC) // With Mac OpenGL, functions aren't dynamically linked. They are only directly called. + //glDebugMessageCallback = ::glDebugMessageCallback; // We can enable this some day when Apple includes support + //glDebugMessageControl = ::glDebugMessageControl; // for glDebugMessageCallback in their headers and SDK. + #else + glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC) GetFunction("glDebugMessageCallback"); + glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC) GetFunction("glDebugMessageControl"); + #endif + + if(glDebugMessageCallback) + { + GetGLDebugCallback(&debugCallbackPrev, &userParamPrev); + + if(!debugCallbackPrev) // If a callback isn't already registered... + { + glDebugMessageCallback(GLDEBUGPROC(DebugMessageCallback), this); + err = glGetError(); + if(err) + { + glDebugMessageCallback = NULL; + glDebugMessageControl = NULL; + OVR_DEBUG_LOG(("glDebugMessageCallback error: %x (%d)\n", err, err)); + } + + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + err = glGetError(); + if(err) + { + OVR_DEBUG_LOG(("GL_DEBUG_OUTPUT_SYNCHRONOUS error: %x (%d)\n", err, err)); + } + + // To consider: disable marker/push/pop + // glDebugMessageControl(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, GL_DONT_CARE, 0, NULL, GL_FALSE); + // glDebugMessageControl(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PUSH_GROUP, GL_DONT_CARE, 0, NULL, GL_FALSE); + // glDebugMessageControl(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_POP_GROUP, GL_DONT_CARE, 0, NULL, GL_FALSE); + } + } + + if(!glDebugMessageCallback) // If KHR_debug wasn't found, try ARB_debug_output. + { + #if !defined(OVR_OS_MAC) + glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC) GetFunction("glDebugMessageCallbackARB"); + glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC) GetFunction("glDebugMessageControlARB"); + #endif + + if(glDebugMessageCallbackARB) + { + GetGLDebugCallback(&debugCallbackPrev, &userParamPrev); + + if(!debugCallbackPrev) // If a callback isn't already registered... + { + glDebugMessageCallbackARB(GLDEBUGPROCARB(DebugMessageCallback), this); + err = glGetError(); + if(err) + { + glDebugMessageCallbackARB = NULL; + glDebugMessageControlARB = NULL; + OVR_DEBUG_LOG(("glDebugMessageCallbackARB error: %x (%d)\n", err, err)); + } + + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + err = glGetError(); + if(err) + { + OVR_DEBUG_LOG(("GL_DEBUG_OUTPUT_SYNCHRONOUS error: %x (%d)\n", err, err)); + } + + // To consider: disable marker/push/pop + // glDebugMessageControlARB(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, GL_DONT_CARE, 0, NULL, GL_FALSE); + // glDebugMessageControlARB(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PUSH_GROUP, GL_DONT_CARE, 0, NULL, GL_FALSE); + // glDebugMessageControlARB(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_POP_GROUP, GL_DONT_CARE, 0, NULL, GL_FALSE); + } + } + } + + if(!glDebugMessageCallback && !glDebugMessageCallbackARB)// If ARB_debug_output also wasn't found, try AMD_debug_output. + { + #if !defined(OVR_OS_MAC) + glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC) GetFunction("glDebugMessageCallbackAMD"); + glDebugMessageControlAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC) GetFunction("glDebugMessageControlAMD"); + #endif + + if(glDebugMessageCallbackAMD) + { + if(!debugCallbackPrev) // If a callback isn't already registered... + { + glDebugMessageCallbackAMD(GLDEBUGPROCAMD(DebugMessageCallbackAMD), this); + err = glGetError(); + if(err) + { + glDebugMessageCallbackAMD = NULL; + glDebugMessageControlAMD = NULL; + OVR_DEBUG_LOG(("glDebugMessageCallbackAMD error: %x (%d)\n", err, err)); + } + // There is no control for synchronous/asynchronous with AMD_debug_output. + } + } + } + } +} + + +void DebugCallback::Shutdown() +{ + if(Initialized) + { + if(glDebugMessageCallbackAMD) + { + glDebugMessageCallbackAMD(NULL, NULL); + glDebugMessageCallbackAMD = NULL; + } + + if(glDebugMessageCallbackARB) + { + glDebugMessageCallbackARB(NULL, NULL); + glDebugMessageCallbackARB = NULL; + } + + if(glDebugMessageCallback) + { + glDebugMessageCallback(NULL, NULL); + glDebugMessageCallback = NULL; + } + + Initialized = false; + } +} + + +void DebugCallback::SetMinSeverity(Severity minLogSeverity, Severity minAssertSeverity) +{ + MinLogSeverity = minLogSeverity; + MinAssertSeverity = minAssertSeverity; +} + + +DebugCallback::Implementation DebugCallback::GetImplementation() const +{ + if(glDebugMessageCallbackAMD) + return ImplementationAMD; + + if(glDebugMessageCallbackARB) + return ImplementationARB; + + if(glDebugMessageCallback) + return ImplementationKHR; + + return ImplementationNone; +} + + +void DebugCallback::DebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei /*length*/, const GLchar* message, GLvoid* userParam) +{ + const char* pSource = GetSource(source); + const char* pType = GetType(type); + const char* pSeverity = GetSeverity(severity); + Severity s; + + switch(severity) + { + default: + case GL_DEBUG_SEVERITY_NOTIFICATION: + s = SeverityNotification; + break; + case GL_DEBUG_SEVERITY_LOW: + s = SeverityLow; + break; + case GL_DEBUG_SEVERITY_MEDIUM: + s = SeverityMedium; + break; + case GL_DEBUG_SEVERITY_HIGH: + s = SeverityHigh; + break; + } + + DebugCallback* pThis = reinterpret_cast<DebugCallback*>(userParam); + pThis->DebugCallbackInternal(s, pSource, pType, id, pSeverity, message); +} + + +const char* DebugCallback::GetSource(GLenum Source) +{ + // There is one contiguous section of GL_DEBUG_SOURCE values. + static_assert((GL_DEBUG_SOURCE_OTHER - GL_DEBUG_SOURCE_API) == 5, "GL_DEBUG_SOURCE constants are not contiguous."); + + static const char* GL_SourceStrings[] = + { + "API", // GL_DEBUG_SOURCE_API + "System", // GL_DEBUG_SOURCE_WINDOW_SYSTEM + "ShaderCompiler", // GL_DEBUG_SOURCE_SHADER_COMPILER + "ThirdParty", // GL_DEBUG_SOURCE_THIRD_PARTY + "Application", // GL_DEBUG_SOURCE_APPLICATION + "Other" // GL_DEBUG_SOURCE_OTHER + }; + + if ((Source >= GL_DEBUG_SOURCE_API) && (Source <= GL_DEBUG_SOURCE_OTHER)) + return GL_SourceStrings[Source - GL_DEBUG_SOURCE_API]; + + return "Unknown"; +} + + + +const char* DebugCallback::GetType(GLenum Type) +{ + // There are two contiguous sections of GL_DEBUG_TYPE values. + static_assert((GL_DEBUG_TYPE_OTHER - GL_DEBUG_TYPE_ERROR) == 5, "GL_DEBUG_TYPE constants are not contiguous."); + static const char* TypeStrings[] = + { + "Error", // GL_DEBUG_TYPE_ERROR + "Deprecated", // GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR + "UndefinedBehavior", // GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR + "Portability", // GL_DEBUG_TYPE_PORTABILITY + "Performance", // GL_DEBUG_TYPE_PERFORMANCE + "Other" // GL_DEBUG_TYPE_OTHER + }; + + if ((Type >= GL_DEBUG_TYPE_ERROR) && (Type <= GL_DEBUG_TYPE_OTHER)) + return TypeStrings[Type - GL_DEBUG_TYPE_ERROR]; + + // KHR_debug marker/push/pop functionality. + static_assert((GL_DEBUG_TYPE_POP_GROUP - GL_DEBUG_TYPE_MARKER) == 2, "GL_DEBUG_TYPE constants are not contiguous."); + static const char* TypeStrings2[] = + { + "Marker", // GL_DEBUG_TYPE_MARKER + "PushGroup", // GL_DEBUG_TYPE_PUSH_GROUP + "PopGroup", // GL_DEBUG_TYPE_POP_GROUP + }; + + if ((Type >= GL_DEBUG_TYPE_MARKER) && (Type <= GL_DEBUG_TYPE_POP_GROUP)) + return TypeStrings2[Type - GL_DEBUG_TYPE_MARKER]; + + return "Unknown"; +} + + +const char* DebugCallback::GetSeverity(GLenum Severity) +{ + // There are two sections of GL_DEBUG_SEVERITY. + static_assert((GL_DEBUG_SEVERITY_LOW - GL_DEBUG_SEVERITY_HIGH) == 2, "GL_DEBUG_SEVERITY constants are not contiguous."); + static const char* SeverityStrings[] = + { + "High", + "Medium", + "Low" + }; + + if ((Severity >= GL_DEBUG_SEVERITY_HIGH) && (Severity <= GL_DEBUG_SEVERITY_LOW)) + return SeverityStrings[Severity - GL_DEBUG_SEVERITY_HIGH]; + + // There is just one value in this second section. + if(Severity == GL_DEBUG_SEVERITY_NOTIFICATION) + return "Notification"; + + return "Unknown"; +} + + +void DebugCallback::DebugMessageCallbackAMD(GLuint id, GLenum category, GLenum severity, GLsizei /*length*/, const GLchar *message, GLvoid *userParam) +{ + static_assert(GL_DEBUG_SEVERITY_LOW_AMD == GL_DEBUG_SEVERITY_LOW, "Severity mismatch"); // Verify that AMD_debug_output severity constants are identical to KHR_debug severity contstants. + + const char* pSource = GetCategoryAMD(category); + const char* pSeverity = GetSeverity(severity); + Severity s; + + switch(severity) + { + default: + case GL_DEBUG_SEVERITY_NOTIFICATION: + s = SeverityNotification; + break; + case GL_DEBUG_SEVERITY_LOW: + s = SeverityLow; + break; + case GL_DEBUG_SEVERITY_MEDIUM: + s = SeverityMedium; + break; + case GL_DEBUG_SEVERITY_HIGH: + s = SeverityHigh; + break; + } + + DebugCallback* pThis = reinterpret_cast<DebugCallback*>(userParam); + pThis->DebugCallbackInternal(s, pSource, "Other", id, pSeverity, message); +} + + +const char* DebugCallback::GetCategoryAMD(GLenum Category) +{ + static_assert((GL_DEBUG_CATEGORY_OTHER_AMD - GL_DEBUG_CATEGORY_API_ERROR_AMD) == 7, "GL_DEBUG_CATEGORY constants are not contiguous."); + static const char* CategoryStrings[] = + { + "API", // GL_DEBUG_CATEGORY_API_ERROR_AMD + "System", // GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD + "Deprecation", // GL_DEBUG_CATEGORY_DEPRECATION_AMD + "UndefinedBehavior", // GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD + "Performance", // GL_DEBUG_CATEGORY_PERFORMANCE_AMD + "ShaderCompiler", // GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD + "Application", // GL_DEBUG_CATEGORY_APPLICATION_AMD + "Other" // GL_DEBUG_CATEGORY_OTHER_AMD + }; + + if((Category >= GL_DEBUG_CATEGORY_API_ERROR_AMD) && (Category <= GL_DEBUG_CATEGORY_OTHER_AMD)) + return CategoryStrings[Category - GL_DEBUG_CATEGORY_API_ERROR_AMD]; + + return "Unknown"; +} + + + + + + + + +void GLVersionAndExtensions::ParseGLVersion() { const char* version = (const char*)glGetString(GL_VERSION); int fields = 0, major = 0, minor = 0; @@ -1448,23 +1907,14 @@ static void ParseGLVersion(GLVersionAndExtensions& versionInfo) { OVR_DEBUG_LOG(("GL_VERSION: %s", (const char*)version)); -#ifdef OVR_CC_MSVC - // Hack: This is using sscanf_s on MSVC to kill the security warning. - // Normally the two functions are not interchangeable because the string format - // is different for %s types, however we only use %d so it's fine. -#define TEMP_OVR_SSCANF sscanf_s -#else -#define TEMP_OVR_SSCANF sscanf -#endif - // Skip all leading non-digits before reading %d. // Example GL_VERSION strings: // "1.5 ATI-1.4.18" // "OpenGL ES-CM 3.2" - fields = TEMP_OVR_SSCANF(version, isdigit(*version) ? "%d.%d" : "%*[^0-9]%d.%d", &major, &minor); + OVR_DISABLE_MSVC_WARNING(4996) // "scanf may be unsafe" + fields = sscanf(version, isdigit(*version) ? "%d.%d" : "%*[^0-9]%d.%d", &major, &minor); isGLES = (strstr(version, "OpenGL ES") != NULL); - -#undef TEMP_OVR_SSCANF + OVR_RESTORE_MSVC_WARNING() } else { @@ -1481,81 +1931,122 @@ static void ParseGLVersion(GLVersionAndExtensions& versionInfo) } // Write version data - versionInfo.MajorVersion = major; - versionInfo.MinorVersion = minor; - versionInfo.IsGLES = isGLES; + MajorVersion = major; + MinorVersion = minor; + WholeVersion = (major * 100) + minor; + IsGLES = isGLES; + IsCoreProfile = (MajorVersion >= 3); // Until we get a better way to detect core profiles, we err on the conservative side and set to true if the version is >= 3. } -static bool HasGLExtension(const char* extensions, const char* searchKey) -{ - const int searchKeyLen = (int)strlen(searchKey); - const char* p = extensions; - for (;;) +bool GLVersionAndExtensions::HasGLExtension(const char* searchKey) const +{ + if (Extensions && Extensions[0]) // If we have an extension string to search for individual extensions... { - p = strstr(p, searchKey); + const int searchKeyLen = (int)strlen(searchKey); + const char* p = Extensions; - // If not found, - if (p == NULL) + for (;;) { - break; - } + p = strstr(p, searchKey); - // Only match full string - if ((p == extensions || p[-1] == ' ') && - (p[searchKeyLen] == '\0' || p[searchKeyLen] == ' ')) - { - return true; + // If not found, + if (p == NULL) + { + break; + } + + // Only match full string + if ((p == Extensions || p[-1] == ' ') && + (p[searchKeyLen] == '\0' || p[searchKeyLen] == ' ')) + { + return true; + } + + // Skip ahead + p += searchKeyLen; } + } + else + { + if (MajorVersion >= 3) // If glGetIntegerv(GL_NUM_EXTENSIONS, ...) is supported... + { + GLint extensionCount = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount); + GLenum err = glGetError(); - // Skip ahead - p += searchKeyLen; + if (err == 0) + { + for (GLint i = 0; i != extensionCount; ++i) + { + const char* extension = (const char*)glGetStringi(GL_EXTENSIONS, (GLuint)i); + + if (extension) // glGetStringi returns NULL upon error. + { + if (strcmp(extension, searchKey) == 0) + return true; + } + else + break; + } + } + } } return false; } -static void ParseGLExtensions(GLVersionAndExtensions& versionInfo) +void GLVersionAndExtensions::ParseGLExtensions() { - const char* extensions = (const char*)glGetString(GL_EXTENSIONS); - - OVR_ASSERT(extensions); - if (!extensions) + if (MajorVersion >= 3) { - extensions = ""; // Note: glGetString() can return null - LogText("Warning: GL_EXTENSIONS was NULL\n"); + // Set to empty because we need to use glGetStringi to read extensions on recent OpenGL. + Extensions = ""; } else { - // Cannot print this to debug log: It's too long! - //OVR_DEBUG_LOG(("GL_EXTENSIONS: %s", (const char*)extensions)); + const char* extensions = (const char*)glGetString(GL_EXTENSIONS); + + OVR_ASSERT(extensions); + if (!extensions) + { + extensions = ""; // Note: glGetString() can return null + LogText("Warning: GL_EXTENSIONS was NULL\n"); + } + else + { + // Cannot print this to debug log: It's too long! + //OVR_DEBUG_LOG(("GL_EXTENSIONS: %s", (const char*)extensions)); + } + + Extensions = extensions; } - versionInfo.Extensions = extensions; + // To do: revise the code below to loop through calls to glGetStringi(GL_EXTENSIONS, ...) so that all extensions below + // can be searched with a single pass over the extensions instead of a full loop per HasGLExtensionCall. - if (versionInfo.MajorVersion >= 3) + if (MajorVersion >= 3) { - versionInfo.SupportsVAO = true; + SupportsVAO = true; } else { - versionInfo.SupportsVAO = - HasGLExtension(extensions, "GL_ARB_vertex_array_object") || - HasGLExtension(extensions, "GL_APPLE_vertex_array_object"); + SupportsVAO = + HasGLExtension("GL_ARB_vertex_array_object") || + HasGLExtension("GL_APPLE_vertex_array_object"); } - versionInfo.SupportsDrawBuffers = HasGLExtension(extensions, "GL_EXT_draw_buffers2"); + SupportsDrawBuffers = HasGLExtension("GL_EXT_draw_buffers2"); // Add more extension checks here... } void GetGLVersionAndExtensions(GLVersionAndExtensions& versionInfo) { - ParseGLVersion(versionInfo); - + versionInfo.ParseGLVersion(); // GL Version must be parsed before parsing extensions: - - ParseGLExtensions(versionInfo); + versionInfo.ParseGLExtensions(); + // To consider: Call to glGetStringi(GL_SHADING_LANGUAGE_VERSION, ...) check/validate the GLSL support. } |