mirror of
https://github.com/RPCS3/glslang.git
synced 2024-11-23 11:19:40 +00:00
942 lines
33 KiB
GLSL
942 lines
33 KiB
GLSL
#version 450 core
|
|
|
|
#extension GL_ARB_sparse_texture2: enable
|
|
#extension GL_ARB_sparse_texture_clamp: enable
|
|
#extension GL_AMD_texture_gather_bias_lod: enable
|
|
|
|
layout(set = 0, binding = 0) uniform sampler1D s1D;
|
|
layout(set = 0, binding = 1) uniform sampler2D s2D;
|
|
layout(set = 0, binding = 2) uniform sampler3D s3D;
|
|
layout(set = 0, binding = 3) uniform sampler2DRect s2DRect;
|
|
layout(set = 0, binding = 4) uniform samplerCube sCube;
|
|
layout(set = 0, binding = 5) uniform samplerBuffer sBuffer;
|
|
layout(set = 0, binding = 6) uniform sampler2DMS s2DMS;
|
|
layout(set = 0, binding = 7) uniform sampler1DArray s1DArray;
|
|
layout(set = 0, binding = 8) uniform sampler2DArray s2DArray;
|
|
layout(set = 0, binding = 9) uniform samplerCubeArray sCubeArray;
|
|
layout(set = 0, binding = 10) uniform sampler2DMSArray s2DMSArray;
|
|
|
|
layout(set = 0, binding = 11) uniform sampler1DShadow s1DShadow;
|
|
layout(set = 0, binding = 12) uniform sampler2DShadow s2DShadow;
|
|
layout(set = 0, binding = 13) uniform sampler2DRectShadow s2DRectShadow;
|
|
layout(set = 0, binding = 14) uniform samplerCubeShadow sCubeShadow;
|
|
layout(set = 0, binding = 15) uniform sampler1DArrayShadow s1DArrayShadow;
|
|
layout(set = 0, binding = 16) uniform sampler2DArrayShadow s2DArrayShadow;
|
|
layout(set = 0, binding = 17) uniform samplerCubeArrayShadow sCubeArrayShadow;
|
|
|
|
layout(set = 1, binding = 0) layout(rgba16f) uniform image1D i1D;
|
|
layout(set = 1, binding = 1) layout(rgba16f) uniform image2D i2D;
|
|
layout(set = 1, binding = 2) layout(rgba16f) uniform image3D i3D;
|
|
layout(set = 1, binding = 3) layout(rgba16f) uniform image2DRect i2DRect;
|
|
layout(set = 1, binding = 4) layout(rgba16f) uniform imageCube iCube;
|
|
layout(set = 1, binding = 5) layout(rgba16f) uniform image1DArray i1DArray;
|
|
layout(set = 1, binding = 6) layout(rgba16f) uniform image2DArray i2DArray;
|
|
layout(set = 1, binding = 7) layout(rgba16f) uniform imageCubeArray iCubeArray;
|
|
layout(set = 1, binding = 8) layout(rgba16f) uniform imageBuffer iBuffer;
|
|
layout(set = 1, binding = 9) layout(rgba16f) uniform image2DMS i2DMS;
|
|
layout(set = 1, binding = 10) layout(rgba16f) uniform image2DMSArray i2DMSArray;
|
|
|
|
layout(set = 2, binding = 0) uniform texture1D t1D;
|
|
layout(set = 2, binding = 1) uniform texture2D t2D;
|
|
layout(set = 2, binding = 2) uniform texture3D t3D;
|
|
layout(set = 2, binding = 3) uniform texture2DRect t2DRect;
|
|
layout(set = 2, binding = 4) uniform textureCube tCube;
|
|
layout(set = 2, binding = 5) uniform texture1DArray t1DArray;
|
|
layout(set = 2, binding = 6) uniform texture2DArray t2DArray;
|
|
layout(set = 2, binding = 7) uniform textureCubeArray tCubeArray;
|
|
layout(set = 2, binding = 8) uniform textureBuffer tBuffer;
|
|
layout(set = 2, binding = 9) uniform texture2DMS t2DMS;
|
|
layout(set = 2, binding = 10) uniform texture2DMSArray t2DMSArray;
|
|
|
|
layout(set = 2, binding = 11) uniform sampler s;
|
|
layout(set = 2, binding = 12) uniform samplerShadow sShadow;
|
|
|
|
layout(set = 3, binding = 0, input_attachment_index = 0) uniform subpassInput subpass;
|
|
layout(set = 3, binding = 1, input_attachment_index = 0) uniform subpassInputMS subpassMS;
|
|
|
|
layout(location = 0) in float c1;
|
|
layout(location = 1) in vec2 c2;
|
|
layout(location = 2) in vec3 c3;
|
|
layout(location = 3) in vec4 c4;
|
|
|
|
layout(location = 4) in float compare;
|
|
layout(location = 5) in float lod;
|
|
layout(location = 6) in float bias;
|
|
layout(location = 7) in float lodClamp;
|
|
|
|
layout(location = 8) in float dPdxy1;
|
|
layout(location = 9) in vec2 dPdxy2;
|
|
layout(location = 10) in vec3 dPdxy3;
|
|
|
|
const int offset1 = 1;
|
|
const ivec2 offset2 = ivec2(1);
|
|
const ivec3 offset3 = ivec3(1);
|
|
const ivec2 offsets[4] = { offset2, offset2, offset2, offset2 };
|
|
|
|
layout(location = 0) out vec4 fragColor;
|
|
|
|
vec4 testTexture()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += texture(s1D, c1);
|
|
texel += texture(s2D, c2);
|
|
texel += texture(s3D, c3);
|
|
texel += texture(sCube, c3);
|
|
texel.x += texture(s1DShadow, c3);
|
|
texel.x += texture(s2DShadow, c3);
|
|
texel.x += texture(sCubeShadow, c4);
|
|
texel += texture(s1DArray, c2);
|
|
texel += texture(s2DArray, c3);
|
|
texel += texture(sCubeArray, c4);
|
|
texel.x += texture(s1DArrayShadow, c3);
|
|
texel.x += texture(s2DArrayShadow, c4);
|
|
texel += texture(s2DRect, c2);
|
|
texel.x += texture(s2DRectShadow, c3);
|
|
texel.x += texture(sCubeArrayShadow, c4, compare);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureProj()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureProj(s1D, c2);
|
|
texel += textureProj(s1D, c4);
|
|
texel += textureProj(s2D, c3);
|
|
texel += textureProj(s2D, c4);
|
|
texel += textureProj(s3D, c4);
|
|
texel.x += textureProj(s1DShadow, c4);
|
|
texel.x += textureProj(s2DShadow, c4);
|
|
texel += textureProj(s2DRect, c3);
|
|
texel += textureProj(s2DRect, c4);
|
|
texel.x += textureProj(s2DRectShadow, c4);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureLod()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureLod(s1D, c1, lod);
|
|
texel += textureLod(s2D, c2, lod);
|
|
texel += textureLod(s3D, c3, lod);
|
|
texel += textureLod(sCube, c3, lod);
|
|
texel.x += textureLod(s1DShadow, c3, lod);
|
|
texel.x += textureLod(s2DShadow, c3, lod);
|
|
texel += textureLod(s1DArray, c2, lod);
|
|
texel += textureLod(s2DArray, c3, lod);
|
|
texel.x += textureLod(s1DArrayShadow, c3, lod);
|
|
texel += textureLod(sCubeArray, c4, lod);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureOffset(s1D, c1, offset1);
|
|
texel += textureOffset(s2D, c2, offset2);
|
|
texel += textureOffset(s3D, c3, offset3);
|
|
texel += textureOffset(s2DRect, c2, offset2);
|
|
texel.x += textureOffset(s2DRectShadow, c3, offset2);
|
|
texel.x += textureOffset(s1DShadow, c3, offset1);
|
|
texel.x += textureOffset(s2DShadow, c3, offset2);
|
|
texel += textureOffset(s1DArray, c2, offset1);
|
|
texel += textureOffset(s2DArray, c3, offset2);
|
|
texel.x += textureOffset(s1DArrayShadow, c3, offset1);
|
|
texel.x += textureOffset(s2DArrayShadow, c4, offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureProjOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureProjOffset(s1D, c2, offset1);
|
|
texel += textureProjOffset(s1D, c4, offset1);
|
|
texel += textureProjOffset(s2D, c3, offset2);
|
|
texel += textureProjOffset(s2D, c4, offset2);
|
|
texel += textureProjOffset(s3D, c4, offset3);
|
|
texel += textureProjOffset(s2DRect, c3, offset2);
|
|
texel += textureProjOffset(s2DRect, c4, offset2);
|
|
texel.x += textureProjOffset(s2DRectShadow, c4, offset2);
|
|
texel.x += textureProjOffset(s1DShadow, c4, offset1);
|
|
texel.x += textureProjOffset(s2DShadow, c4, offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureLodOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureLodOffset(s1D, c1, lod, offset1);
|
|
texel += textureLodOffset(s2D, c2, lod, offset2);
|
|
texel += textureLodOffset(s3D, c3, lod, offset3);
|
|
texel.x += textureLodOffset(s1DShadow, c3, lod, offset1);
|
|
texel.x += textureLodOffset(s2DShadow, c3, lod, offset2);
|
|
texel += textureLodOffset(s1DArray, c2, lod, offset1);
|
|
texel += textureLodOffset(s2DArray, c3, lod, offset2);
|
|
texel.x += textureLodOffset(s1DArrayShadow, c3, lod, offset1);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureProjLodOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureProjLodOffset(s1D, c2, lod, offset1);
|
|
texel += textureProjLodOffset(s1D, c4, lod, offset1);
|
|
texel += textureProjLodOffset(s2D, c3, lod, offset2);
|
|
texel += textureProjLodOffset(s2D, c4, lod, offset2);
|
|
texel += textureProjLodOffset(s3D, c4, lod, offset3);
|
|
texel.x += textureProjLodOffset(s1DShadow, c4, lod, offset1);
|
|
texel.x += textureProjLodOffset(s2DShadow, c4, lod, offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTexelFetch()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += texelFetch(s1D, int(c1), int(lod));
|
|
texel += texelFetch(s2D, ivec2(c2), int(lod));
|
|
texel += texelFetch(s3D, ivec3(c3), int(lod));
|
|
texel += texelFetch(s2DRect, ivec2(c2));
|
|
texel += texelFetch(s1DArray, ivec2(c2), int(lod));
|
|
texel += texelFetch(s2DArray, ivec3(c3), int(lod));
|
|
texel += texelFetch(sBuffer, int(c1));
|
|
texel += texelFetch(s2DMS, ivec2(c2), 1);
|
|
texel += texelFetch(s2DMSArray, ivec3(c3), 2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTexelFetchOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += texelFetchOffset(s1D, int(c1), int(lod), offset1);
|
|
texel += texelFetchOffset(s2D, ivec2(c2), int(lod), offset2);
|
|
texel += texelFetchOffset(s3D, ivec3(c3), int(lod), offset3);
|
|
texel += texelFetchOffset(s2DRect, ivec2(c2), offset2);
|
|
texel += texelFetchOffset(s1DArray, ivec2(c2), int(lod), offset1);
|
|
texel += texelFetchOffset(s2DArray, ivec3(c3), int(lod), offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGrad()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGrad(s1D, c1, dPdxy1, dPdxy1);
|
|
texel += textureGrad(s2D, c2, dPdxy2, dPdxy2);
|
|
texel += textureGrad(s3D, c3, dPdxy3, dPdxy3);
|
|
texel += textureGrad(sCube, c3, dPdxy3, dPdxy3);
|
|
texel += textureGrad(s2DRect, c2, dPdxy2, dPdxy2);
|
|
texel.x += textureGrad(s2DRectShadow, c3, dPdxy2, dPdxy2);
|
|
texel.x += textureGrad(s1DShadow, c3, dPdxy1, dPdxy1);
|
|
texel.x += textureGrad(s2DShadow, c3, dPdxy2, dPdxy2);
|
|
texel.x += textureGrad(sCubeShadow, c4, dPdxy3, dPdxy3);
|
|
texel += textureGrad(s1DArray, c2, dPdxy1, dPdxy1);
|
|
texel += textureGrad(s2DArray, c3, dPdxy2, dPdxy2);
|
|
texel.x += textureGrad(s1DArrayShadow, c3, dPdxy1, dPdxy1);
|
|
texel.x += textureGrad(s2DArrayShadow, c4, dPdxy2, dPdxy2);
|
|
texel += textureGrad(sCubeArray, c4, dPdxy3, dPdxy3);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGradOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGradOffset(s1D, c1, dPdxy1, dPdxy1, offset1);
|
|
texel += textureGradOffset(s2D, c2, dPdxy2, dPdxy2, offset2);
|
|
texel += textureGradOffset(s3D, c3, dPdxy3, dPdxy3, offset3);
|
|
texel += textureGradOffset(s2DRect, c2, dPdxy2, dPdxy2, offset2);
|
|
texel.x += textureGradOffset(s2DRectShadow, c3, dPdxy2, dPdxy2, offset2);
|
|
texel.x += textureGradOffset(s1DShadow, c3, dPdxy1, dPdxy1, offset1);
|
|
texel.x += textureGradOffset(s2DShadow, c3, dPdxy2, dPdxy2, offset2);
|
|
texel += textureGradOffset(s1DArray, c2, dPdxy1, dPdxy1, offset1);
|
|
texel += textureGradOffset(s2DArray, c3, dPdxy2, dPdxy2, offset2);
|
|
texel.x += textureGradOffset(s1DArrayShadow, c3, dPdxy1, dPdxy1, offset1);
|
|
texel.x += textureGradOffset(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureProjGrad()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureProjGrad(s1D, c2, dPdxy1, dPdxy1);
|
|
texel += textureProjGrad(s1D, c4, dPdxy1, dPdxy1);
|
|
texel += textureProjGrad(s2D, c3, dPdxy2, dPdxy2);
|
|
texel += textureProjGrad(s2D, c4, dPdxy2, dPdxy2);
|
|
texel += textureProjGrad(s3D, c4, dPdxy3, dPdxy3);
|
|
texel += textureProjGrad(s2DRect, c3, dPdxy2, dPdxy2);
|
|
texel += textureProjGrad(s2DRect, c4, dPdxy2, dPdxy2);
|
|
texel.x += textureProjGrad(s2DRectShadow, c4, dPdxy2, dPdxy2);
|
|
texel.x += textureProjGrad(s1DShadow, c4, dPdxy1, dPdxy1);
|
|
texel.x += textureProjGrad(s2DShadow, c4, dPdxy2, dPdxy2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureProjGradoffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureProjGradOffset(s1D, c2, dPdxy1, dPdxy1, offset1);
|
|
texel += textureProjGradOffset(s1D, c4, dPdxy1, dPdxy1, offset1);
|
|
texel += textureProjGradOffset(s2D, c3, dPdxy2, dPdxy2, offset2);
|
|
texel += textureProjGradOffset(s2D, c4, dPdxy2, dPdxy2, offset2);
|
|
texel += textureProjGradOffset(s2DRect, c3, dPdxy2, dPdxy2, offset2);
|
|
texel += textureProjGradOffset(s2DRect, c4, dPdxy2, dPdxy2, offset2);
|
|
texel.x += textureProjGradOffset(s2DRectShadow, c4, dPdxy2, dPdxy2, offset2);
|
|
texel += textureProjGradOffset(s3D, c4, dPdxy3, dPdxy3, offset3);
|
|
texel.x += textureProjGradOffset(s1DShadow, c4, dPdxy1, dPdxy1, offset1);
|
|
texel.x += textureProjGradOffset(s2DShadow, c4, dPdxy2, dPdxy2, offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGather()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGather(s2D, c2, 0);
|
|
texel += textureGather(s2DArray, c3, 0);
|
|
texel += textureGather(sCube, c3, 0);
|
|
texel += textureGather(sCubeArray, c4, 0);
|
|
texel += textureGather(s2DRect, c2, 0);
|
|
texel += textureGather(s2DShadow, c2, compare);
|
|
texel += textureGather(s2DArrayShadow, c3, compare);
|
|
texel += textureGather(sCubeShadow, c3, compare);
|
|
texel += textureGather(sCubeArrayShadow, c4, compare);
|
|
texel += textureGather(s2DRectShadow, c2, compare);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGatherOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGatherOffset(s2D, c2, offset2, 0);
|
|
texel += textureGatherOffset(s2DArray, c3, offset2, 0);
|
|
texel += textureGatherOffset(s2DRect, c2, offset2, 0);
|
|
texel += textureGatherOffset(s2DShadow, c2, compare, offset2);
|
|
texel += textureGatherOffset(s2DArrayShadow, c3, compare, offset2);
|
|
texel += textureGatherOffset(s2DRectShadow, c2, compare, offset2);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGatherOffsets()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGatherOffsets(s2D, c2, offsets, 0);
|
|
texel += textureGatherOffsets(s2DArray, c3, offsets, 0);
|
|
texel += textureGatherOffsets(s2DRect, c2, offsets, 0);
|
|
texel += textureGatherOffsets(s2DShadow, c2, compare, offsets);
|
|
texel += textureGatherOffsets(s2DArrayShadow, c3, compare, offsets);
|
|
texel += textureGatherOffsets(s2DRectShadow, c2, compare, offsets);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGatherLod()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGatherLodAMD(s2D, c2, lod, 0);
|
|
texel += textureGatherLodAMD(s2DArray, c3, lod, 0);
|
|
texel += textureGatherLodAMD(sCube, c3, lod, 0);
|
|
texel += textureGatherLodAMD(sCubeArray, c4, lod, 0);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGatherLodOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGatherLodOffsetAMD(s2D, c2, lod, offset2, 0);
|
|
texel += textureGatherLodOffsetAMD(s2DArray, c3, lod, offset2, 0);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGatherLodOffsets()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGatherLodOffsetsAMD(s2D, c2, lod, offsets, 0);
|
|
texel += textureGatherLodOffsetsAMD(s2DArray, c3, lod, offsets, 0);
|
|
|
|
return texel;
|
|
}
|
|
|
|
ivec4 testTextureSize()
|
|
{
|
|
ivec4 size = ivec4(0);
|
|
|
|
size.x += textureSize(s1D, int(lod));
|
|
size.xy += textureSize(s2D, int(lod));
|
|
size.xyz += textureSize(s3D, int(lod));
|
|
size.xy += textureSize(sCube, int(lod));
|
|
size.x += textureSize(s1DShadow, int(lod));
|
|
size.xy += textureSize(s2DShadow, int(lod));
|
|
size.xy += textureSize(sCubeShadow, int(lod));
|
|
size.xyz += textureSize(sCubeArray, int(lod));
|
|
size.xyz += textureSize(sCubeArrayShadow, int(lod));
|
|
size.xy += textureSize(s2DRect);
|
|
size.xy += textureSize(s2DRectShadow);
|
|
size.xy += textureSize(s1DArray, int(lod));
|
|
size.xyz += textureSize(s2DArray, int(lod));
|
|
size.xy += textureSize(s1DArrayShadow, int(lod));
|
|
size.xyz += textureSize(s2DArrayShadow, int(lod));
|
|
size.x += textureSize(sBuffer);
|
|
size.xy += textureSize(s2DMS);
|
|
size.xyz += textureSize(s2DMSArray);
|
|
|
|
return size;
|
|
}
|
|
|
|
vec2 testTextureQueryLod()
|
|
{
|
|
vec2 lod = vec2(0.0);
|
|
|
|
lod += textureQueryLod(s1D, c1);
|
|
lod += textureQueryLod(s2D, c2);
|
|
lod += textureQueryLod(s3D, c3);
|
|
lod += textureQueryLod(sCube, c3);
|
|
lod += textureQueryLod(s1DArray, c1);
|
|
lod += textureQueryLod(s2DArray, c2);
|
|
lod += textureQueryLod(sCubeArray, c3);
|
|
lod += textureQueryLod(s1DShadow, c1);
|
|
lod += textureQueryLod(s2DShadow, c2);
|
|
lod += textureQueryLod(sCubeArrayShadow, c3);
|
|
lod += textureQueryLod(s1DArrayShadow, c1);
|
|
lod += textureQueryLod(s2DArrayShadow, c2);
|
|
lod += textureQueryLod(sCubeArrayShadow, c3);
|
|
|
|
return lod;
|
|
}
|
|
|
|
int testTextureQueryLevels()
|
|
{
|
|
int levels = 0;
|
|
|
|
levels += textureQueryLevels(s1D);
|
|
levels += textureQueryLevels(s2D);
|
|
levels += textureQueryLevels(s3D);
|
|
levels += textureQueryLevels(sCube);
|
|
levels += textureQueryLevels(s1DShadow);
|
|
levels += textureQueryLevels(s2DShadow);
|
|
levels += textureQueryLevels(sCubeShadow);
|
|
levels += textureQueryLevels(sCubeArray);
|
|
levels += textureQueryLevels(sCubeArrayShadow);
|
|
levels += textureQueryLevels(s1DArray);
|
|
levels += textureQueryLevels(s2DArray);
|
|
levels += textureQueryLevels(s1DArrayShadow);
|
|
levels += textureQueryLevels(s2DArrayShadow);
|
|
|
|
return levels;
|
|
}
|
|
|
|
int testTextureSamples()
|
|
{
|
|
int samples = 0;
|
|
|
|
samples += textureSamples(s2DMS);
|
|
samples += textureSamples(s2DMSArray);
|
|
|
|
return samples;
|
|
}
|
|
|
|
vec4 testImageLoad()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += imageLoad(i1D, int(c1));
|
|
texel += imageLoad(i2D, ivec2(c2));
|
|
texel += imageLoad(i3D, ivec3(c3));
|
|
texel += imageLoad(i2DRect, ivec2(c2));
|
|
texel += imageLoad(iCube, ivec3(c3));
|
|
texel += imageLoad(iBuffer, int(c1));
|
|
texel += imageLoad(i1DArray, ivec2(c2));
|
|
texel += imageLoad(i2DArray, ivec3(c3));
|
|
texel += imageLoad(iCubeArray, ivec3(c3));
|
|
texel += imageLoad(i2DMS, ivec2(c2), 1);
|
|
texel += imageLoad(i2DMSArray, ivec3(c3), 1);
|
|
|
|
return texel;
|
|
}
|
|
|
|
void testImageStore(vec4 data)
|
|
{
|
|
imageStore(i1D, int(c1), data);
|
|
imageStore(i2D, ivec2(c2), data);
|
|
imageStore(i3D, ivec3(c3), data);
|
|
imageStore(i2DRect, ivec2(c2), data);
|
|
imageStore(iCube, ivec3(c3), data);
|
|
imageStore(iBuffer, int(c1), data);
|
|
imageStore(i1DArray, ivec2(c2), data);
|
|
imageStore(i2DArray, ivec3(c3), data);
|
|
imageStore(iCubeArray, ivec3(c3), data);
|
|
imageStore(i2DMS, ivec2(c2), 1, data);
|
|
imageStore(i2DMSArray, ivec3(c3), 1, data);
|
|
}
|
|
|
|
vec4 testSparseTexture()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureARB(s2D, c2, texel);
|
|
sparseTextureARB(s3D, c3, texel);
|
|
sparseTextureARB(sCube, c3, texel);
|
|
sparseTextureARB(s2DShadow, c3, texel.x);
|
|
sparseTextureARB(sCubeShadow, c4, texel.x);
|
|
sparseTextureARB(s2DArray, c3, texel);
|
|
sparseTextureARB(sCubeArray, c4, texel);
|
|
sparseTextureARB(s2DArrayShadow, c4, texel.x);
|
|
sparseTextureARB(s2DRect, c2, texel);
|
|
sparseTextureARB(s2DRectShadow, c3, texel.x);
|
|
sparseTextureARB(sCubeArrayShadow, c4, compare, texel.x);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureLod()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureLodARB(s2D, c2, lod, texel);
|
|
sparseTextureLodARB(s3D, c3, lod, texel);
|
|
sparseTextureLodARB(sCube, c3, lod, texel);
|
|
sparseTextureLodARB(s2DShadow, c3, lod, texel.x);
|
|
sparseTextureLodARB(s2DArray, c3, lod, texel);
|
|
sparseTextureLodARB(sCubeArray, c4, lod, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureOffsetARB(s2D, c2, offset2, texel);
|
|
sparseTextureOffsetARB(s3D, c3, offset3, texel);
|
|
sparseTextureOffsetARB(s2DRect, c2, offset2, texel);
|
|
sparseTextureOffsetARB(s2DRectShadow, c3, offset2, texel.x);
|
|
sparseTextureOffsetARB(s2DShadow, c3, offset2, texel.x);
|
|
sparseTextureOffsetARB(s2DArray, c3, offset2, texel);
|
|
sparseTextureOffsetARB(s2DArrayShadow, c4, offset2, texel.x);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureLodOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureLodOffsetARB(s2D, c2, lod, offset2, texel);
|
|
sparseTextureLodOffsetARB(s3D, c3, lod, offset3, texel);
|
|
sparseTextureLodOffsetARB(s2DShadow, c3, lod, offset2, texel.x);
|
|
sparseTextureLodOffsetARB(s2DArray, c3, lod, offset2, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGrad()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGradARB(s2D, c2, dPdxy2, dPdxy2, texel);
|
|
sparseTextureGradARB(s3D, c3, dPdxy3, dPdxy3, texel);
|
|
sparseTextureGradARB(sCube, c3, dPdxy3, dPdxy3, texel);
|
|
sparseTextureGradARB(s2DRect, c2, dPdxy2, dPdxy2, texel);
|
|
sparseTextureGradARB(s2DRectShadow, c3, dPdxy2, dPdxy2, texel.x);
|
|
sparseTextureGradARB(s2DShadow, c3, dPdxy2, dPdxy2, texel.x);
|
|
sparseTextureGradARB(sCubeShadow, c4, dPdxy3, dPdxy3, texel.x);
|
|
sparseTextureGradARB(s2DArray, c3, dPdxy2, dPdxy2, texel);
|
|
sparseTextureGradARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, texel.x);
|
|
sparseTextureGradARB(sCubeArray, c4, dPdxy3, dPdxy3, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGradOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGradOffsetARB(s2D, c2, dPdxy2, dPdxy2, offset2, texel);
|
|
sparseTextureGradOffsetARB(s3D, c3, dPdxy3, dPdxy3, offset3, texel);
|
|
sparseTextureGradOffsetARB(s2DRect, c2, dPdxy2, dPdxy2, offset2, texel);
|
|
sparseTextureGradOffsetARB(s2DRectShadow, c3, dPdxy2, dPdxy2, offset2, texel.x);
|
|
sparseTextureGradOffsetARB(s2DShadow, c3, dPdxy2, dPdxy2, offset2, texel.x);
|
|
sparseTextureGradOffsetARB(s2DArray, c3, dPdxy2, dPdxy2, offset2, texel);
|
|
sparseTextureGradOffsetARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2, texel.x);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTexelFetch()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTexelFetchARB(s2D, ivec2(c2), int(lod), texel);
|
|
sparseTexelFetchARB(s3D, ivec3(c3), int(lod), texel);
|
|
sparseTexelFetchARB(s2DRect, ivec2(c2), texel);
|
|
sparseTexelFetchARB(s2DArray, ivec3(c3), int(lod), texel);
|
|
sparseTexelFetchARB(s2DMS, ivec2(c2), 1, texel);
|
|
sparseTexelFetchARB(s2DMSArray, ivec3(c3), 2, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTexelFetchOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTexelFetchOffsetARB(s2D, ivec2(c2), int(lod), offset2, texel);
|
|
sparseTexelFetchOffsetARB(s3D, ivec3(c3), int(lod), offset3, texel);
|
|
sparseTexelFetchOffsetARB(s2DRect, ivec2(c2), offset2, texel);
|
|
sparseTexelFetchOffsetARB(s2DArray, ivec3(c3), int(lod), offset2, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGather()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGatherARB(s2D, c2, texel, 0);
|
|
sparseTextureGatherARB(s2DArray, c3, texel, 0);
|
|
sparseTextureGatherARB(sCube, c3, texel, 0);
|
|
sparseTextureGatherARB(sCubeArray, c4, texel, 0);
|
|
sparseTextureGatherARB(s2DRect, c2, texel, 0);
|
|
sparseTextureGatherARB(s2DShadow, c2, compare, texel);
|
|
sparseTextureGatherARB(s2DArrayShadow, c3, compare, texel);
|
|
sparseTextureGatherARB(sCubeShadow, c3, compare, texel);
|
|
sparseTextureGatherARB(sCubeArrayShadow, c4, compare, texel);
|
|
sparseTextureGatherARB(s2DRectShadow, c2, compare, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGatherOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGatherOffsetARB(s2D, c2, offset2, texel, 0);
|
|
sparseTextureGatherOffsetARB(s2DArray, c3, offset2, texel, 0);
|
|
sparseTextureGatherOffsetARB(s2DRect, c2, offset2, texel, 0);
|
|
sparseTextureGatherOffsetARB(s2DShadow, c2, compare, offset2, texel);
|
|
sparseTextureGatherOffsetARB(s2DArrayShadow, c3, compare, offset2, texel);
|
|
sparseTextureGatherOffsetARB(s2DRectShadow, c2, compare, offset2, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGatherOffsets()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
const ivec2 constOffsets[4] = ivec2[4](ivec2(1,2), ivec2(3,4), ivec2(15,16), ivec2(-2,0));
|
|
|
|
sparseTextureGatherOffsetsARB(s2D, c2, constOffsets, texel, 0);
|
|
sparseTextureGatherOffsetsARB(s2DArray, c3, constOffsets, texel, 0);
|
|
sparseTextureGatherOffsetsARB(s2DRect, c2, constOffsets, texel, 0);
|
|
sparseTextureGatherOffsetsARB(s2DShadow, c2, compare, constOffsets, texel);
|
|
sparseTextureGatherOffsetsARB(s2DArrayShadow, c3, compare, constOffsets, texel);
|
|
sparseTextureGatherOffsetsARB(s2DRectShadow, c2, compare, constOffsets, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGatherLod()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGatherLodAMD(s2D, c2, lod, texel, 0);
|
|
sparseTextureGatherLodAMD(s2DArray, c3, lod, texel, 0);
|
|
sparseTextureGatherLodAMD(sCube, c3, lod, texel, 0);
|
|
sparseTextureGatherLodAMD(sCubeArray, c4, lod, texel, 0);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGatherLodOffset()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGatherLodOffsetAMD(s2D, c2, lod, offset2, texel, 0);
|
|
sparseTextureGatherLodOffsetAMD(s2DArray, c3, lod, offset2, texel, 0);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGatherLodOffsets()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGatherLodOffsetsAMD(s2D, c2, lod, offsets, texel, 0);
|
|
sparseTextureGatherLodOffsetsAMD(s2DArray, c3, lod, offsets, texel, 0);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseImageLoad()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseImageLoadARB(i2D, ivec2(c2), texel);
|
|
sparseImageLoadARB(i3D, ivec3(c3), texel);
|
|
sparseImageLoadARB(i2DRect, ivec2(c2), texel);
|
|
sparseImageLoadARB(iCube, ivec3(c3), texel);
|
|
sparseImageLoadARB(i2DArray, ivec3(c3), texel);
|
|
sparseImageLoadARB(iCubeArray, ivec3(c3), texel);
|
|
sparseImageLoadARB(i2DMS, ivec2(c2), 1, texel);
|
|
sparseImageLoadARB(i2DMSArray, ivec3(c3), 2, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureClampARB(s2D, c2, lodClamp, texel);
|
|
sparseTextureClampARB(s3D, c3, lodClamp, texel);
|
|
sparseTextureClampARB(sCube, c3, lodClamp, texel);
|
|
sparseTextureClampARB(s2DShadow, c3, lodClamp, texel.x);
|
|
sparseTextureClampARB(sCubeShadow, c4, lodClamp, texel.x);
|
|
sparseTextureClampARB(s2DArray, c3, lodClamp, texel);
|
|
sparseTextureClampARB(sCubeArray, c4, lodClamp, texel);
|
|
sparseTextureClampARB(s2DArrayShadow, c4, lodClamp, texel.x);
|
|
sparseTextureClampARB(sCubeArrayShadow, c4, compare, lodClamp, texel.x);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureClampARB(s1D, c1, lodClamp);
|
|
texel += textureClampARB(s2D, c2, lodClamp);
|
|
texel += textureClampARB(s3D, c3, lodClamp);
|
|
texel += textureClampARB(sCube, c3, lodClamp);
|
|
texel.x += textureClampARB(s1DShadow, c3, lodClamp);
|
|
texel.x += textureClampARB(s2DShadow, c3, lodClamp);
|
|
texel.x += textureClampARB(sCubeShadow, c4, lodClamp);
|
|
texel += textureClampARB(s1DArray, c2, lodClamp);
|
|
texel += textureClampARB(s2DArray, c3, lodClamp);
|
|
texel += textureClampARB(sCubeArray, c4, lodClamp);
|
|
texel.x += textureClampARB(s1DArrayShadow, c3, lodClamp);
|
|
texel.x += textureClampARB(s2DArrayShadow, c4, lodClamp);
|
|
texel.x += textureClampARB(sCubeArrayShadow, c4, compare, lodClamp);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureOffsetClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureOffsetClampARB(s2D, c2, offset2, lodClamp, texel);
|
|
sparseTextureOffsetClampARB(s3D, c3, offset3, lodClamp, texel);
|
|
sparseTextureOffsetClampARB(s2DShadow, c3, offset2, lodClamp, texel.x);
|
|
sparseTextureOffsetClampARB(s2DArray, c3, offset2, lodClamp, texel);
|
|
sparseTextureOffsetClampARB(s2DArrayShadow, c4, offset2, lodClamp, texel.x);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureOffsetClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureOffsetClampARB(s1D, c1, offset1, lodClamp);
|
|
texel += textureOffsetClampARB(s2D, c2, offset2, lodClamp);
|
|
texel += textureOffsetClampARB(s3D, c3, offset3, lodClamp);
|
|
texel.x += textureOffsetClampARB(s1DShadow, c3, offset1, lodClamp);
|
|
texel.x += textureOffsetClampARB(s2DShadow, c3, offset2, lodClamp);
|
|
texel += textureOffsetClampARB(s1DArray, c2, offset1, lodClamp);
|
|
texel += textureOffsetClampARB(s2DArray, c3, offset2, lodClamp);
|
|
texel.x += textureOffsetClampARB(s1DArrayShadow, c3, offset1, lodClamp);
|
|
texel.x += textureOffsetClampARB(s2DArrayShadow, c4, offset2, lodClamp);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGradClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGradClampARB(s2D, c2, dPdxy2, dPdxy2, lodClamp, texel);
|
|
sparseTextureGradClampARB(s3D, c3, dPdxy3, dPdxy3, lodClamp, texel);
|
|
sparseTextureGradClampARB(sCube, c3, dPdxy3, dPdxy3, lodClamp, texel);
|
|
sparseTextureGradClampARB(s2DShadow, c3, dPdxy2, dPdxy2, lodClamp, texel.x);
|
|
sparseTextureGradClampARB(sCubeShadow, c4, dPdxy3, dPdxy3, lodClamp, texel.x);
|
|
sparseTextureGradClampARB(s2DArray, c3, dPdxy2, dPdxy2, lodClamp, texel);
|
|
sparseTextureGradClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, lodClamp, texel.x);
|
|
sparseTextureGradClampARB(sCubeArray, c4, dPdxy3, dPdxy3, lodClamp, texel);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGradClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGradClampARB(s1D, c1, dPdxy1, dPdxy1, lodClamp);
|
|
texel += textureGradClampARB(s2D, c2, dPdxy2, dPdxy2, lodClamp);
|
|
texel += textureGradClampARB(s3D, c3, dPdxy3, dPdxy3, lodClamp);
|
|
texel += textureGradClampARB(sCube, c3, dPdxy3, dPdxy3, lodClamp);
|
|
texel.x += textureGradClampARB(s1DShadow, c3, dPdxy1, dPdxy1, lodClamp);
|
|
texel.x += textureGradClampARB(s2DShadow, c3, dPdxy2, dPdxy2, lodClamp);
|
|
texel.x += textureGradClampARB(sCubeShadow, c4, dPdxy3, dPdxy3, lodClamp);
|
|
texel += textureGradClampARB(s1DArray, c2, dPdxy1, dPdxy1, lodClamp);
|
|
texel += textureGradClampARB(s2DArray, c3, dPdxy2, dPdxy2, lodClamp);
|
|
texel.x += textureGradClampARB(s1DArrayShadow, c3, dPdxy1, dPdxy1, lodClamp);
|
|
texel.x += textureGradClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, lodClamp);
|
|
texel += textureGradClampARB(sCubeArray, c4, dPdxy3, dPdxy3, lodClamp);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSparseTextureGradOffsetClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
sparseTextureGradOffsetClampARB(s2D, c2, dPdxy2, dPdxy2, offset2, lodClamp, texel);
|
|
sparseTextureGradOffsetClampARB(s3D, c3, dPdxy3, dPdxy3, offset3, lodClamp, texel);
|
|
sparseTextureGradOffsetClampARB(s2DShadow, c3, dPdxy2, dPdxy2, offset2, lodClamp, texel.x);
|
|
sparseTextureGradOffsetClampARB(s2DArray, c3, dPdxy2, dPdxy2, offset2, lodClamp, texel);
|
|
sparseTextureGradOffsetClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2, lodClamp, texel.x);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testTextureGradOffsetClamp()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += textureGradOffsetClampARB(s1D, c1, dPdxy1, dPdxy1, offset1, lodClamp);
|
|
texel += textureGradOffsetClampARB(s2D, c2, dPdxy2, dPdxy2, offset2, lodClamp);
|
|
texel += textureGradOffsetClampARB(s3D, c3, dPdxy3, dPdxy3, offset3, lodClamp);
|
|
texel.x += textureGradOffsetClampARB(s1DShadow, c3, dPdxy1, dPdxy1, offset1, lodClamp);
|
|
texel.x += textureGradOffsetClampARB(s2DShadow, c3, dPdxy2, dPdxy2, offset2, lodClamp);
|
|
texel += textureGradOffsetClampARB(s1DArray, c2, dPdxy1, dPdxy1, offset1, lodClamp);
|
|
texel += textureGradOffsetClampARB(s2DArray, c3, dPdxy2, dPdxy2, offset2, lodClamp);
|
|
texel.x += textureGradOffsetClampARB(s1DArrayShadow, c3, dPdxy1, dPdxy1, offset1, lodClamp);
|
|
texel.x += textureGradOffsetClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2, lodClamp);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testCombinedTextureSampler()
|
|
{
|
|
vec4 texel = vec4(0.0);
|
|
|
|
texel += texture(sampler1D(t1D, s), c1);
|
|
texel += texture(sampler2D(t2D, s), c2);
|
|
texel += texture(sampler3D(t3D, s), c3);
|
|
texel += texture(samplerCube(tCube, s), c3);
|
|
texel.x += texture(sampler1DShadow(t1D, sShadow), c3);
|
|
texel.x += texture(sampler2DShadow(t2D, sShadow), c3);
|
|
texel.x += texture(samplerCubeShadow(tCube, sShadow), c4);
|
|
texel += texture(sampler1DArray(t1DArray, s), c2);
|
|
texel += texture(sampler2DArray(t2DArray, s), c3);
|
|
texel += texture(samplerCubeArray(tCubeArray, s), c4);
|
|
texel.x += texture(sampler1DArrayShadow(t1DArray, sShadow), c3);
|
|
texel.x += texture(sampler2DArrayShadow(t2DArray, sShadow), c4);
|
|
texel += texture(sampler2DRect(t2DRect, s), c2);
|
|
texel.x += texture(sampler2DRectShadow(t2DRect, sShadow), c3);
|
|
texel.x += texture(samplerCubeArrayShadow(tCubeArray, sShadow), c4, compare);
|
|
|
|
return texel;
|
|
}
|
|
|
|
vec4 testSubpassLoad()
|
|
{
|
|
return subpassLoad(subpass) + subpassLoad(subpassMS, 2);
|
|
}
|
|
|
|
void main()
|
|
{
|
|
vec4 result = vec4(0.0);
|
|
|
|
result += testTexture();
|
|
result += testTextureProj();
|
|
result += testTextureLod();
|
|
result += testTextureOffset();
|
|
result += testTextureLodOffset();
|
|
result += testTextureProjLodOffset();
|
|
result += testTexelFetch();
|
|
result += testTexelFetchOffset();
|
|
result += testTextureGrad();
|
|
result += testTextureGradOffset();
|
|
result += testTextureProjGrad();
|
|
result += testTextureProjGradoffset();
|
|
result += testTextureGather();
|
|
result += testTextureGatherOffset();
|
|
result += testTextureGatherOffsets();
|
|
result += testTextureGatherLod();
|
|
result += testTextureGatherLodOffset();
|
|
result += testTextureGatherLodOffsets();
|
|
|
|
result += vec4(testTextureSize());
|
|
result.xy += vec2(testTextureQueryLod());
|
|
result.x += testTextureQueryLevels();
|
|
result.x += testTextureSamples();
|
|
|
|
result += testImageLoad();
|
|
testImageStore(result);
|
|
|
|
result += testSparseTexture();
|
|
result += testSparseTextureLod();
|
|
result += testSparseTextureOffset();
|
|
result += testSparseTextureLodOffset();
|
|
result += testSparseTextureGrad();
|
|
result += testSparseTextureGradOffset();
|
|
result += testSparseTexelFetch();
|
|
result += testSparseTexelFetchOffset();
|
|
result += testSparseTextureGather();
|
|
result += testSparseTextureGatherOffset();
|
|
result += testSparseTextureGatherOffsets();
|
|
result += testSparseTextureGatherLod();
|
|
result += testSparseTextureGatherLodOffset();
|
|
result += testSparseTextureGatherLodOffsets();
|
|
|
|
result += testSparseImageLoad();
|
|
|
|
result += testSparseTextureClamp();
|
|
result += testTextureClamp();
|
|
result += testSparseTextureOffsetClamp();
|
|
result += testTextureOffsetClamp();
|
|
result += testSparseTextureGrad();
|
|
result += testTextureGrad();
|
|
result += testSparseTextureGradOffsetClamp();
|
|
result += testTextureGradOffsetClamp();
|
|
|
|
result += testCombinedTextureSampler();
|
|
result += testSubpassLoad();
|
|
|
|
fragColor = result;
|
|
}
|
|
|