glsl-in: Add tests for images

tests/in/glsl/images.frag

@@ -0,0 +1,57 @@
+#version 460 core
+
+layout(rgba8, binding = 0) uniform image1D img1D;
+layout(rgba8, binding = 1) uniform image2D img2D;
+layout(rgba8, binding = 2) uniform image3D img3D;
+layout(rgba8, binding = 3) uniform imageCube imgCube;
+layout(rgba8, binding = 4) uniform image1DArray img1DArray;
+layout(rgba8, binding = 5) uniform image2DArray img2DArray;
+layout(rgba8, binding = 6) uniform imageCubeArray imgCubeArray;
+
+void testImg1D(in int coord) {
+    int size = imageSize(img1D);
+    vec4 c = imageLoad(img1D, coord);
+    imageStore(img1D, coord, vec4(2));
+}
+
+void testImg1DArray(in ivec2 coord) {
+    vec2 size = imageSize(img1DArray);
+    vec4 c = imageLoad(img1DArray, coord);
+    imageStore(img1DArray, coord, vec4(2));
+}
+
+void testImg2D(in ivec2 coord) {
+    vec2 size = imageSize(img2D);
+    vec4 c = imageLoad(img2D, coord);
+    imageStore(img2D, coord, vec4(2));
+}
+
+void testImg2DArray(in ivec3 coord) {
+    vec3 size = imageSize(img2DArray);
+    vec4 c = imageLoad(img2DArray, coord);
+    imageStore(img2DArray, coord, vec4(2));
+}
+
+void testImg3D(in ivec3 coord) {
+    vec3 size = imageSize(img3D);
+    vec4 c = imageLoad(img3D, coord);
+    imageStore(img3D, coord, vec4(2));
+}
+
+void testImgCube(in ivec3 coord) {
+    vec2 size = imageSize(imgCube);
+// Naga doesn't support imageLoad/Store on cube images and it's usefulness
+// is questionable, so they won't be supported for now
+//     vec4 c = imageLoad(imgCube, coord);
+//     imageStore(imgCube, coord, vec4(2));
+}
+
+void testImgCubeArray(in ivec3 coord) {
+    vec3 size = imageSize(imgCubeArray);
+// Naga doesn't support imageLoad/Store on cube images and it's usefulness
+// is questionable, so they won't be supported for now
+//     vec4 c = imageLoad(imgCubeArray, coord);
+//     imageStore(imgCubeArray, coord, vec4(2));
+}
+
+void main() {}

tests/out/wgsl/images-frag.wgsl

@@ -0,0 +1,127 @@
+@group(0) @binding(0) 
+var img1D: texture_storage_1d<rgba8unorm,read_write>;
+@group(0) @binding(1) 
+var img2D: texture_storage_2d<rgba8unorm,read_write>;
+@group(0) @binding(2) 
+var img3D: texture_storage_3d<rgba8unorm,read_write>;
+@group(0) @binding(3) 
+var imgCube: texture_storage_cube<rgba8unorm,read_write>;
+@group(0) @binding(4) 
+var img1DArray: texture_storage_1d_array<rgba8unorm,read_write>;
+@group(0) @binding(5) 
+var img2DArray: texture_storage_2d_array<rgba8unorm,read_write>;
+@group(0) @binding(6) 
+var imgCubeArray: texture_storage_cube_array<rgba8unorm,read_write>;
+
+fn testImg1D(coord: i32) {
+    var coord_1: i32;
+    var size: i32;
+    var c: vec4<f32>;
+
+    coord_1 = coord;
+    let _e9 = textureDimensions(img1D);
+    size = _e9;
+    let _e12 = coord_1;
+    let _e13 = textureLoad(img1D, _e12);
+    c = _e13;
+    let _e19 = coord_1;
+    textureStore(img1D, _e19, vec4<f32>(f32(2)));
+    return;
+}
+
+fn testImg1DArray(coord_2: vec2<i32>) {
+    var coord_3: vec2<i32>;
+    var size_1: vec2<f32>;
+    var c_1: vec4<f32>;
+
+    coord_3 = coord_2;
+    let _e9 = textureDimensions(img1DArray);
+    let _e10 = textureNumLayers(img1DArray);
+    size_1 = vec2<f32>(vec2<i32>(_e9, _e10));
+    let _e15 = coord_3;
+    let _e18 = textureLoad(img1DArray, _e15.x, _e15.y);
+    c_1 = _e18;
+    let _e24 = coord_3;
+    textureStore(img1DArray, _e24.x, _e24.y, vec4<f32>(f32(2)));
+    return;
+}
+
+fn testImg2D(coord_4: vec2<i32>) {
+    var coord_5: vec2<i32>;
+    var size_2: vec2<f32>;
+    var c_2: vec4<f32>;
+
+    coord_5 = coord_4;
+    let _e9 = textureDimensions(img2D);
+    size_2 = vec2<f32>(_e9);
+    let _e13 = coord_5;
+    let _e14 = textureLoad(img2D, _e13);
+    c_2 = _e14;
+    let _e20 = coord_5;
+    textureStore(img2D, _e20, vec4<f32>(f32(2)));
+    return;
+}
+
+fn testImg2DArray(coord_6: vec3<i32>) {
+    var coord_7: vec3<i32>;
+    var size_3: vec3<f32>;
+    var c_3: vec4<f32>;
+
+    coord_7 = coord_6;
+    let _e9 = textureDimensions(img2DArray);
+    let _e12 = textureNumLayers(img2DArray);
+    size_3 = vec3<f32>(vec3<i32>(_e9.x, _e9.y, _e12));
+    let _e17 = coord_7;
+    let _e20 = textureLoad(img2DArray, _e17.xy, _e17.z);
+    c_3 = _e20;
+    let _e26 = coord_7;
+    textureStore(img2DArray, _e26.xy, _e26.z, vec4<f32>(f32(2)));
+    return;
+}
+
+fn testImg3D(coord_8: vec3<i32>) {
+    var coord_9: vec3<i32>;
+    var size_4: vec3<f32>;
+    var c_4: vec4<f32>;
+
+    coord_9 = coord_8;
+    let _e9 = textureDimensions(img3D);
+    size_4 = vec3<f32>(_e9);
+    let _e13 = coord_9;
+    let _e14 = textureLoad(img3D, _e13);
+    c_4 = _e14;
+    let _e20 = coord_9;
+    textureStore(img3D, _e20, vec4<f32>(f32(2)));
+    return;
+}
+
+fn testImgCube(coord_10: vec3<i32>) {
+    var coord_11: vec3<i32>;
+    var size_5: vec2<f32>;
+
+    coord_11 = coord_10;
+    let _e9 = textureDimensions(imgCube);
+    size_5 = vec2<f32>(_e9);
+    return;
+}
+
+fn testImgCubeArray(coord_12: vec3<i32>) {
+    var coord_13: vec3<i32>;
+    var size_6: vec3<f32>;
+
+    coord_13 = coord_12;
+    let _e9 = textureDimensions(imgCubeArray);
+    let _e12 = textureNumLayers(imgCubeArray);
+    size_6 = vec3<f32>(vec3<i32>(_e9.x, _e9.y, _e12));
+    return;
+}
+
+fn main_1() {
+    return;
+}
+
+@stage(fragment) 
+fn main() {
+    main_1();
+    return;
+}