From baa530eb5f80e2ee4461907fc28487a20f25e8c9 Mon Sep 17 00:00:00 2001 From: valeriog Date: Fri, 31 Oct 2014 19:47:42 +0100 Subject: [PATCH] Add visualization of most missing OpenGL texture types (cube maps, texture arrays, stencil, 1D/3D textures, integer textures), take selected mip level into account and point sampling when required. --- renderdoc/data/glsl/debuguniforms.h | 84 ++++++++ renderdoc/data/glsl/texdisplay.frag | 293 ++++++++++++++++++++++++---- renderdoc/data/renderdoc.rc | 1 + renderdoc/data/resource.h | 1 + renderdoc/driver/gl/gl_debug.cpp | 152 +++++++++++---- renderdoc/driver/gl/gl_replay.h | 2 - renderdoc/renderdoc.vcxproj | 1 + renderdoc/renderdoc.vcxproj.filters | 3 + 8 files changed, 466 insertions(+), 71 deletions(-) create mode 100644 renderdoc/data/glsl/debuguniforms.h diff --git a/renderdoc/data/glsl/debuguniforms.h b/renderdoc/data/glsl/debuguniforms.h new file mode 100644 index 000000000..d25c95326 --- /dev/null +++ b/renderdoc/data/glsl/debuguniforms.h @@ -0,0 +1,84 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * 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. + ******************************************************************************/ + +// use some preprocessor hacks to compile the same header in both GLSL and C++ so we can define +// classes that represent a whole cbuffer +#if defined(__cplusplus) + +#define uniform struct +#define vec2 Vec2f +#define vec3 Vec3f +#define vec4 Vec4f + +#define BINDING(b) + +#else + +#version 420 core + +#define BINDING(b) layout (binding = b, std140) + +#endif + +BINDING(0) uniform texdisplay +{ + vec2 Position; + float Scale; + float HDRMul; + + vec4 Channels; + + float RangeMinimum; + float InverseRangeSize; + float MipLevel; + int FlipY; + + vec3 TextureResolutionPS; + int OutputDisplayFormat; + + vec2 OutputRes; + int RawOutput; + float Slice; +}; + +// some constants available to both C++ and GLSL for configuring display +#define CUBEMAP_FACE_POS_X 0 +#define CUBEMAP_FACE_NEG_X 1 +#define CUBEMAP_FACE_POS_Y 2 +#define CUBEMAP_FACE_NEG_Y 3 +#define CUBEMAP_FACE_POS_Z 4 +#define CUBEMAP_FACE_NEG_Z 5 + +#define RESTYPE_TEX1D 0x1 +#define RESTYPE_TEX2D 0x2 +#define RESTYPE_TEX3D 0x3 +#define RESTYPE_TEXCUBE 0x4 +#define RESTYPE_TEX1DARRAY 0x5 +#define RESTYPE_TEX2DARRAY 0x6 +#define RESTYPE_TEXCUBEARRAY 0x7 + +#define TEXDISPLAY_TYPEMASK 0x7 +#define TEXDISPLAY_UINT_TEX 0x8 +#define TEXDISPLAY_SINT_TEX 0x10 + diff --git a/renderdoc/data/glsl/texdisplay.frag b/renderdoc/data/glsl/texdisplay.frag index 493e32cfc..fc7477cd2 100644 --- a/renderdoc/data/glsl/texdisplay.frag +++ b/renderdoc/data/glsl/texdisplay.frag @@ -22,52 +22,269 @@ * THE SOFTWARE. ******************************************************************************/ -#version 420 core +layout (binding = 1) uniform sampler1D tex1D; +layout (binding = 2) uniform sampler2D tex2D; +layout (binding = 3) uniform sampler3D tex3D; +layout (binding = 4) uniform samplerCube texCube; +layout (binding = 5) uniform sampler1DArray tex1DArray; +layout (binding = 6) uniform sampler2DArray tex2DArray; +layout (binding = 7) uniform samplerCubeArray texCubeArray; -layout (binding = 0, std140) uniform texdisplay -{ - vec2 Position; - float Scale; - float HDRMul; +layout (binding = 9) uniform usampler1D texUInt1D; +layout (binding = 10) uniform usampler2D texUInt2D; +layout (binding = 11) uniform usampler3D texUInt3D; +layout (binding = 13) uniform usampler1DArray texUInt1DArray; +layout (binding = 14) uniform usampler2DArray texUInt2DArray; - vec4 Channels; +layout (binding = 16) uniform isampler1D texSInt1D; +layout (binding = 17) uniform isampler2D texSInt2D; +layout (binding = 18) uniform isampler3D texSInt3D; +layout (binding = 20) uniform isampler1DArray texSInt1DArray; +layout (binding = 21) uniform isampler2DArray texSInt2DArray; - float RangeMinimum; - float InverseRangeSize; - float MipLevel; - int FlipY; - - vec3 TextureResolutionPS; - int OutputDisplayFormat; - - vec2 OutputRes; - int RawOutput; - float Slice; -}; - -layout (binding = 0) uniform sampler2D tex0; layout (location = 0) out vec4 color_out; +vec3 CalcCubeCoord(vec2 uv, int face) +{ + // Map UVs to [-0.5, 0.5] and rotate + uv -= vec2(0.5); + vec3 coord; + if (face == CUBEMAP_FACE_POS_X) + coord = vec3(0.5, uv.y, -uv.x); + else if (face == CUBEMAP_FACE_NEG_X) + coord = vec3(-0.5, -uv.y, uv.x); + else if (face == CUBEMAP_FACE_POS_Y) + coord = vec3(uv.x, 0.5, uv.y); + else if (face == CUBEMAP_FACE_NEG_Y) + coord = vec3(uv.x, -0.5, -uv.y); + else if (face == CUBEMAP_FACE_POS_Z) + coord = vec3(uv.x, -uv.y, 0.5); + else // face == CUBEMAP_FACE_NEG_Z + coord = vec3(-uv.x, -uv.y, -0.5); + return coord; +} + +uvec4 SampleTextureUInt4(vec2 pos, int type, bool flipY, int mipLevel, float slice) +{ + uvec4 col; + if (type == RESTYPE_TEX1D) + { + int size = textureSize(texUInt1D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size) discard; + + col = texelFetch(texUInt1D, int(pos.x), mipLevel); + } + else if (type == RESTYPE_TEX1DARRAY) + { + ivec2 size = textureSize(texUInt1DArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x) discard; + + col = texelFetch(texUInt1DArray, ivec2(pos.x, slice), mipLevel); + } + else if (type == RESTYPE_TEX2D) + { + ivec2 size = textureSize(texUInt2D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + col = texelFetch(texUInt2D, ivec2(pos), mipLevel); + } + else if (type == RESTYPE_TEX2DARRAY) + { + ivec3 size = textureSize(texUInt2DArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + col = texelFetch(texUInt2DArray, ivec3(pos, slice), mipLevel); + } + else // if (type == RESTYPE_TEX3D) + { + ivec3 size = textureSize(texUInt3D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + col = texelFetch(texUInt3D, ivec3(pos, slice), mipLevel); + } + + return col; +} + +ivec4 SampleTextureSInt4(vec2 pos, int type, bool flipY, int mipLevel, float slice) +{ + ivec4 col; + if (type == RESTYPE_TEX1D) +{ + int size = textureSize(texSInt1D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size) discard; + + col = texelFetch(texSInt1D, int(pos.x), mipLevel); + } + else if (type == RESTYPE_TEX1DARRAY) + { + ivec2 size = textureSize(texSInt1DArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x) discard; + + col = texelFetch(texSInt1DArray, ivec2(pos.x, slice), mipLevel); + } + else if (type == RESTYPE_TEX2D) + { + ivec2 size = textureSize(texSInt2D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + col = texelFetch(texSInt2D, ivec2(pos), mipLevel); + } + else if (type == RESTYPE_TEX2DARRAY) + { + ivec3 size = textureSize(texSInt2DArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + col = texelFetch(texSInt2DArray, ivec3(pos, slice), mipLevel); + } + else // if (type == RESTYPE_TEX3D) + { + ivec3 size = textureSize(texSInt3D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + col = texelFetch(texSInt3D, ivec3(pos, slice), mipLevel); + } + + return col; +} + + +vec4 SampleTextureFloat4(vec2 pos, int type, bool flipY, bool linearSample, int mipLevel, float slice) +{ + vec4 col; + if (type == RESTYPE_TEX1D) + { + int size = textureSize(tex1D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size) discard; + + if (linearSample) + col = texture(tex1D, pos.x / size); + else + col = texelFetch(tex1D, int(pos.x), mipLevel); + } + else if (type == RESTYPE_TEX1DARRAY) + { + ivec2 size = textureSize(tex1DArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x) discard; + + if (linearSample) + col = texture(tex1DArray, vec2(pos.x / size.x, slice)); + else + col = texelFetch(tex1DArray, ivec2(pos.x, slice), mipLevel); + } + else if (type == RESTYPE_TEX2D) + { + ivec2 size = textureSize(tex2D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + if (linearSample) + col = texture(tex2D, pos / size); + else + col = texelFetch(tex2D, ivec2(pos), mipLevel); + } + else if (type == RESTYPE_TEX2DARRAY) + { + ivec3 size = textureSize(tex2DArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + if (linearSample) + col = texture(tex2DArray, vec3(pos / size.xy, slice)); + else + col = texelFetch(tex2DArray, ivec3(pos, slice), mipLevel); + } + else if (type == RESTYPE_TEX3D) + { + ivec3 size = textureSize(tex3D, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + if (linearSample) + col = texture(tex3D, vec3(pos / size.xy, slice)); + else + col = texelFetch(tex3D, ivec3(pos, slice), mipLevel); + } + else if (type == RESTYPE_TEXCUBE) + { + ivec2 size = textureSize(texCube, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + vec3 cubeCoord = CalcCubeCoord(pos / size, int(slice)); + + if (linearSample) + col = texture(texCube, cubeCoord); + else + col = textureLod(texCube, cubeCoord, mipLevel); + } + else // type == RESTYPE_TEXCUBEARRAY + { + ivec3 size = textureSize(texCubeArray, mipLevel); + if (pos.x < 0 || pos.y < 0 || pos.x > size.x || pos.y > size.y) discard; + + if (flipY) + pos.y = size.y - pos.y; + + vec3 cubeCoord = CalcCubeCoord(pos / size.xy, int(slice) % 6); + vec4 arrayCoord = vec4(cubeCoord, int(Slice) / 6); + + if (linearSample) + col = texture(texCubeArray, arrayCoord); + else + col = textureLod(texCubeArray, arrayCoord, mipLevel); + } + + return col; +} + void main(void) { + bool uintTex = (OutputDisplayFormat & TEXDISPLAY_UINT_TEX) != 0; + bool sintTex = (OutputDisplayFormat & TEXDISPLAY_SINT_TEX) != 0; + + vec4 col; + uvec4 ucol; + ivec4 scol; + // calc screen co-ords with origin top left, modified by Position vec2 scr = vec2(gl_FragCoord.x, OutputRes.y - gl_FragCoord.y) - Position.xy; - // calc UVs in texture - vec2 uv = scr/(textureSize(tex0,0)*Scale); - - // discard if we're rendering outside input texture - if(uv.x < 0 || uv.y < 0 || uv.x > 1 || uv.y > 1) discard; - // sample the texture. - // TODO: handle uint/sint/float textures (OutputDisplayFormat). - // TODO: Use MipLevel and Slice parameters - // TODO: Sample from a point or linear sampler depending on if we're - // upscaling (point) or downscaling mip 0 (linear) - vec4 col = texture(tex0, vec2(uv.x, FlipY > 0 ? uv.y : 1.0f-uv.y)); + if (uintTex) + { + ucol = SampleTextureUInt4(scr / Scale, OutputDisplayFormat & TEXDISPLAY_TYPEMASK, FlipY == 0, int(MipLevel), Slice); + } + else if (sintTex) + { + scol = SampleTextureSInt4(scr / Scale, OutputDisplayFormat & TEXDISPLAY_TYPEMASK, FlipY == 0, int(MipLevel), Slice); + } + else + { + col = SampleTextureFloat4(scr / Scale, OutputDisplayFormat & TEXDISPLAY_TYPEMASK, FlipY == 0, (Scale < 1.0 && MipLevel == 0.0), int(MipLevel), Slice); + } if(RawOutput != 0) { + if (uintTex) + color_out = uintBitsToFloat(ucol); + else if (sintTex) + color_out = intBitsToFloat(scol); + else color_out = col; return; } @@ -75,9 +292,19 @@ void main(void) // RGBM encoding if(HDRMul > 0.0f) { - col = vec4(col.rgb * col.a * HDRMul, 1.0f); + if (uintTex) + col = vec4(ucol.rgb * ucol.a * uint(HDRMul), 1.0); + else if (sintTex) + col = vec4(scol.rgb * scol.a * int(HDRMul), 1.0); + else + col = vec4(col.rgb * col.a * HDRMul, 1.0); } + if (uintTex) + col = vec4(ucol); + else if (sintTex) + col = vec4(scol); + col = ((col - RangeMinimum)*InverseRangeSize); col = mix(vec4(0,0,0,1), col, Channels); diff --git a/renderdoc/data/renderdoc.rc b/renderdoc/data/renderdoc.rc index 6b2c7aadc..c683aa9f3 100644 --- a/renderdoc/data/renderdoc.rc +++ b/renderdoc/data/renderdoc.rc @@ -116,6 +116,7 @@ RESOURCE_checkerboard_frag TYPE_EMBED "glsl/checkerboard.frag" RESOURCE_generic_vert TYPE_EMBED "glsl/generic.vert" RESOURCE_generic_frag TYPE_EMBED "glsl/generic.frag" RESOURCE_mesh_vert TYPE_EMBED "glsl/mesh.vert" +RESOURCE_debuguniforms_h TYPE_EMBED "glsl/debuguniforms.h" RESOURCE_sourcecodepro_ttf TYPE_EMBED "sourcecodepro.ttf" diff --git a/renderdoc/data/resource.h b/renderdoc/data/resource.h index b3006168c..0033b58d1 100644 --- a/renderdoc/data/resource.h +++ b/renderdoc/data/resource.h @@ -18,6 +18,7 @@ #define RESOURCE_generic_vert 205 #define RESOURCE_generic_frag 206 #define RESOURCE_mesh_vert 207 +#define RESOURCE_debuguniforms_h 208 #define RESOURCE_sourcecodepro_ttf 301 diff --git a/renderdoc/driver/gl/gl_debug.cpp b/renderdoc/driver/gl/gl_debug.cpp index 9dc1c5c2a..81a8d6cdc 100644 --- a/renderdoc/driver/gl/gl_debug.cpp +++ b/renderdoc/driver/gl/gl_debug.cpp @@ -79,6 +79,8 @@ GLuint GLReplay::CreateShaderProgram(const char *vsSrc, const char *psSrc) return ret; } +#include "data/glsl/debuguniforms.h" + void GLReplay::InitDebugData() { if(m_pDriver == NULL) return; @@ -96,7 +98,8 @@ void GLReplay::InitDebugData() DebugData.blitProg = CreateShaderProgram(DebugData.blitvsSource.c_str(), DebugData.blitfsSource.c_str()); - string texfs = GetEmbeddedResource(texdisplay_frag); + string texfs = GetEmbeddedResource(debuguniforms_h); + texfs += GetEmbeddedResource(texdisplay_frag); DebugData.texDisplayProg = CreateShaderProgram(DebugData.blitvsSource.c_str(), texfs.c_str()); @@ -150,7 +153,7 @@ void GLReplay::InitDebugData() for(size_t i=0; i < ARRAY_COUNT(DebugData.UBOs); i++) { gl.glBindBuffer(eGL_UNIFORM_BUFFER, DebugData.UBOs[i]); - gl.glBufferData(eGL_UNIFORM_BUFFER, Debug_UBOSize, NULL, eGL_DYNAMIC_DRAW); + gl.glBufferData(eGL_UNIFORM_BUFFER, sizeof(texdisplay), NULL, eGL_DYNAMIC_DRAW); } DebugData.overlayTexWidth = DebugData.overlayTexHeight = 0; @@ -220,6 +223,8 @@ void GLReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_t sl bool GLReplay::RenderTexture(TextureDisplay cfg) { + FetchTexture tex = GetTexture(cfg.texid); + MakeCurrentReplayContext(m_DebugCtx); WrappedOpenGL &gl = *m_pDriver; @@ -228,42 +233,102 @@ bool GLReplay::RenderTexture(TextureDisplay cfg) auto &texDetails = m_pDriver->m_Textures[cfg.texid]; - gl.glActiveTexture(eGL_TEXTURE0); - gl.glBindTexture(eGL_TEXTURE_2D, texDetails.resource.name); + int resType; + switch (texDetails.curType) + { + case eGL_TEXTURE_1D: + resType = RESTYPE_TEX1D; + break; + default: + RDCWARN("Unexpected texture type"); + case eGL_TEXTURE_2D: + resType = RESTYPE_TEX2D; + break; + case eGL_TEXTURE_3D: + resType = RESTYPE_TEX3D; + break; + case eGL_TEXTURE_CUBE_MAP: + resType = RESTYPE_TEXCUBE; + break; + case eGL_TEXTURE_1D_ARRAY: + resType = RESTYPE_TEX1DARRAY; + break; + case eGL_TEXTURE_2D_ARRAY: + resType = RESTYPE_TEX2DARRAY; + break; + case eGL_TEXTURE_CUBE_MAP_ARRAY: + resType = RESTYPE_TEXCUBEARRAY; + break; + } - if(cfg.mip == 0 && cfg.scale < 1.0f) - gl.glBindSampler(0, DebugData.linearSampler); + RDCGLenum dsTexMode = eGL_NONE; + if (tex.creationFlags & eTextureCreate_DSV) + { + if (cfg.Green) + { + dsTexMode = eGL_STENCIL_INDEX; + + // Stencil texture sampling is not normalized in OpenGL + resType |= TEXDISPLAY_UINT_TEX; + float rangeScale; + switch (tex.format.rawType) + { + case eGL_STENCIL_INDEX1: + rangeScale = 1.0f; + break; + case eGL_STENCIL_INDEX4: + rangeScale = 16.0f; + break; + default: + RDCWARN("Unexpected raw format for stencil visualization"); + case eGL_DEPTH24_STENCIL8: + case eGL_DEPTH32F_STENCIL8: + case eGL_STENCIL_INDEX8: + rangeScale = 256.0f; + break; + case eGL_STENCIL_INDEX16: + rangeScale = 65536.0f; + break; + } + cfg.rangemin *= rangeScale; + cfg.rangemax *= rangeScale; + } + else + dsTexMode = eGL_DEPTH_COMPONENT; + } else - gl.glBindSampler(0, DebugData.pointSampler); + { + switch (tex.format.compType) + { + case eCompType_UInt: + resType |= TEXDISPLAY_UINT_TEX; + break; + case eCompType_SNorm: + resType |= TEXDISPLAY_SINT_TEX; + break; + } + } + gl.glActiveTexture((RDCGLenum)(eGL_TEXTURE0 + resType)); + gl.glBindTexture(texDetails.curType, texDetails.resource.name); + + GLint origDSTexMode = eGL_DEPTH_COMPONENT; + if (dsTexMode != eGL_NONE) + { + gl.glGetTexParameteriv(texDetails.curType, eGL_DEPTH_STENCIL_TEXTURE_MODE, &origDSTexMode); + gl.glTexParameteri(texDetails.curType, eGL_DEPTH_STENCIL_TEXTURE_MODE, dsTexMode); + } + + if(cfg.mip == 0 && cfg.scale < 1.0f && dsTexMode == eGL_NONE) + gl.glBindSampler(resType, DebugData.linearSampler); + else + gl.glBindSampler(resType, DebugData.pointSampler); + GLint tex_x = texDetails.width, tex_y = texDetails.height, tex_z = texDetails.depth; gl.glBindBufferBase(eGL_UNIFORM_BUFFER, 0, DebugData.UBOs[0]); - struct uboData - { - Vec2f Position; - float Scale; - float HDRMul; - - Vec4f Channels; - - float RangeMinimum; - float InverseRangeSize; - float MipLevel; - int32_t FlipY; - - Vec3f TextureResolutionPS; - int32_t OutputDisplayFormat; - - Vec2f OutputRes; - int32_t RawOutput; - float Slice; - }; - - uboData *ubo = (uboData *)gl.glMapBufferRange(eGL_UNIFORM_BUFFER, 0, sizeof(uboData), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); - - RDCCOMPILE_ASSERT(sizeof(uboData) <= Debug_UBOSize, "UBO data is too big"); + texdisplay *ubo = (texdisplay *)gl.glMapBufferRange(eGL_UNIFORM_BUFFER, 0, sizeof(texdisplay), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); float x = cfg.offx; float y = cfg.offy; @@ -297,17 +362,29 @@ bool GLReplay::RenderTexture(TextureDisplay cfg) if(cfg.rangemax <= cfg.rangemin) cfg.rangemax += 0.00001f; - ubo->Channels.x = cfg.Red ? 1.0f : 0.0f; - ubo->Channels.y = cfg.Green ? 1.0f : 0.0f; - ubo->Channels.z = cfg.Blue ? 1.0f : 0.0f; - ubo->Channels.w = cfg.Alpha ? 1.0f : 0.0f; + if (dsTexMode == eGL_NONE) + { + ubo->Channels.x = cfg.Red ? 1.0f : 0.0f; + ubo->Channels.y = cfg.Green ? 1.0f : 0.0f; + ubo->Channels.z = cfg.Blue ? 1.0f : 0.0f; + ubo->Channels.w = cfg.Alpha ? 1.0f : 0.0f; + } + else + { + // Both depth and stencil texture mode use the red channel + ubo->Channels.x = 1.0f; + ubo->Channels.y = 0.0f; + ubo->Channels.z = 0.0f; + ubo->Channels.w = 0.0f; + } ubo->RangeMinimum = cfg.rangemin; ubo->InverseRangeSize = 1.0f/(cfg.rangemax-cfg.rangemin); ubo->MipLevel = (float)cfg.mip; + ubo->Slice = (float)cfg.sliceFace; - ubo->OutputDisplayFormat = 0x2; // 2d. Unused for now + ubo->OutputDisplayFormat = resType; ubo->RawOutput = cfg.rawoutput ? 1 : 0; @@ -335,6 +412,9 @@ bool GLReplay::RenderTexture(TextureDisplay cfg) gl.glBindSampler(0, 0); + if (dsTexMode != eGL_NONE) + gl.glTexParameteri(texDetails.curType, eGL_DEPTH_STENCIL_TEXTURE_MODE, origDSTexMode); + return true; } diff --git a/renderdoc/driver/gl/gl_replay.h b/renderdoc/driver/gl/gl_replay.h index ad246daad..8e9fee97b 100644 --- a/renderdoc/driver/gl/gl_replay.h +++ b/renderdoc/driver/gl/gl_replay.h @@ -205,8 +205,6 @@ class GLReplay : public IReplayDriver GLuint emptyVAO; } DebugData; - - static const size_t Debug_UBOSize = 64 * sizeof(Vec4f); void InitDebugData(); diff --git a/renderdoc/renderdoc.vcxproj b/renderdoc/renderdoc.vcxproj index 16d999d7c..6f5eb9063 100644 --- a/renderdoc/renderdoc.vcxproj +++ b/renderdoc/renderdoc.vcxproj @@ -248,6 +248,7 @@ + diff --git a/renderdoc/renderdoc.vcxproj.filters b/renderdoc/renderdoc.vcxproj.filters index d05b1aed0..de2499724 100644 --- a/renderdoc/renderdoc.vcxproj.filters +++ b/renderdoc/renderdoc.vcxproj.filters @@ -240,6 +240,9 @@ Resources\hlsl + + Resources\glsl + Drivers\OpenGL