From ecc711a5a640564931a38aaefd86cacd1a4f9bb3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Capucho?= Date: Sun, 6 Feb 2022 18:07:55 +0000 Subject: [PATCH] glsl-in: Texture builtins fixes This one grew out of hand quick. Initially it was just replacing the bit loops with a function driving the declarations to make the code sharing better and support different scalar kinds. Now it includes a lot of fixes: - `textureSize` now also returns the array layers as the last component on the return (only for arrayed textures) - `textureSize` now supports multisampled textures - the `texture` family of functions now consumes a `vec3` coordinate vector for all 1D shadow textures - Shadow textures can use the bias version of `texture` functions (temporarily disabled since naga doesn't support it) - 3D textures can be used in `textureProj` - `sampler2DArrayShadow` can't be used in `textureLod` or in `texture` with bias - Cube textures cannot be used with offsets Updates the tests to cover all functions --- src/front/glsl/builtins.rs | 573 +++++++++--------- tests/in/glsl/samplers.frag | 79 ++- tests/out/wgsl/samplers-frag.wgsl | 947 ++++++++++++++++-------------- 3 files changed, 866 insertions(+), 733 deletions(-) diff --git a/src/front/glsl/builtins.rs b/src/front/glsl/builtins.rs index d688ecad57..41c29ecb2c 100644 --- a/src/front/glsl/builtins.rs +++ b/src/front/glsl/builtins.rs @@ -147,337 +147,219 @@ pub fn inject_builtin(declaration: &mut FunctionDeclaration, module: &mut Module | "textureProjLod" | "textureProjLodOffset" | "textureProjOffset" => { - // bits layout - // bits 0 through 1 - dims - // bit 2 - shadow - // bit 3 - array - // bit 4 - extra variant - // bit 5 - bias - - for bits in 0..(0b1000000) { - let dim = bits & 0b11; - let shadow = bits & 0b100 == 0b100; - let arrayed = bits & 0b1000 == 0b1000; - let variant = bits & 0b10000 == 0b10000; - let bias = bits & 0b100000 == 0b100000; - - let builtin = match name { - // texture(gsampler, gvec P, [float bias]); - "texture" => MacroCall::Texture { - proj: false, - offset: false, - shadow, - level_type: TextureLevelType::None, - }, - // textureGrad(gsampler, gvec P, gvec dPdx, gvec dPdy); - "textureGrad" => MacroCall::Texture { - proj: false, - offset: false, - shadow, - level_type: TextureLevelType::Grad, - }, - // textureGradOffset(gsampler, gvec P, gvec dPdx, gvec dPdy, ivec offset); - "textureGradOffset" => MacroCall::Texture { - proj: false, - offset: true, - shadow, - level_type: TextureLevelType::Grad, - }, - // textureLod(gsampler, gvec P, float lod); - "textureLod" => MacroCall::Texture { - proj: false, - offset: false, - shadow, - level_type: TextureLevelType::Lod, - }, - // textureLodOffset(gsampler, gvec P, float lod, ivec offset); - "textureLodOffset" => MacroCall::Texture { - proj: false, - offset: true, - shadow, - level_type: TextureLevelType::Lod, - }, - // textureOffset(gsampler, gvec+1 P, ivec offset, [float bias]); - "textureOffset" => MacroCall::Texture { - proj: false, - offset: true, - shadow, - level_type: TextureLevelType::None, - }, - // textureProj(gsampler, gvec+1 P, [float bias]); - "textureProj" => MacroCall::Texture { - proj: true, - offset: false, - shadow, - level_type: TextureLevelType::None, - }, - // textureProjGrad(gsampler, gvec+1 P, gvec dPdx, gvec dPdy); - "textureProjGrad" => MacroCall::Texture { - proj: true, - offset: false, - shadow, - level_type: TextureLevelType::Grad, - }, - // textureProjGradOffset(gsampler, gvec+1 P, gvec dPdx, gvec dPdy, ivec offset); - "textureProjGradOffset" => MacroCall::Texture { - proj: true, - offset: true, - shadow, - level_type: TextureLevelType::Grad, - }, - // textureProjLod(gsampler, gvec+1 P, float lod); - "textureProjLod" => MacroCall::Texture { - proj: true, - offset: false, - shadow, - level_type: TextureLevelType::Lod, - }, - // textureProjLodOffset(gsampler, gvec+1 P, gvec dPdx, gvec dPdy, ivec offset); - "textureProjLodOffset" => MacroCall::Texture { - proj: true, - offset: true, - shadow, - level_type: TextureLevelType::Lod, - }, - // textureProjOffset(gsampler, gvec+1 P, ivec offset, [float bias]); - "textureProjOffset" => MacroCall::Texture { - proj: true, - offset: true, + let f = |kind, dim, arrayed, multi, shadow| { + for bits in 0..=0b11 { + let variant = bits & 0b1 != 0; + let bias = bits & 0b10 != 0; + + let (proj, offset, level_type) = match name { + // texture(gsampler, gvec P, [float bias]); + "texture" => (false, false, TextureLevelType::None), + // textureGrad(gsampler, gvec P, gvec dPdx, gvec dPdy); + "textureGrad" => (false, false, TextureLevelType::Grad), + // textureGradOffset(gsampler, gvec P, gvec dPdx, gvec dPdy, ivec offset); + "textureGradOffset" => (false, true, TextureLevelType::Grad), + // textureLod(gsampler, gvec P, float lod); + "textureLod" => (false, false, TextureLevelType::Lod), + // textureLodOffset(gsampler, gvec P, float lod, ivec offset); + "textureLodOffset" => (false, true, TextureLevelType::Lod), + // textureOffset(gsampler, gvec+1 P, ivec offset, [float bias]); + "textureOffset" => (false, true, TextureLevelType::None), + // textureProj(gsampler, gvec+1 P, [float bias]); + "textureProj" => (true, false, TextureLevelType::None), + // textureProjGrad(gsampler, gvec+1 P, gvec dPdx, gvec dPdy); + "textureProjGrad" => (true, false, TextureLevelType::Grad), + // textureProjGradOffset(gsampler, gvec+1 P, gvec dPdx, gvec dPdy, ivec offset); + "textureProjGradOffset" => (true, true, TextureLevelType::Grad), + // textureProjLod(gsampler, gvec+1 P, float lod); + "textureProjLod" => (true, false, TextureLevelType::Lod), + // textureProjLodOffset(gsampler, gvec+1 P, gvec dPdx, gvec dPdy, ivec offset); + "textureProjLodOffset" => (true, true, TextureLevelType::Lod), + // textureProjOffset(gsampler, gvec+1 P, ivec offset, [float bias]); + "textureProjOffset" => (true, true, TextureLevelType::None), + _ => unreachable!(), + }; + + let builtin = MacroCall::Texture { + proj, + offset, shadow, - level_type: TextureLevelType::None, - }, - _ => unreachable!(), - }; + level_type, + }; - // Parse out the variant settings. - let proj = matches!(builtin, MacroCall::Texture { proj: true, .. }); - let grad = matches!( - builtin, - MacroCall::Texture { - level_type: TextureLevelType::Grad, - .. - } - ); - let lod = matches!( - builtin, - MacroCall::Texture { - level_type: TextureLevelType::Lod, - .. + // Parse out the variant settings. + let grad = level_type == TextureLevelType::Grad; + let lod = level_type == TextureLevelType::Lod; + + let supports_variant = proj && !shadow; + if variant && !supports_variant { + continue; } - ); - let offset = matches!(builtin, MacroCall::Texture { offset: true, .. }); - let supports_variant = proj && !shadow; - if variant && !supports_variant { - continue; - } + if bias && !matches!(level_type, TextureLevelType::None) { + continue; + } - let supports_bias = matches!( - builtin, - MacroCall::Texture { - level_type: TextureLevelType::None, - .. + // Proj doesn't work with arrayed or Cube + if proj && (arrayed || dim == Dim::Cube) { + continue; } - ) && !shadow; - if bias && !supports_bias { - continue; - } - // Proj doesn't work with arrayed, Cube or 3D samplers - if proj && (arrayed || dim == 0b10 || dim == 0b11) { - continue; - } + // texture operations with offset are not supported for cube maps + if dim == Dim::Cube && offset { + continue; + } - // 3DArray and 3DShadow are not valid texture types - if dim == 0b11 && (arrayed || shadow) { - continue; - } + // sampler2DArrayShadow can't be used in textureLod or in texture with bias + if (lod || bias) && arrayed && shadow && dim == Dim::D2 { + continue; + } - // It seems that textureGradOffset(samplerCube) is not defined by GLSL for some reason... - if dim == 0b10 && grad && offset { - continue; - } + // TODO: glsl supports using bias with depth samplers but naga doesn't + if bias && shadow { + continue; + } - let class = match shadow { - true => ImageClass::Depth { multi: false }, - false => ImageClass::Sampled { - kind: Sk::Float, - multi: false, - }, - }; + let class = match shadow { + true => ImageClass::Depth { multi }, + false => ImageClass::Sampled { kind, multi }, + }; - let image = TypeInner::Image { - dim: match dim { - 0b00 => Dim::D1, - 0b01 => Dim::D2, - 0b10 => Dim::Cube, - _ => Dim::D3, - }, - arrayed, - class, - }; + let image = TypeInner::Image { + dim, + arrayed, + class, + }; - let num_coords_from_dim = (dim + 1).min(3); - let mut num_coords = num_coords_from_dim; + let dim_value = image_dims_to_coords_size(dim); + let num_coords_from_dim = (dim_value + 1).min(3); + let mut num_coords = num_coords_from_dim; - if shadow && proj { - num_coords = 4; - } else if shadow { - num_coords += 1; - } else if proj { - if variant && num_coords == 4 { - // Normal form already has 4 components, no need to have a variant form. - continue; - } else if variant { + if shadow && proj { num_coords = 4; - } else { + } else if dim == Dim::D1 && shadow { + num_coords = 3; + } else if shadow { num_coords += 1; + } else if proj { + if variant && num_coords == 4 { + // Normal form already has 4 components, no need to have a variant form. + continue; + } else if variant { + num_coords = 4; + } else { + num_coords += 1; + } } - } - - num_coords += arrayed as usize; - // Special case: texture(gsamplerCubeArrayShadow) kicks the shadow compare ref to a separate argument, - // since it would otherwise take five arguments. It also can't take a bias, nor can it be proj/grad/lod/offset - // (presumably because nobody asked for it, and implementation complexity?) - if num_coords >= 5 { - if lod || grad || offset || proj || bias { - continue; + if !(dim == Dim::D1 && shadow) { + num_coords += arrayed as usize; } - debug_assert!(dim == 0b10 && shadow && arrayed); - } - debug_assert!(num_coords <= 5); - let vector = make_coords_arg(num_coords, Sk::Float); - let mut args = vec![image, vector]; + // Special case: texture(gsamplerCubeArrayShadow) kicks the shadow compare ref to a separate argument, + // since it would otherwise take five arguments. It also can't take a bias, nor can it be proj/grad/lod/offset + // (presumably because nobody asked for it, and implementation complexity?) + if num_coords >= 5 { + if lod || grad || offset || proj || bias { + continue; + } + debug_assert!(dim == ImageDimension::Cube && shadow && arrayed); + } + debug_assert!(num_coords <= 5); - if num_coords == 5 { - args.push(TypeInner::Scalar { - kind: Sk::Float, - width, - }); - } + let vector = make_coords_arg(num_coords, Sk::Float); + let mut args = vec![image, vector]; - match builtin { - MacroCall::Texture { - level_type: TextureLevelType::Lod, - .. - } => { + if num_coords == 5 { args.push(TypeInner::Scalar { kind: Sk::Float, width, }); } - MacroCall::Texture { - level_type: TextureLevelType::Grad, - .. - } => { - args.push(make_coords_arg(num_coords_from_dim, Sk::Float)); - args.push(make_coords_arg(num_coords_from_dim, Sk::Float)); + + match level_type { + TextureLevelType::Lod => { + args.push(TypeInner::Scalar { + kind: Sk::Float, + width, + }); + } + TextureLevelType::Grad => { + args.push(make_coords_arg(num_coords_from_dim, Sk::Float)); + args.push(make_coords_arg(num_coords_from_dim, Sk::Float)); + } + _ => {} + }; + + if offset { + args.push(make_coords_arg(num_coords_from_dim, Sk::Sint)); } - _ => {} - }; - if offset { - args.push(make_coords_arg(num_coords_from_dim, Sk::Sint)); - } + if bias { + args.push(TypeInner::Scalar { + kind: Sk::Float, + width, + }); + } - if bias { - args.push(TypeInner::Scalar { - kind: Sk::Float, - width, - }); + declaration + .overloads + .push(module.add_builtin(args, builtin)); } + }; - declaration - .overloads - .push(module.add_builtin(args, builtin)); - } + texture_args_generator(TextureArgsOptions::SHADOW, f) } "textureSize" => { - // bits layout - // bits 0 trough 1 - dims - // bit 2 - shadow - // bit 3 - array - for bits in 0..(0b10000) { - let dim = bits & 0b11; - let shadow = bits & 0b100 == 0b100; - let arrayed = bits & 0b1000 == 0b1000; - - // Shadow, arrayed or both 3D images are not allowed - if (shadow || arrayed) && dim == 0b11 { - continue; - } - + let f = |kind, dim, arrayed, multi, shadow| { let class = match shadow { - true => ImageClass::Depth { multi: false }, - false => ImageClass::Sampled { - kind: Sk::Float, - multi: false, - }, + true => ImageClass::Depth { multi }, + false => ImageClass::Sampled { kind, multi }, }; let image = TypeInner::Image { - dim: match dim { - 0b00 => Dim::D1, - 0b01 => Dim::D2, - 0b10 => Dim::Cube, - _ => Dim::D3, - }, + dim, arrayed, class, }; - let args = vec![ - image, - TypeInner::Scalar { + let mut args = vec![image]; + + if !multi { + args.push(TypeInner::Scalar { kind: Sk::Sint, width, - }, - ]; + }) + } declaration .overloads - .push(module.add_builtin(args, MacroCall::TextureSize)) - } + .push(module.add_builtin(args, MacroCall::TextureSize { arrayed })) + }; + + texture_args_generator(TextureArgsOptions::all(), f) } "texelFetch" => { - // bits layout - // bit 0 - array - // bit 1 - multisample - // bits 2 trough 3 - dims - // - // 0b1000 is the latest since 3D images aren't allowed to be multisampled or arrayed - for bits in 0..=(0b1000) { - let arrayed = bits & 0b1 != 0; - let multi = bits & 0b10 != 0; - let dim = bits >> 2; - - // Multisampled 1d images don't exist - if dim == 0b00 && multi { - continue; + let f = |kind, dim, arrayed, multi, _| { + // Cube images aren't supported + if let Dim::Cube = dim { + return; } let image = TypeInner::Image { - dim: match dim { - 0b00 => Dim::D1, - 0b01 => Dim::D2, - _ => Dim::D3, - }, + dim, arrayed, - class: ImageClass::Sampled { - kind: Sk::Float, - multi, - }, + class: ImageClass::Sampled { kind, multi }, }; - let vector = match (dim, arrayed) { - (0b00, false) => TypeInner::Scalar { + let coordinates = match (dim, arrayed) { + (Dim::D1, false) => TypeInner::Scalar { kind: Sk::Sint, width, }, - (_, _) => { - let size = match dim + arrayed as u32 { + _ => { + let dim_value = image_dims_to_coords_size(dim); + let size = match dim_value + arrayed as usize { 1 => VectorSize::Bi, 2 => VectorSize::Tri, _ => VectorSize::Quad, @@ -493,7 +375,7 @@ pub fn inject_builtin(declaration: &mut FunctionDeclaration, module: &mut Module let args = vec![ image, - vector, + coordinates, TypeInner::Scalar { kind: Sk::Sint, width, @@ -503,7 +385,10 @@ pub fn inject_builtin(declaration: &mut FunctionDeclaration, module: &mut Module declaration .overloads .push(module.add_builtin(args, MacroCall::TexelFetch)) - } + }; + + // Don't generate shadow images since they aren't supported + texture_args_generator(TextureArgsOptions::MULTI, f) } "sin" | "exp" | "exp2" | "sinh" | "cos" | "cosh" | "tan" | "tanh" | "acos" | "asin" | "log" | "log2" | "radians" | "degrees" | "asinh" | "acosh" | "atanh" @@ -1546,7 +1431,9 @@ pub enum MacroCall { shadow: bool, level_type: TextureLevelType, }, - TextureSize, + TextureSize { + arrayed: bool, + }, TexelFetch, MathFunction(MathFunction), BitfieldExtract, @@ -1706,16 +1593,69 @@ impl MacroCall { texture_call(ctx, args[0], level, comps, texture_offset, body, meta) } - MacroCall::TextureSize => Ok(ctx.add_expression( - Expression::ImageQuery { - image: args[0], - query: ImageQuery::Size { - level: args.get(1).copied(), + + MacroCall::TextureSize { arrayed } => { + let mut expr = ctx.add_expression( + Expression::ImageQuery { + image: args[0], + query: ImageQuery::Size { + level: args.get(1).copied(), + }, }, - }, - Span::default(), - body, - )), + Span::default(), + body, + ); + + if arrayed { + let mut components = Vec::with_capacity(4); + + let size = match *parser.resolve_type(ctx, expr, meta)? { + TypeInner::Vector { size: ori_size, .. } => { + for index in 0..(ori_size as u32) { + components.push(ctx.add_expression( + Expression::AccessIndex { base: expr, index }, + Span::default(), + body, + )) + } + + match ori_size { + VectorSize::Bi => VectorSize::Tri, + _ => VectorSize::Quad, + } + } + _ => { + components.push(expr); + VectorSize::Bi + } + }; + + components.push(ctx.add_expression( + Expression::ImageQuery { + image: args[0], + query: ImageQuery::NumLayers, + }, + Span::default(), + body, + )); + + let ty = parser.module.types.insert( + Type { + name: None, + inner: TypeInner::Vector { + size, + kind: crate::ScalarKind::Sint, + width: 4, + }, + }, + Span::default(), + ); + + expr = ctx.add_expression(Expression::Compose { components, ty }, meta, body) + } + + Ok(expr) + } MacroCall::TexelFetch => { let comps = parser.coordinate_components(ctx, args[0], args[1], None, meta, body)?; @@ -2099,3 +2039,64 @@ pub fn sampled_to_depth( }), }; } + +bitflags::bitflags! { + /// Influences the operation `texture_args_generator` + struct TextureArgsOptions: u32 { + /// Generates multisampled variants of images + const MULTI = 0; + /// Generates shadow variants of images + const SHADOW = 1; + } +} + +/// Helper function to generate the image components for texture/image builtins +/// +/// Calls the passed function `f` with: +/// ```text +/// f(ScalarKind, ImageDimension, arrayed, multi, shadow) +/// ``` +/// +/// `options` controls extra image variants generation like multisampling and depth, +/// see the struct documentation +fn texture_args_generator( + options: TextureArgsOptions, + mut f: impl FnMut(crate::ScalarKind, ImageDimension, bool, bool, bool), +) { + use crate::ImageDimension as Dim; + + for kind in [Sk::Float, Sk::Uint, Sk::Sint].iter().copied() { + for dim in [Dim::D1, Dim::D2, Dim::D3, Dim::Cube].iter().copied() { + for arrayed in [false, true].iter().copied() { + f(kind, dim, arrayed, false, false); + + // 3D images can't be neither arrayed nor shadow + // so we break out early, this way arrayed will always + // be false and we won't hit the shadow branch + if let Dim::D3 = dim { + break; + } + + if Dim::D2 == dim && options.contains(TextureArgsOptions::MULTI) { + // multisampling + f(kind, dim, arrayed, true, false); + } + + if Sk::Float == kind && options.contains(TextureArgsOptions::SHADOW) { + // shadow + f(kind, dim, arrayed, false, true); + } + } + } + } +} + +/// Helper functions used to convert from a image dimension into a integer representing the +/// number of components needed for the coordinates vector (0 means scalar instead of vector) +fn image_dims_to_coords_size(dim: ImageDimension) -> usize { + match dim { + ImageDimension::D1 => 0, + ImageDimension::D2 => 1, + _ => 2, + } +} diff --git a/tests/in/glsl/samplers.frag b/tests/in/glsl/samplers.frag index c3f6484c22..1a34216009 100644 --- a/tests/in/glsl/samplers.frag +++ b/tests/in/glsl/samplers.frag @@ -25,6 +25,9 @@ layout(set = 1, binding = 15) uniform textureCubeArray texCubeArrayShadow; layout(set = 1, binding = 16) uniform texture3D tex3DShadow; layout(set = 1, binding = 17) uniform samplerShadow sampShadow; +layout(binding = 18) uniform texture2DMS tex2DMS; +layout(binding = 19) uniform texture2DMSArray tex2DMSArray; + // Conventions for readability: // 1.0 = Shadow Ref // 2.0 = LOD Bias @@ -34,6 +37,7 @@ layout(set = 1, binding = 17) uniform samplerShadow sampShadow; // 6.0 = Proj W void testTex1D(in float coord) { + int size1D = textureSize(sampler1D(tex1D, samp), 0); vec4 c; c = texture(sampler1D(tex1D, samp), coord); c = texture(sampler1D(tex1D, samp), coord, 2.0); @@ -59,27 +63,35 @@ void testTex1D(in float coord) { c = textureProjOffset(sampler1D(tex1D, samp), vec4(coord, 0.0, 0.0, 6.0), 5); c = textureProjOffset(sampler1D(tex1D, samp), vec2(coord, 6.0), 5, 2.0); c = textureProjOffset(sampler1D(tex1D, samp), vec4(coord, 0.0, 0.0, 6.0), 5, 2.0); + c = texelFetch(sampler1D(tex1D, samp), int(coord), 3); + // c = texelFetchOffset(sampler1D(tex1D, samp), int(coord), 3, 5); } #if HAS_1D_DEPTH_TEXTURES void testTex1DShadow(float coord) { + int size1DShadow = textureSize(sampler1DShadow(tex1DShadow, sampShadow), 0); float d; - d = texture(sampler1DShadow(tex1DShadow, sampShadow), vec2(coord, 1.0)); - d = textureGrad(sampler1DShadow(tex1DShadow, sampShadow), vec2(coord, 1.0), 4.0, 4.0); - d = textureGradOffset(sampler1DShadow(tex1DShadow, sampShadow), vec2(coord, 1.0), 4.0, 4.0, 5); - d = textureLod(sampler1DShadow(tex1DShadow, sampShadow), vec2(coord, 1.0), 3.0); - d = textureLodOffset(sampler1DShadow(tex1DShadow, sampShadow), vec2(coord, 1.0), 3.0, 5); - d = textureOffset(sampler1DShadow(tex1DShadow, sampShadow), vec2(coord, 1.0), 5); + d = texture(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0)); + // d = texture(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 2.0); + d = textureGrad(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 4.0, 4.0); + d = textureGradOffset(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 4.0, 4.0, 5); + d = textureLod(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 3.0); + d = textureLodOffset(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 3.0, 5); + d = textureOffset(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 5); + // d = textureOffset(sampler1DShadow(tex1DShadow, sampShadow), vec3(coord, 1.0, 1.0), 5, 2.0); d = textureProj(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0)); + // d = textureProj(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 2.0); d = textureProjGrad(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 4.0, 4.0); d = textureProjGradOffset(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 4.0, 4.0, 5); d = textureProjLod(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 3.0); d = textureProjLodOffset(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 3.0, 5); d = textureProjOffset(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 5); + // d = textureProjOffset(sampler1DShadow(tex1DShadow, sampShadow), vec4(coord, 0.0, 1.0, 6.0), 5, 2.0); } #endif void testTex1DArray(in vec2 coord) { + ivec2 size1DArray = textureSize(sampler1DArray(tex1DArray, samp), 0); vec4 c; c = texture(sampler1DArray(tex1DArray, samp), coord); c = texture(sampler1DArray(tex1DArray, samp), coord, 2.0); @@ -89,10 +101,13 @@ void testTex1DArray(in vec2 coord) { c = textureLodOffset(sampler1DArray(tex1DArray, samp), coord, 3.0, 5); c = textureOffset(sampler1DArray(tex1DArray, samp), coord, 5); c = textureOffset(sampler1DArray(tex1DArray, samp), coord, 5, 2.0); + c = texelFetch(sampler1DArray(tex1DArray, samp), ivec2(coord), 3); + // c = texelFetchOffset(sampler1DArray(tex1DArray, samp), ivec2(coord), 3, 5); } #if HAS_1D_DEPTH_TEXTURES void testTex1DArrayShadow(in vec2 coord) { + ivec2 size1DArrayShadow = textureSize(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), 0); float d; d = texture(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), vec3(coord, 1.0)); d = textureGrad(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), vec3(coord, 1.0), 4.0, 4.0); @@ -100,10 +115,12 @@ void testTex1DArrayShadow(in vec2 coord) { d = textureLod(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), vec3(coord, 1.0), 3.0); d = textureLodOffset(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), vec3(coord, 1.0), 3.0, 5); d = textureOffset(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), vec3(coord, 1.0), 5); + // d = textureOffset(sampler1DArrayShadow(tex1DArrayShadow, sampShadow), vec3(coord, 1.0), 5, 2.0); } #endif void testTex2D(in vec2 coord) { + ivec2 size2D = textureSize(sampler2D(tex2D, samp), 0); vec4 c; c = texture(sampler2D(tex2D, samp), coord); c = texture(sampler2D(tex2D, samp), coord, 2.0); @@ -129,25 +146,33 @@ void testTex2D(in vec2 coord) { c = textureProjOffset(sampler2D(tex2D, samp), vec4(coord, 0.0, 6.0), ivec2(5)); c = textureProjOffset(sampler2D(tex2D, samp), vec3(coord, 6.0), ivec2(5), 2.0); c = textureProjOffset(sampler2D(tex2D, samp), vec4(coord, 0.0, 6.0), ivec2(5), 2.0); + c = texelFetch(sampler2D(tex2D, samp), ivec2(coord), 3); + // c = texelFetchOffset(sampler2D(tex2D, samp), ivec2(coord), 3, ivec2(5)); } void testTex2DShadow(vec2 coord) { + ivec2 size2DShadow = textureSize(sampler2DShadow(tex2DShadow, sampShadow), 0); float d; d = texture(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0)); + // d = texture(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), 2.0); d = textureGrad(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), vec2(4.0), vec2(4.0)); d = textureGradOffset(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), vec2(4.0), vec2(4.0), ivec2(5)); d = textureLod(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), 3.0); d = textureLodOffset(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), 3.0, ivec2(5)); d = textureOffset(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), ivec2(5)); + // d = textureOffset(sampler2DShadow(tex2DShadow, sampShadow), vec3(coord, 1.0), ivec2(5), 2.0); d = textureProj(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0)); + // d = textureProj(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), 2.0); d = textureProjGrad(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), vec2(4.0), vec2(4.0)); d = textureProjGradOffset(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), vec2(4.0), vec2(4.0), ivec2(5)); d = textureProjLod(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), 3.0); d = textureProjLodOffset(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), 3.0, ivec2(5)); d = textureProjOffset(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), ivec2(5)); + // d = textureProjOffset(sampler2DShadow(tex2DShadow, sampShadow), vec4(coord, 1.0, 6.0), ivec2(5), 2.0); } void testTex2DArray(in vec3 coord) { + ivec3 size2DArray = textureSize(sampler2DArray(tex2DArray, samp), 0); vec4 c; c = texture(sampler2DArray(tex2DArray, samp), coord); c = texture(sampler2DArray(tex2DArray, samp), coord, 2.0); @@ -157,68 +182,84 @@ void testTex2DArray(in vec3 coord) { c = textureLodOffset(sampler2DArray(tex2DArray, samp), coord, 3.0, ivec2(5)); c = textureOffset(sampler2DArray(tex2DArray, samp), coord, ivec2(5)); c = textureOffset(sampler2DArray(tex2DArray, samp), coord, ivec2(5), 2.0); + c = texelFetch(sampler2DArray(tex2DArray, samp), ivec3(coord), 3); + // c = texelFetchOffset(sampler2DArray(tex2DArray, samp), ivec3(coord), 3, ivec2(5)); } void testTex2DArrayShadow(in vec3 coord) { + ivec3 size2DArrayShadow = textureSize(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), 0); float d; d = texture(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), vec4(coord, 1.0)); d = textureGrad(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), vec4(coord, 1.0), vec2(4.0), vec2(4.0)); d = textureGradOffset(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), vec4(coord, 1.0), vec2(4.0), vec2(4.0), ivec2(5)); - d = textureLod(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), vec4(coord, 1.0), 3.0); - d = textureLodOffset(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), vec4(coord, 1.0), 3.0, ivec2(5)); d = textureOffset(sampler2DArrayShadow(tex2DArrayShadow, sampShadow), vec4(coord, 1.0), ivec2(5)); } void testTexCube(in vec3 coord) { + ivec2 sizeCube = textureSize(samplerCube(texCube, samp), 0); vec4 c; c = texture(samplerCube(texCube, samp), coord); c = texture(samplerCube(texCube, samp), coord, 2.0); c = textureGrad(samplerCube(texCube, samp), coord, vec3(4.0), vec3(4.0)); c = textureLod(samplerCube(texCube, samp), coord, 3.0); - c = textureLodOffset(samplerCube(texCube, samp), coord, 3.0, ivec3(5)); - c = textureOffset(samplerCube(texCube, samp), coord, ivec3(5)); - c = textureOffset(samplerCube(texCube, samp), coord, ivec3(5), 2.0); } void testTexCubeShadow(in vec3 coord) { + ivec2 sizeCubeShadow = textureSize(samplerCubeShadow(texCubeShadow, sampShadow), 0); float d; d = texture(samplerCubeShadow(texCubeShadow, sampShadow), vec4(coord, 1.0)); d = textureGrad(samplerCubeShadow(texCubeShadow, sampShadow), vec4(coord, 1.0), vec3(4.0), vec3(4.0)); - d = textureLod(samplerCubeShadow(texCubeShadow, sampShadow), vec4(coord, 1.0), 3.0); - d = textureLodOffset(samplerCubeShadow(texCubeShadow, sampShadow), vec4(coord, 1.0), 3.0, ivec3(5)); - d = textureOffset(samplerCubeShadow(texCubeShadow, sampShadow), vec4(coord, 1.0), ivec3(5)); } void testTexCubeArray(in vec4 coord) { + ivec3 sizeCubeArray = textureSize(samplerCubeArray(texCubeArray, samp), 0); vec4 c; c = texture(samplerCubeArray(texCubeArray, samp), coord); c = texture(samplerCubeArray(texCubeArray, samp), coord, 2.0); c = textureGrad(samplerCubeArray(texCubeArray, samp), coord, vec3(4.0), vec3(4.0)); c = textureLod(samplerCubeArray(texCubeArray, samp), coord, 3.0); - c = textureLodOffset(samplerCubeArray(texCubeArray, samp), coord, 3.0, ivec3(5)); - c = textureOffset(samplerCubeArray(texCubeArray, samp), coord, ivec3(5)); - c = textureOffset(samplerCubeArray(texCubeArray, samp), coord, ivec3(5), 2.0); } void testTexCubeArrayShadow(in vec4 coord) { + ivec3 sizeCubeArrayShadow = textureSize(samplerCubeArrayShadow(texCubeArrayShadow, sampShadow), 0); float d; d = texture(samplerCubeArrayShadow(texCubeArrayShadow, sampShadow), coord, 1.0); // The rest of the variants aren't defined by GLSL. } void testTex3D(in vec3 coord) { + ivec3 size3D = textureSize(sampler3D(tex3D, samp), 0); vec4 c; c = texture(sampler3D(tex3D, samp), coord); c = texture(sampler3D(tex3D, samp), coord, 2.0); + c = textureProj(sampler3D(tex3D, samp), vec4(coord, 6.0)); + c = textureProj(sampler3D(tex3D, samp), vec4(coord, 6.0), 2.0); + c = textureProjOffset(sampler3D(tex3D, samp), vec4(coord, 6.0), ivec3(5)); + c = textureProjOffset(sampler3D(tex3D, samp), vec4(coord, 6.0), ivec3(5), 2.0); + c = textureProjLod(sampler3D(tex3D, samp), vec4(coord, 6.0), 3.0); + c = textureProjLodOffset(sampler3D(tex3D, samp), vec4(coord, 6.0), 3.0, ivec3(5)); + c = textureProjGrad(sampler3D(tex3D, samp), vec4(coord, 6.0), vec3(4.0), vec3(4.0)); + c = textureProjGradOffset(sampler3D(tex3D, samp), vec4(coord, 6.0), vec3(4.0), vec3(4.0), ivec3(5)); c = textureGrad(sampler3D(tex3D, samp), coord, vec3(4.0), vec3(4.0)); c = textureGradOffset(sampler3D(tex3D, samp), coord, vec3(4.0), vec3(4.0), ivec3(5)); c = textureLod(sampler3D(tex3D, samp), coord, 3.0); c = textureLodOffset(sampler3D(tex3D, samp), coord, 3.0, ivec3(5)); c = textureOffset(sampler3D(tex3D, samp), coord, ivec3(5)); c = textureOffset(sampler3D(tex3D, samp), coord, ivec3(5), 2.0); + c = texelFetch(sampler3D(tex3D, samp), ivec3(coord), 3); + // c = texelFetchOffset(sampler3D(tex3D, samp), ivec3(coord), 3, ivec3(5)); } -layout(location = 0) in vec4 texcoord; +void testTex2DMS(in vec2 coord) { + ivec2 size2DMS = textureSize(sampler2DMS(tex2DMS, samp)); + vec4 c; + c = texelFetch(sampler2DMS(tex2DMS, samp), ivec2(coord), 3); +} -void main() { +void testTex2DMSArray(in vec3 coord) { + ivec3 size2DMSArray = textureSize(sampler2DMSArray(tex2DMSArray, samp)); + vec4 c; + c = texelFetch(sampler2DMSArray(tex2DMSArray, samp), ivec3(coord), 3); } + +void main() {} diff --git a/tests/out/wgsl/samplers-frag.wgsl b/tests/out/wgsl/samplers-frag.wgsl index f4ec16972f..3e5eb59551 100644 --- a/tests/out/wgsl/samplers-frag.wgsl +++ b/tests/out/wgsl/samplers-frag.wgsl @@ -26,539 +26,631 @@ var texCubeArrayShadow: texture_depth_cube_array; var tex3DShadow: texture_3d; @group(1) @binding(17) var sampShadow: sampler_comparison; -var texcoord_1: vec4; +@group(0) @binding(18) +var tex2DMS: texture_multisampled_2d; +@group(0) @binding(19) +var tex2DMSArray: texture_multisampled_2d_array; fn testTex1D(coord: f32) { var coord_1: f32; + var size1D: i32; var c: vec4; coord_1 = coord; - let _e18 = coord_1; - let _e19 = textureSample(tex1D, samp, _e18); - c = _e19; - let _e22 = coord_1; - let _e24 = textureSampleBias(tex1D, samp, _e22, 2.0); - c = _e24; + let _e20 = textureDimensions(tex1D, 0); + size1D = _e20; + let _e24 = coord_1; + let _e25 = textureSample(tex1D, samp, _e24); + c = _e25; let _e28 = coord_1; - let _e31 = textureSampleGrad(tex1D, samp, _e28, 4.0, 4.0); - c = _e31; - let _e36 = coord_1; - let _e40 = textureSampleGrad(tex1D, samp, _e36, 4.0, 4.0, 5); - c = _e40; - let _e43 = coord_1; - let _e45 = textureSampleLevel(tex1D, samp, _e43, 3.0); - c = _e45; + let _e30 = textureSampleBias(tex1D, samp, _e28, 2.0); + c = _e30; + let _e34 = coord_1; + let _e37 = textureSampleGrad(tex1D, samp, _e34, 4.0, 4.0); + c = _e37; + let _e42 = coord_1; + let _e46 = textureSampleGrad(tex1D, samp, _e42, 4.0, 4.0, 5); + c = _e46; let _e49 = coord_1; - let _e52 = textureSampleLevel(tex1D, samp, _e49, 3.0, 5); - c = _e52; + let _e51 = textureSampleLevel(tex1D, samp, _e49, 3.0); + c = _e51; let _e55 = coord_1; - let _e57 = textureSample(tex1D, samp, _e55, 5); - c = _e57; + let _e58 = textureSampleLevel(tex1D, samp, _e55, 3.0, 5); + c = _e58; let _e61 = coord_1; - let _e64 = textureSampleBias(tex1D, samp, _e61, 2.0, 5); - c = _e64; - let _e65 = coord_1; - let _e68 = coord_1; - let _e70 = vec2(_e68, 6.0); - let _e74 = textureSample(tex1D, samp, (_e70.x / _e70.y)); - c = _e74; - let _e75 = coord_1; - let _e80 = coord_1; - let _e84 = vec4(_e80, 0.0, 0.0, 6.0); - let _e90 = textureSample(tex1D, samp, (_e84.xyz / vec3(_e84.w)).x); - c = _e90; - let _e91 = coord_1; - let _e95 = coord_1; - let _e97 = vec2(_e95, 6.0); - let _e102 = textureSampleBias(tex1D, samp, (_e97.x / _e97.y), 2.0); - c = _e102; - let _e103 = coord_1; + let _e63 = textureSample(tex1D, samp, _e61, 5); + c = _e63; + let _e67 = coord_1; + let _e70 = textureSampleBias(tex1D, samp, _e67, 2.0, 5); + c = _e70; + let _e71 = coord_1; + let _e74 = coord_1; + let _e76 = vec2(_e74, 6.0); + let _e80 = textureSample(tex1D, samp, (_e76.x / _e76.y)); + c = _e80; + let _e81 = coord_1; + let _e86 = coord_1; + let _e90 = vec4(_e86, 0.0, 0.0, 6.0); + let _e96 = textureSample(tex1D, samp, (_e90.xyz / vec3(_e90.w)).x); + c = _e96; + let _e97 = coord_1; + let _e101 = coord_1; + let _e103 = vec2(_e101, 6.0); + let _e108 = textureSampleBias(tex1D, samp, (_e103.x / _e103.y), 2.0); + c = _e108; let _e109 = coord_1; - let _e113 = vec4(_e109, 0.0, 0.0, 6.0); - let _e120 = textureSampleBias(tex1D, samp, (_e113.xyz / vec3(_e113.w)).x, 2.0); - c = _e120; - let _e121 = coord_1; - let _e126 = coord_1; - let _e128 = vec2(_e126, 6.0); - let _e134 = textureSampleGrad(tex1D, samp, (_e128.x / _e128.y), 4.0, 4.0); - c = _e134; - let _e135 = coord_1; - let _e142 = coord_1; - let _e146 = vec4(_e142, 0.0, 0.0, 6.0); - let _e154 = textureSampleGrad(tex1D, samp, (_e146.xyz / vec3(_e146.w)).x, 4.0, 4.0); - c = _e154; - let _e155 = coord_1; + let _e115 = coord_1; + let _e119 = vec4(_e115, 0.0, 0.0, 6.0); + let _e126 = textureSampleBias(tex1D, samp, (_e119.xyz / vec3(_e119.w)).x, 2.0); + c = _e126; + let _e127 = coord_1; + let _e132 = coord_1; + let _e134 = vec2(_e132, 6.0); + let _e140 = textureSampleGrad(tex1D, samp, (_e134.x / _e134.y), 4.0, 4.0); + c = _e140; + let _e141 = coord_1; + let _e148 = coord_1; + let _e152 = vec4(_e148, 0.0, 0.0, 6.0); + let _e160 = textureSampleGrad(tex1D, samp, (_e152.xyz / vec3(_e152.w)).x, 4.0, 4.0); + c = _e160; let _e161 = coord_1; - let _e163 = vec2(_e161, 6.0); - let _e170 = textureSampleGrad(tex1D, samp, (_e163.x / _e163.y), 4.0, 4.0, 5); - c = _e170; - let _e171 = coord_1; - let _e179 = coord_1; - let _e183 = vec4(_e179, 0.0, 0.0, 6.0); - let _e192 = textureSampleGrad(tex1D, samp, (_e183.xyz / vec3(_e183.w)).x, 4.0, 4.0, 5); - c = _e192; - let _e193 = coord_1; - let _e197 = coord_1; - let _e199 = vec2(_e197, 6.0); - let _e204 = textureSampleLevel(tex1D, samp, (_e199.x / _e199.y), 3.0); - c = _e204; - let _e205 = coord_1; + let _e167 = coord_1; + let _e169 = vec2(_e167, 6.0); + let _e176 = textureSampleGrad(tex1D, samp, (_e169.x / _e169.y), 4.0, 4.0, 5); + c = _e176; + let _e177 = coord_1; + let _e185 = coord_1; + let _e189 = vec4(_e185, 0.0, 0.0, 6.0); + let _e198 = textureSampleGrad(tex1D, samp, (_e189.xyz / vec3(_e189.w)).x, 4.0, 4.0, 5); + c = _e198; + let _e199 = coord_1; + let _e203 = coord_1; + let _e205 = vec2(_e203, 6.0); + let _e210 = textureSampleLevel(tex1D, samp, (_e205.x / _e205.y), 3.0); + c = _e210; let _e211 = coord_1; - let _e215 = vec4(_e211, 0.0, 0.0, 6.0); - let _e222 = textureSampleLevel(tex1D, samp, (_e215.xyz / vec3(_e215.w)).x, 3.0); - c = _e222; - let _e223 = coord_1; - let _e228 = coord_1; - let _e230 = vec2(_e228, 6.0); - let _e236 = textureSampleLevel(tex1D, samp, (_e230.x / _e230.y), 3.0, 5); - c = _e236; - let _e237 = coord_1; - let _e244 = coord_1; - let _e248 = vec4(_e244, 0.0, 0.0, 6.0); - let _e256 = textureSampleLevel(tex1D, samp, (_e248.xyz / vec3(_e248.w)).x, 3.0, 5); - c = _e256; - let _e257 = coord_1; - let _e261 = coord_1; - let _e263 = vec2(_e261, 6.0); - let _e268 = textureSample(tex1D, samp, (_e263.x / _e263.y), 5); - c = _e268; - let _e269 = coord_1; + let _e217 = coord_1; + let _e221 = vec4(_e217, 0.0, 0.0, 6.0); + let _e228 = textureSampleLevel(tex1D, samp, (_e221.xyz / vec3(_e221.w)).x, 3.0); + c = _e228; + let _e229 = coord_1; + let _e234 = coord_1; + let _e236 = vec2(_e234, 6.0); + let _e242 = textureSampleLevel(tex1D, samp, (_e236.x / _e236.y), 3.0, 5); + c = _e242; + let _e243 = coord_1; + let _e250 = coord_1; + let _e254 = vec4(_e250, 0.0, 0.0, 6.0); + let _e262 = textureSampleLevel(tex1D, samp, (_e254.xyz / vec3(_e254.w)).x, 3.0, 5); + c = _e262; + let _e263 = coord_1; + let _e267 = coord_1; + let _e269 = vec2(_e267, 6.0); + let _e274 = textureSample(tex1D, samp, (_e269.x / _e269.y), 5); + c = _e274; let _e275 = coord_1; - let _e279 = vec4(_e275, 0.0, 0.0, 6.0); - let _e286 = textureSample(tex1D, samp, (_e279.xyz / vec3(_e279.w)).x, 5); - c = _e286; - let _e287 = coord_1; - let _e292 = coord_1; - let _e294 = vec2(_e292, 6.0); - let _e300 = textureSampleBias(tex1D, samp, (_e294.x / _e294.y), 2.0, 5); - c = _e300; - let _e301 = coord_1; - let _e308 = coord_1; - let _e312 = vec4(_e308, 0.0, 0.0, 6.0); - let _e320 = textureSampleBias(tex1D, samp, (_e312.xyz / vec3(_e312.w)).x, 2.0, 5); - c = _e320; + let _e281 = coord_1; + let _e285 = vec4(_e281, 0.0, 0.0, 6.0); + let _e292 = textureSample(tex1D, samp, (_e285.xyz / vec3(_e285.w)).x, 5); + c = _e292; + let _e293 = coord_1; + let _e298 = coord_1; + let _e300 = vec2(_e298, 6.0); + let _e306 = textureSampleBias(tex1D, samp, (_e300.x / _e300.y), 2.0, 5); + c = _e306; + let _e307 = coord_1; + let _e314 = coord_1; + let _e318 = vec4(_e314, 0.0, 0.0, 6.0); + let _e326 = textureSampleBias(tex1D, samp, (_e318.xyz / vec3(_e318.w)).x, 2.0, 5); + c = _e326; + let _e327 = coord_1; + let _e330 = coord_1; + let _e333 = textureLoad(tex1D, i32(_e330), 3); + c = _e333; return; } fn testTex1DArray(coord_2: vec2) { var coord_3: vec2; + var size1DArray: vec2; var c_1: vec4; coord_3 = coord_2; - let _e18 = coord_3; - let _e22 = textureSample(tex1DArray, samp, _e18.x, i32(_e18.y)); - c_1 = _e22; - let _e25 = coord_3; - let _e30 = textureSampleBias(tex1DArray, samp, _e25.x, i32(_e25.y), 2.0); + let _e20 = textureDimensions(tex1DArray, 0); + let _e21 = textureNumLayers(tex1DArray); + size1DArray = vec2(_e20, _e21); + let _e26 = coord_3; + let _e30 = textureSample(tex1DArray, samp, _e26.x, i32(_e26.y)); c_1 = _e30; - let _e34 = coord_3; - let _e40 = textureSampleGrad(tex1DArray, samp, _e34.x, i32(_e34.y), 4.0, 4.0); - c_1 = _e40; - let _e45 = coord_3; - let _e52 = textureSampleGrad(tex1DArray, samp, _e45.x, i32(_e45.y), 4.0, 4.0, 5); - c_1 = _e52; - let _e55 = coord_3; - let _e60 = textureSampleLevel(tex1DArray, samp, _e55.x, i32(_e55.y), 3.0); + let _e33 = coord_3; + let _e38 = textureSampleBias(tex1DArray, samp, _e33.x, i32(_e33.y), 2.0); + c_1 = _e38; + let _e42 = coord_3; + let _e48 = textureSampleGrad(tex1DArray, samp, _e42.x, i32(_e42.y), 4.0, 4.0); + c_1 = _e48; + let _e53 = coord_3; + let _e60 = textureSampleGrad(tex1DArray, samp, _e53.x, i32(_e53.y), 4.0, 4.0, 5); c_1 = _e60; - let _e64 = coord_3; - let _e70 = textureSampleLevel(tex1DArray, samp, _e64.x, i32(_e64.y), 3.0, 5); - c_1 = _e70; - let _e73 = coord_3; - let _e78 = textureSample(tex1DArray, samp, _e73.x, i32(_e73.y), 5); + let _e63 = coord_3; + let _e68 = textureSampleLevel(tex1DArray, samp, _e63.x, i32(_e63.y), 3.0); + c_1 = _e68; + let _e72 = coord_3; + let _e78 = textureSampleLevel(tex1DArray, samp, _e72.x, i32(_e72.y), 3.0, 5); c_1 = _e78; - let _e82 = coord_3; - let _e88 = textureSampleBias(tex1DArray, samp, _e82.x, i32(_e82.y), 2.0, 5); - c_1 = _e88; + let _e81 = coord_3; + let _e86 = textureSample(tex1DArray, samp, _e81.x, i32(_e81.y), 5); + c_1 = _e86; + let _e90 = coord_3; + let _e96 = textureSampleBias(tex1DArray, samp, _e90.x, i32(_e90.y), 2.0, 5); + c_1 = _e96; + let _e97 = coord_3; + let _e100 = coord_3; + let _e101 = vec2(_e100); + let _e105 = textureLoad(tex1DArray, _e101.x, _e101.y, 3); + c_1 = _e105; return; } fn testTex2D(coord_4: vec2) { var coord_5: vec2; + var size2D: vec2; var c_2: vec4; coord_5 = coord_4; - let _e18 = coord_5; - let _e19 = textureSample(tex2D, samp, _e18); - c_2 = _e19; - let _e22 = coord_5; - let _e24 = textureSampleBias(tex2D, samp, _e22, 2.0); - c_2 = _e24; - let _e30 = coord_5; - let _e35 = textureSampleGrad(tex2D, samp, _e30, vec2(4.0), vec2(4.0)); - c_2 = _e35; - let _e43 = coord_5; - let _e50 = textureSampleGrad(tex2D, samp, _e43, vec2(4.0), vec2(4.0), vec2(5, 5)); - c_2 = _e50; - let _e53 = coord_5; - let _e55 = textureSampleLevel(tex2D, samp, _e53, 3.0); - c_2 = _e55; - let _e60 = coord_5; - let _e64 = textureSampleLevel(tex2D, samp, _e60, 3.0, vec2(5, 5)); - c_2 = _e64; - let _e68 = coord_5; - let _e71 = textureSample(tex2D, samp, _e68, vec2(5, 5)); - c_2 = _e71; - let _e76 = coord_5; - let _e80 = textureSampleBias(tex2D, samp, _e76, 2.0, vec2(5, 5)); - c_2 = _e80; - let _e81 = coord_5; - let _e86 = coord_5; - let _e90 = vec3(_e86.x, _e86.y, 6.0); - let _e95 = textureSample(tex2D, samp, (_e90.xy / vec2(_e90.z))); - c_2 = _e95; - let _e96 = coord_5; + let _e20 = textureDimensions(tex2D, 0); + size2D = _e20; + let _e24 = coord_5; + let _e25 = textureSample(tex2D, samp, _e24); + c_2 = _e25; + let _e28 = coord_5; + let _e30 = textureSampleBias(tex2D, samp, _e28, 2.0); + c_2 = _e30; + let _e36 = coord_5; + let _e41 = textureSampleGrad(tex2D, samp, _e36, vec2(4.0), vec2(4.0)); + c_2 = _e41; + let _e49 = coord_5; + let _e56 = textureSampleGrad(tex2D, samp, _e49, vec2(4.0), vec2(4.0), vec2(5, 5)); + c_2 = _e56; + let _e59 = coord_5; + let _e61 = textureSampleLevel(tex2D, samp, _e59, 3.0); + c_2 = _e61; + let _e66 = coord_5; + let _e70 = textureSampleLevel(tex2D, samp, _e66, 3.0, vec2(5, 5)); + c_2 = _e70; + let _e74 = coord_5; + let _e77 = textureSample(tex2D, samp, _e74, vec2(5, 5)); + c_2 = _e77; + let _e82 = coord_5; + let _e86 = textureSampleBias(tex2D, samp, _e82, 2.0, vec2(5, 5)); + c_2 = _e86; + let _e87 = coord_5; + let _e92 = coord_5; + let _e96 = vec3(_e92.x, _e92.y, 6.0); + let _e101 = textureSample(tex2D, samp, (_e96.xy / vec2(_e96.z))); + c_2 = _e101; let _e102 = coord_5; - let _e107 = vec4(_e102.x, _e102.y, 0.0, 6.0); - let _e113 = textureSample(tex2D, samp, (_e107.xyz / vec3(_e107.w)).xy); - c_2 = _e113; - let _e114 = coord_5; + let _e108 = coord_5; + let _e113 = vec4(_e108.x, _e108.y, 0.0, 6.0); + let _e119 = textureSample(tex2D, samp, (_e113.xyz / vec3(_e113.w)).xy); + c_2 = _e119; let _e120 = coord_5; - let _e124 = vec3(_e120.x, _e120.y, 6.0); - let _e130 = textureSampleBias(tex2D, samp, (_e124.xy / vec2(_e124.z)), 2.0); - c_2 = _e130; - let _e131 = coord_5; - let _e138 = coord_5; - let _e143 = vec4(_e138.x, _e138.y, 0.0, 6.0); - let _e150 = textureSampleBias(tex2D, samp, (_e143.xyz / vec3(_e143.w)).xy, 2.0); - c_2 = _e150; - let _e151 = coord_5; - let _e160 = coord_5; - let _e164 = vec3(_e160.x, _e160.y, 6.0); - let _e173 = textureSampleGrad(tex2D, samp, (_e164.xy / vec2(_e164.z)), vec2(4.0), vec2(4.0)); - c_2 = _e173; - let _e174 = coord_5; - let _e184 = coord_5; - let _e189 = vec4(_e184.x, _e184.y, 0.0, 6.0); - let _e199 = textureSampleGrad(tex2D, samp, (_e189.xyz / vec3(_e189.w)).xy, vec2(4.0), vec2(4.0)); - c_2 = _e199; - let _e200 = coord_5; - let _e211 = coord_5; - let _e215 = vec3(_e211.x, _e211.y, 6.0); - let _e226 = textureSampleGrad(tex2D, samp, (_e215.xy / vec2(_e215.z)), vec2(4.0), vec2(4.0), vec2(5, 5)); - c_2 = _e226; - let _e227 = coord_5; - let _e239 = coord_5; - let _e244 = vec4(_e239.x, _e239.y, 0.0, 6.0); - let _e256 = textureSampleGrad(tex2D, samp, (_e244.xyz / vec3(_e244.w)).xy, vec2(4.0), vec2(4.0), vec2(5, 5)); - c_2 = _e256; - let _e257 = coord_5; + let _e126 = coord_5; + let _e130 = vec3(_e126.x, _e126.y, 6.0); + let _e136 = textureSampleBias(tex2D, samp, (_e130.xy / vec2(_e130.z)), 2.0); + c_2 = _e136; + let _e137 = coord_5; + let _e144 = coord_5; + let _e149 = vec4(_e144.x, _e144.y, 0.0, 6.0); + let _e156 = textureSampleBias(tex2D, samp, (_e149.xyz / vec3(_e149.w)).xy, 2.0); + c_2 = _e156; + let _e157 = coord_5; + let _e166 = coord_5; + let _e170 = vec3(_e166.x, _e166.y, 6.0); + let _e179 = textureSampleGrad(tex2D, samp, (_e170.xy / vec2(_e170.z)), vec2(4.0), vec2(4.0)); + c_2 = _e179; + let _e180 = coord_5; + let _e190 = coord_5; + let _e195 = vec4(_e190.x, _e190.y, 0.0, 6.0); + let _e205 = textureSampleGrad(tex2D, samp, (_e195.xyz / vec3(_e195.w)).xy, vec2(4.0), vec2(4.0)); + c_2 = _e205; + let _e206 = coord_5; + let _e217 = coord_5; + let _e221 = vec3(_e217.x, _e217.y, 6.0); + let _e232 = textureSampleGrad(tex2D, samp, (_e221.xy / vec2(_e221.z)), vec2(4.0), vec2(4.0), vec2(5, 5)); + c_2 = _e232; + let _e233 = coord_5; + let _e245 = coord_5; + let _e250 = vec4(_e245.x, _e245.y, 0.0, 6.0); + let _e262 = textureSampleGrad(tex2D, samp, (_e250.xyz / vec3(_e250.w)).xy, vec2(4.0), vec2(4.0), vec2(5, 5)); + c_2 = _e262; let _e263 = coord_5; - let _e267 = vec3(_e263.x, _e263.y, 6.0); - let _e273 = textureSampleLevel(tex2D, samp, (_e267.xy / vec2(_e267.z)), 3.0); - c_2 = _e273; - let _e274 = coord_5; - let _e281 = coord_5; - let _e286 = vec4(_e281.x, _e281.y, 0.0, 6.0); - let _e293 = textureSampleLevel(tex2D, samp, (_e286.xyz / vec3(_e286.w)).xy, 3.0); - c_2 = _e293; - let _e294 = coord_5; - let _e302 = coord_5; - let _e306 = vec3(_e302.x, _e302.y, 6.0); - let _e314 = textureSampleLevel(tex2D, samp, (_e306.xy / vec2(_e306.z)), 3.0, vec2(5, 5)); - c_2 = _e314; - let _e315 = coord_5; - let _e324 = coord_5; - let _e329 = vec4(_e324.x, _e324.y, 0.0, 6.0); - let _e338 = textureSampleLevel(tex2D, samp, (_e329.xyz / vec3(_e329.w)).xy, 3.0, vec2(5, 5)); - c_2 = _e338; - let _e339 = coord_5; - let _e346 = coord_5; - let _e350 = vec3(_e346.x, _e346.y, 6.0); - let _e357 = textureSample(tex2D, samp, (_e350.xy / vec2(_e350.z)), vec2(5, 5)); - c_2 = _e357; - let _e358 = coord_5; - let _e366 = coord_5; - let _e371 = vec4(_e366.x, _e366.y, 0.0, 6.0); - let _e379 = textureSample(tex2D, samp, (_e371.xyz / vec3(_e371.w)).xy, vec2(5, 5)); - c_2 = _e379; - let _e380 = coord_5; - let _e388 = coord_5; - let _e392 = vec3(_e388.x, _e388.y, 6.0); - let _e400 = textureSampleBias(tex2D, samp, (_e392.xy / vec2(_e392.z)), 2.0, vec2(5, 5)); - c_2 = _e400; - let _e401 = coord_5; - let _e410 = coord_5; - let _e415 = vec4(_e410.x, _e410.y, 0.0, 6.0); - let _e424 = textureSampleBias(tex2D, samp, (_e415.xyz / vec3(_e415.w)).xy, 2.0, vec2(5, 5)); - c_2 = _e424; + let _e269 = coord_5; + let _e273 = vec3(_e269.x, _e269.y, 6.0); + let _e279 = textureSampleLevel(tex2D, samp, (_e273.xy / vec2(_e273.z)), 3.0); + c_2 = _e279; + let _e280 = coord_5; + let _e287 = coord_5; + let _e292 = vec4(_e287.x, _e287.y, 0.0, 6.0); + let _e299 = textureSampleLevel(tex2D, samp, (_e292.xyz / vec3(_e292.w)).xy, 3.0); + c_2 = _e299; + let _e300 = coord_5; + let _e308 = coord_5; + let _e312 = vec3(_e308.x, _e308.y, 6.0); + let _e320 = textureSampleLevel(tex2D, samp, (_e312.xy / vec2(_e312.z)), 3.0, vec2(5, 5)); + c_2 = _e320; + let _e321 = coord_5; + let _e330 = coord_5; + let _e335 = vec4(_e330.x, _e330.y, 0.0, 6.0); + let _e344 = textureSampleLevel(tex2D, samp, (_e335.xyz / vec3(_e335.w)).xy, 3.0, vec2(5, 5)); + c_2 = _e344; + let _e345 = coord_5; + let _e352 = coord_5; + let _e356 = vec3(_e352.x, _e352.y, 6.0); + let _e363 = textureSample(tex2D, samp, (_e356.xy / vec2(_e356.z)), vec2(5, 5)); + c_2 = _e363; + let _e364 = coord_5; + let _e372 = coord_5; + let _e377 = vec4(_e372.x, _e372.y, 0.0, 6.0); + let _e385 = textureSample(tex2D, samp, (_e377.xyz / vec3(_e377.w)).xy, vec2(5, 5)); + c_2 = _e385; + let _e386 = coord_5; + let _e394 = coord_5; + let _e398 = vec3(_e394.x, _e394.y, 6.0); + let _e406 = textureSampleBias(tex2D, samp, (_e398.xy / vec2(_e398.z)), 2.0, vec2(5, 5)); + c_2 = _e406; + let _e407 = coord_5; + let _e416 = coord_5; + let _e421 = vec4(_e416.x, _e416.y, 0.0, 6.0); + let _e430 = textureSampleBias(tex2D, samp, (_e421.xyz / vec3(_e421.w)).xy, 2.0, vec2(5, 5)); + c_2 = _e430; + let _e431 = coord_5; + let _e434 = coord_5; + let _e437 = textureLoad(tex2D, vec2(_e434), 3); + c_2 = _e437; return; } fn testTex2DShadow(coord_6: vec2) { var coord_7: vec2; + var size2DShadow: vec2; var d: f32; coord_7 = coord_6; - let _e17 = coord_7; - let _e22 = coord_7; - let _e26 = vec3(_e22.x, _e22.y, 1.0); - let _e29 = textureSampleCompare(tex2DShadow, sampShadow, _e26.xy, _e26.z); - d = _e29; - let _e30 = coord_7; - let _e39 = coord_7; - let _e43 = vec3(_e39.x, _e39.y, 1.0); - let _e50 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e43.xy, _e43.z); - d = _e50; - let _e51 = coord_7; - let _e62 = coord_7; - let _e66 = vec3(_e62.x, _e62.y, 1.0); - let _e75 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e66.xy, _e66.z, vec2(5, 5)); - d = _e75; - let _e76 = coord_7; + let _e20 = textureDimensions(tex2DShadow, 0); + size2DShadow = _e20; + let _e23 = coord_7; + let _e28 = coord_7; + let _e32 = vec3(_e28.x, _e28.y, 1.0); + let _e35 = textureSampleCompare(tex2DShadow, sampShadow, _e32.xy, _e32.z); + d = _e35; + let _e36 = coord_7; + let _e45 = coord_7; + let _e49 = vec3(_e45.x, _e45.y, 1.0); + let _e56 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e49.xy, _e49.z); + d = _e56; + let _e57 = coord_7; + let _e68 = coord_7; + let _e72 = vec3(_e68.x, _e68.y, 1.0); + let _e81 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e72.xy, _e72.z, vec2(5, 5)); + d = _e81; let _e82 = coord_7; - let _e86 = vec3(_e82.x, _e82.y, 1.0); - let _e90 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e86.xy, _e86.z); - d = _e90; - let _e91 = coord_7; - let _e99 = coord_7; - let _e103 = vec3(_e99.x, _e99.y, 1.0); - let _e109 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e103.xy, _e103.z, vec2(5, 5)); - d = _e109; - let _e110 = coord_7; - let _e117 = coord_7; - let _e121 = vec3(_e117.x, _e117.y, 1.0); - let _e126 = textureSampleCompare(tex2DShadow, sampShadow, _e121.xy, _e121.z, vec2(5, 5)); - d = _e126; - let _e127 = coord_7; + let _e88 = coord_7; + let _e92 = vec3(_e88.x, _e88.y, 1.0); + let _e96 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e92.xy, _e92.z); + d = _e96; + let _e97 = coord_7; + let _e105 = coord_7; + let _e109 = vec3(_e105.x, _e105.y, 1.0); + let _e115 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e109.xy, _e109.z, vec2(5, 5)); + d = _e115; + let _e116 = coord_7; + let _e123 = coord_7; + let _e127 = vec3(_e123.x, _e123.y, 1.0); + let _e132 = textureSampleCompare(tex2DShadow, sampShadow, _e127.xy, _e127.z, vec2(5, 5)); + d = _e132; let _e133 = coord_7; - let _e138 = vec4(_e133.x, _e133.y, 1.0, 6.0); - let _e142 = (_e138.xyz / vec3(_e138.w)); - let _e145 = textureSampleCompare(tex2DShadow, sampShadow, _e142.xy, _e142.z); - d = _e145; - let _e146 = coord_7; - let _e156 = coord_7; - let _e161 = vec4(_e156.x, _e156.y, 1.0, 6.0); - let _e169 = (_e161.xyz / vec3(_e161.w)); - let _e172 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e169.xy, _e169.z); - d = _e172; - let _e173 = coord_7; - let _e185 = coord_7; - let _e190 = vec4(_e185.x, _e185.y, 1.0, 6.0); - let _e200 = (_e190.xyz / vec3(_e190.w)); - let _e203 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e200.xy, _e200.z, vec2(5, 5)); - d = _e203; - let _e204 = coord_7; - let _e211 = coord_7; - let _e216 = vec4(_e211.x, _e211.y, 1.0, 6.0); - let _e221 = (_e216.xyz / vec3(_e216.w)); - let _e224 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e221.xy, _e221.z); - d = _e224; - let _e225 = coord_7; - let _e234 = coord_7; - let _e239 = vec4(_e234.x, _e234.y, 1.0, 6.0); - let _e246 = (_e239.xyz / vec3(_e239.w)); - let _e249 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e246.xy, _e246.z, vec2(5, 5)); - d = _e249; - let _e250 = coord_7; - let _e258 = coord_7; - let _e263 = vec4(_e258.x, _e258.y, 1.0, 6.0); - let _e269 = (_e263.xyz / vec3(_e263.w)); - let _e272 = textureSampleCompare(tex2DShadow, sampShadow, _e269.xy, _e269.z, vec2(5, 5)); - d = _e272; + let _e139 = coord_7; + let _e144 = vec4(_e139.x, _e139.y, 1.0, 6.0); + let _e148 = (_e144.xyz / vec3(_e144.w)); + let _e151 = textureSampleCompare(tex2DShadow, sampShadow, _e148.xy, _e148.z); + d = _e151; + let _e152 = coord_7; + let _e162 = coord_7; + let _e167 = vec4(_e162.x, _e162.y, 1.0, 6.0); + let _e175 = (_e167.xyz / vec3(_e167.w)); + let _e178 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e175.xy, _e175.z); + d = _e178; + let _e179 = coord_7; + let _e191 = coord_7; + let _e196 = vec4(_e191.x, _e191.y, 1.0, 6.0); + let _e206 = (_e196.xyz / vec3(_e196.w)); + let _e209 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e206.xy, _e206.z, vec2(5, 5)); + d = _e209; + let _e210 = coord_7; + let _e217 = coord_7; + let _e222 = vec4(_e217.x, _e217.y, 1.0, 6.0); + let _e227 = (_e222.xyz / vec3(_e222.w)); + let _e230 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e227.xy, _e227.z); + d = _e230; + let _e231 = coord_7; + let _e240 = coord_7; + let _e245 = vec4(_e240.x, _e240.y, 1.0, 6.0); + let _e252 = (_e245.xyz / vec3(_e245.w)); + let _e255 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e252.xy, _e252.z, vec2(5, 5)); + d = _e255; + let _e256 = coord_7; + let _e264 = coord_7; + let _e269 = vec4(_e264.x, _e264.y, 1.0, 6.0); + let _e275 = (_e269.xyz / vec3(_e269.w)); + let _e278 = textureSampleCompare(tex2DShadow, sampShadow, _e275.xy, _e275.z, vec2(5, 5)); + d = _e278; return; } fn testTex2DArray(coord_8: vec3) { var coord_9: vec3; + var size2DArray: vec3; var c_3: vec4; coord_9 = coord_8; - let _e18 = coord_9; - let _e22 = textureSample(tex2DArray, samp, _e18.xy, i32(_e18.z)); - c_3 = _e22; - let _e25 = coord_9; - let _e30 = textureSampleBias(tex2DArray, samp, _e25.xy, i32(_e25.z), 2.0); - c_3 = _e30; - let _e36 = coord_9; - let _e44 = textureSampleGrad(tex2DArray, samp, _e36.xy, i32(_e36.z), vec2(4.0), vec2(4.0)); - c_3 = _e44; - let _e52 = coord_9; - let _e62 = textureSampleGrad(tex2DArray, samp, _e52.xy, i32(_e52.z), vec2(4.0), vec2(4.0), vec2(5, 5)); - c_3 = _e62; - let _e65 = coord_9; - let _e70 = textureSampleLevel(tex2DArray, samp, _e65.xy, i32(_e65.z), 3.0); - c_3 = _e70; + let _e20 = textureDimensions(tex2DArray, 0); + let _e23 = textureNumLayers(tex2DArray); + size2DArray = vec3(_e20.x, _e20.y, _e23); + let _e28 = coord_9; + let _e32 = textureSample(tex2DArray, samp, _e28.xy, i32(_e28.z)); + c_3 = _e32; + let _e35 = coord_9; + let _e40 = textureSampleBias(tex2DArray, samp, _e35.xy, i32(_e35.z), 2.0); + c_3 = _e40; + let _e46 = coord_9; + let _e54 = textureSampleGrad(tex2DArray, samp, _e46.xy, i32(_e46.z), vec2(4.0), vec2(4.0)); + c_3 = _e54; + let _e62 = coord_9; + let _e72 = textureSampleGrad(tex2DArray, samp, _e62.xy, i32(_e62.z), vec2(4.0), vec2(4.0), vec2(5, 5)); + c_3 = _e72; let _e75 = coord_9; - let _e82 = textureSampleLevel(tex2DArray, samp, _e75.xy, i32(_e75.z), 3.0, vec2(5, 5)); - c_3 = _e82; - let _e86 = coord_9; - let _e92 = textureSample(tex2DArray, samp, _e86.xy, i32(_e86.z), vec2(5, 5)); + let _e80 = textureSampleLevel(tex2DArray, samp, _e75.xy, i32(_e75.z), 3.0); + c_3 = _e80; + let _e85 = coord_9; + let _e92 = textureSampleLevel(tex2DArray, samp, _e85.xy, i32(_e85.z), 3.0, vec2(5, 5)); c_3 = _e92; - let _e97 = coord_9; - let _e104 = textureSampleBias(tex2DArray, samp, _e97.xy, i32(_e97.z), 2.0, vec2(5, 5)); - c_3 = _e104; + let _e96 = coord_9; + let _e102 = textureSample(tex2DArray, samp, _e96.xy, i32(_e96.z), vec2(5, 5)); + c_3 = _e102; + let _e107 = coord_9; + let _e114 = textureSampleBias(tex2DArray, samp, _e107.xy, i32(_e107.z), 2.0, vec2(5, 5)); + c_3 = _e114; + let _e115 = coord_9; + let _e118 = coord_9; + let _e119 = vec3(_e118); + let _e123 = textureLoad(tex2DArray, _e119.xy, _e119.z, 3); + c_3 = _e123; return; } fn testTex2DArrayShadow(coord_10: vec3) { var coord_11: vec3; + var size2DArrayShadow: vec3; var d_1: f32; coord_11 = coord_10; - let _e17 = coord_11; - let _e23 = coord_11; - let _e28 = vec4(_e23.x, _e23.y, _e23.z, 1.0); - let _e33 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e28.xy, i32(_e28.z), _e28.w); - d_1 = _e33; - let _e34 = coord_11; + let _e20 = textureDimensions(tex2DArrayShadow, 0); + let _e23 = textureNumLayers(tex2DArrayShadow); + size2DArrayShadow = vec3(_e20.x, _e20.y, _e23); + let _e27 = coord_11; + let _e33 = coord_11; + let _e38 = vec4(_e33.x, _e33.y, _e33.z, 1.0); + let _e43 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e38.xy, i32(_e38.z), _e38.w); + d_1 = _e43; let _e44 = coord_11; - let _e49 = vec4(_e44.x, _e44.y, _e44.z, 1.0); - let _e58 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e49.xy, i32(_e49.z), _e49.w); - d_1 = _e58; - let _e59 = coord_11; - let _e71 = coord_11; - let _e76 = vec4(_e71.x, _e71.y, _e71.z, 1.0); - let _e87 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e76.xy, i32(_e76.z), _e76.w, vec2(5, 5)); - d_1 = _e87; - let _e88 = coord_11; - let _e95 = coord_11; - let _e100 = vec4(_e95.x, _e95.y, _e95.z, 1.0); - let _e106 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e100.xy, i32(_e100.z), _e100.w); - d_1 = _e106; - let _e107 = coord_11; - let _e116 = coord_11; - let _e121 = vec4(_e116.x, _e116.y, _e116.z, 1.0); - let _e129 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e121.xy, i32(_e121.z), _e121.w, vec2(5, 5)); - d_1 = _e129; - let _e130 = coord_11; - let _e138 = coord_11; - let _e143 = vec4(_e138.x, _e138.y, _e138.z, 1.0); - let _e150 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e143.xy, i32(_e143.z), _e143.w, vec2(5, 5)); - d_1 = _e150; + let _e54 = coord_11; + let _e59 = vec4(_e54.x, _e54.y, _e54.z, 1.0); + let _e68 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e59.xy, i32(_e59.z), _e59.w); + d_1 = _e68; + let _e69 = coord_11; + let _e81 = coord_11; + let _e86 = vec4(_e81.x, _e81.y, _e81.z, 1.0); + let _e97 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e86.xy, i32(_e86.z), _e86.w, vec2(5, 5)); + d_1 = _e97; + let _e98 = coord_11; + let _e106 = coord_11; + let _e111 = vec4(_e106.x, _e106.y, _e106.z, 1.0); + let _e118 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e111.xy, i32(_e111.z), _e111.w, vec2(5, 5)); + d_1 = _e118; return; } fn testTexCube(coord_12: vec3) { var coord_13: vec3; + var sizeCube: vec2; var c_4: vec4; coord_13 = coord_12; - let _e18 = coord_13; - let _e19 = textureSample(texCube, samp, _e18); - c_4 = _e19; - let _e22 = coord_13; - let _e24 = textureSampleBias(texCube, samp, _e22, 2.0); - c_4 = _e24; - let _e30 = coord_13; - let _e35 = textureSampleGrad(texCube, samp, _e30, vec3(4.0), vec3(4.0)); - c_4 = _e35; - let _e38 = coord_13; - let _e40 = textureSampleLevel(texCube, samp, _e38, 3.0); - c_4 = _e40; - let _e45 = coord_13; - let _e49 = textureSampleLevel(texCube, samp, _e45, 3.0, vec3(5, 5, 5)); - c_4 = _e49; - let _e53 = coord_13; - let _e56 = textureSample(texCube, samp, _e53, vec3(5, 5, 5)); - c_4 = _e56; - let _e61 = coord_13; - let _e65 = textureSampleBias(texCube, samp, _e61, 2.0, vec3(5, 5, 5)); - c_4 = _e65; + let _e20 = textureDimensions(texCube, 0); + sizeCube = _e20; + let _e24 = coord_13; + let _e25 = textureSample(texCube, samp, _e24); + c_4 = _e25; + let _e28 = coord_13; + let _e30 = textureSampleBias(texCube, samp, _e28, 2.0); + c_4 = _e30; + let _e36 = coord_13; + let _e41 = textureSampleGrad(texCube, samp, _e36, vec3(4.0), vec3(4.0)); + c_4 = _e41; + let _e44 = coord_13; + let _e46 = textureSampleLevel(texCube, samp, _e44, 3.0); + c_4 = _e46; return; } fn testTexCubeShadow(coord_14: vec3) { var coord_15: vec3; + var sizeCubeShadow: vec2; var d_2: f32; coord_15 = coord_14; - let _e17 = coord_15; + let _e20 = textureDimensions(texCubeShadow, 0); + sizeCubeShadow = _e20; let _e23 = coord_15; - let _e28 = vec4(_e23.x, _e23.y, _e23.z, 1.0); - let _e31 = textureSampleCompare(texCubeShadow, sampShadow, _e28.xyz, _e28.w); - d_2 = _e31; - let _e32 = coord_15; - let _e42 = coord_15; - let _e47 = vec4(_e42.x, _e42.y, _e42.z, 1.0); - let _e54 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e47.xyz, _e47.w); - d_2 = _e54; - let _e55 = coord_15; - let _e62 = coord_15; - let _e67 = vec4(_e62.x, _e62.y, _e62.z, 1.0); - let _e71 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e67.xyz, _e67.w); - d_2 = _e71; - let _e72 = coord_15; - let _e81 = coord_15; - let _e86 = vec4(_e81.x, _e81.y, _e81.z, 1.0); - let _e92 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e86.xyz, _e86.w, vec3(5, 5, 5)); - d_2 = _e92; - let _e93 = coord_15; - let _e101 = coord_15; - let _e106 = vec4(_e101.x, _e101.y, _e101.z, 1.0); - let _e111 = textureSampleCompare(texCubeShadow, sampShadow, _e106.xyz, _e106.w, vec3(5, 5, 5)); - d_2 = _e111; + let _e29 = coord_15; + let _e34 = vec4(_e29.x, _e29.y, _e29.z, 1.0); + let _e37 = textureSampleCompare(texCubeShadow, sampShadow, _e34.xyz, _e34.w); + d_2 = _e37; + let _e38 = coord_15; + let _e48 = coord_15; + let _e53 = vec4(_e48.x, _e48.y, _e48.z, 1.0); + let _e60 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e53.xyz, _e53.w); + d_2 = _e60; return; } fn testTexCubeArray(coord_16: vec4) { var coord_17: vec4; + var sizeCubeArray: vec3; var c_5: vec4; coord_17 = coord_16; - let _e18 = coord_17; - let _e22 = textureSample(texCubeArray, samp, _e18.xyz, i32(_e18.w)); - c_5 = _e22; - let _e25 = coord_17; - let _e30 = textureSampleBias(texCubeArray, samp, _e25.xyz, i32(_e25.w), 2.0); - c_5 = _e30; - let _e36 = coord_17; - let _e44 = textureSampleGrad(texCubeArray, samp, _e36.xyz, i32(_e36.w), vec3(4.0), vec3(4.0)); - c_5 = _e44; - let _e47 = coord_17; - let _e52 = textureSampleLevel(texCubeArray, samp, _e47.xyz, i32(_e47.w), 3.0); - c_5 = _e52; + let _e20 = textureDimensions(texCubeArray, 0); + let _e23 = textureNumLayers(texCubeArray); + sizeCubeArray = vec3(_e20.x, _e20.y, _e23); + let _e28 = coord_17; + let _e32 = textureSample(texCubeArray, samp, _e28.xyz, i32(_e28.w)); + c_5 = _e32; + let _e35 = coord_17; + let _e40 = textureSampleBias(texCubeArray, samp, _e35.xyz, i32(_e35.w), 2.0); + c_5 = _e40; + let _e46 = coord_17; + let _e54 = textureSampleGrad(texCubeArray, samp, _e46.xyz, i32(_e46.w), vec3(4.0), vec3(4.0)); + c_5 = _e54; let _e57 = coord_17; - let _e64 = textureSampleLevel(texCubeArray, samp, _e57.xyz, i32(_e57.w), 3.0, vec3(5, 5, 5)); - c_5 = _e64; - let _e68 = coord_17; - let _e74 = textureSample(texCubeArray, samp, _e68.xyz, i32(_e68.w), vec3(5, 5, 5)); - c_5 = _e74; - let _e79 = coord_17; - let _e86 = textureSampleBias(texCubeArray, samp, _e79.xyz, i32(_e79.w), 2.0, vec3(5, 5, 5)); - c_5 = _e86; + let _e62 = textureSampleLevel(texCubeArray, samp, _e57.xyz, i32(_e57.w), 3.0); + c_5 = _e62; return; } fn testTexCubeArrayShadow(coord_18: vec4) { var coord_19: vec4; + var sizeCubeArrayShadow: vec3; var d_3: f32; coord_19 = coord_18; - let _e19 = coord_19; - let _e24 = textureSampleCompare(texCubeArrayShadow, sampShadow, _e19.xyz, i32(_e19.w), 1.0); - d_3 = _e24; + let _e20 = textureDimensions(texCubeArrayShadow, 0); + let _e23 = textureNumLayers(texCubeArrayShadow); + sizeCubeArrayShadow = vec3(_e20.x, _e20.y, _e23); + let _e29 = coord_19; + let _e34 = textureSampleCompare(texCubeArrayShadow, sampShadow, _e29.xyz, i32(_e29.w), 1.0); + d_3 = _e34; return; } fn testTex3D(coord_20: vec3) { var coord_21: vec3; + var size3D: vec3; var c_6: vec4; coord_21 = coord_20; - let _e18 = coord_21; - let _e19 = textureSample(tex3D, samp, _e18); - c_6 = _e19; - let _e22 = coord_21; - let _e24 = textureSampleBias(tex3D, samp, _e22, 2.0); - c_6 = _e24; - let _e30 = coord_21; - let _e35 = textureSampleGrad(tex3D, samp, _e30, vec3(4.0), vec3(4.0)); - c_6 = _e35; - let _e43 = coord_21; - let _e50 = textureSampleGrad(tex3D, samp, _e43, vec3(4.0), vec3(4.0), vec3(5, 5, 5)); - c_6 = _e50; - let _e53 = coord_21; - let _e55 = textureSampleLevel(tex3D, samp, _e53, 3.0); - c_6 = _e55; - let _e60 = coord_21; - let _e64 = textureSampleLevel(tex3D, samp, _e60, 3.0, vec3(5, 5, 5)); - c_6 = _e64; - let _e68 = coord_21; - let _e71 = textureSample(tex3D, samp, _e68, vec3(5, 5, 5)); - c_6 = _e71; - let _e76 = coord_21; - let _e80 = textureSampleBias(tex3D, samp, _e76, 2.0, vec3(5, 5, 5)); - c_6 = _e80; + let _e20 = textureDimensions(tex3D, 0); + size3D = _e20; + let _e24 = coord_21; + let _e25 = textureSample(tex3D, samp, _e24); + c_6 = _e25; + let _e28 = coord_21; + let _e30 = textureSampleBias(tex3D, samp, _e28, 2.0); + c_6 = _e30; + let _e31 = coord_21; + let _e37 = coord_21; + let _e42 = vec4(_e37.x, _e37.y, _e37.z, 6.0); + let _e47 = textureSample(tex3D, samp, (_e42.xyz / vec3(_e42.w))); + c_6 = _e47; + let _e48 = coord_21; + let _e55 = coord_21; + let _e60 = vec4(_e55.x, _e55.y, _e55.z, 6.0); + let _e66 = textureSampleBias(tex3D, samp, (_e60.xyz / vec3(_e60.w)), 2.0); + c_6 = _e66; + let _e67 = coord_21; + let _e75 = coord_21; + let _e80 = vec4(_e75.x, _e75.y, _e75.z, 6.0); + let _e87 = textureSample(tex3D, samp, (_e80.xyz / vec3(_e80.w)), vec3(5, 5, 5)); + c_6 = _e87; + let _e88 = coord_21; + let _e97 = coord_21; + let _e102 = vec4(_e97.x, _e97.y, _e97.z, 6.0); + let _e110 = textureSampleBias(tex3D, samp, (_e102.xyz / vec3(_e102.w)), 2.0, vec3(5, 5, 5)); + c_6 = _e110; + let _e111 = coord_21; + let _e118 = coord_21; + let _e123 = vec4(_e118.x, _e118.y, _e118.z, 6.0); + let _e129 = textureSampleLevel(tex3D, samp, (_e123.xyz / vec3(_e123.w)), 3.0); + c_6 = _e129; + let _e130 = coord_21; + let _e139 = coord_21; + let _e144 = vec4(_e139.x, _e139.y, _e139.z, 6.0); + let _e152 = textureSampleLevel(tex3D, samp, (_e144.xyz / vec3(_e144.w)), 3.0, vec3(5, 5, 5)); + c_6 = _e152; + let _e153 = coord_21; + let _e163 = coord_21; + let _e168 = vec4(_e163.x, _e163.y, _e163.z, 6.0); + let _e177 = textureSampleGrad(tex3D, samp, (_e168.xyz / vec3(_e168.w)), vec3(4.0), vec3(4.0)); + c_6 = _e177; + let _e178 = coord_21; + let _e190 = coord_21; + let _e195 = vec4(_e190.x, _e190.y, _e190.z, 6.0); + let _e206 = textureSampleGrad(tex3D, samp, (_e195.xyz / vec3(_e195.w)), vec3(4.0), vec3(4.0), vec3(5, 5, 5)); + c_6 = _e206; + let _e212 = coord_21; + let _e217 = textureSampleGrad(tex3D, samp, _e212, vec3(4.0), vec3(4.0)); + c_6 = _e217; + let _e225 = coord_21; + let _e232 = textureSampleGrad(tex3D, samp, _e225, vec3(4.0), vec3(4.0), vec3(5, 5, 5)); + c_6 = _e232; + let _e235 = coord_21; + let _e237 = textureSampleLevel(tex3D, samp, _e235, 3.0); + c_6 = _e237; + let _e242 = coord_21; + let _e246 = textureSampleLevel(tex3D, samp, _e242, 3.0, vec3(5, 5, 5)); + c_6 = _e246; + let _e250 = coord_21; + let _e253 = textureSample(tex3D, samp, _e250, vec3(5, 5, 5)); + c_6 = _e253; + let _e258 = coord_21; + let _e262 = textureSampleBias(tex3D, samp, _e258, 2.0, vec3(5, 5, 5)); + c_6 = _e262; + let _e263 = coord_21; + let _e266 = coord_21; + let _e269 = textureLoad(tex3D, vec3(_e266), 3); + c_6 = _e269; + return; +} + +fn testTex2DMS(coord_22: vec2) { + var coord_23: vec2; + var size2DMS: vec2; + var c_7: vec4; + + coord_23 = coord_22; + let _e18 = textureDimensions(tex2DMS); + size2DMS = _e18; + let _e21 = coord_23; + let _e24 = coord_23; + let _e27 = textureLoad(tex2DMS, vec2(_e24), 3); + c_7 = _e27; + return; +} + +fn testTex2DMSArray(coord_24: vec3) { + var coord_25: vec3; + var size2DMSArray: vec3; + var c_8: vec4; + + coord_25 = coord_24; + let _e18 = textureDimensions(tex2DMSArray); + let _e21 = textureNumLayers(tex2DMSArray); + size2DMSArray = vec3(_e18.x, _e18.y, _e21); + let _e25 = coord_25; + let _e28 = coord_25; + let _e29 = vec3(_e28); + let _e33 = textureLoad(tex2DMSArray, _e29.xy, _e29.z, 3); + c_8 = _e33; return; } @@ -567,8 +659,7 @@ fn main_1() { } @stage(fragment) -fn main(@location(0) texcoord: vec4) { - texcoord_1 = texcoord; +fn main() { main_1(); return; }