glsl: Implement Images

src/shader_recompiler/backend/glsl/emit_context.cpp

@@ -91,11 +91,42 @@ std::string_view SamplerType(TextureType type, bool is_depth) {
     case TextureType::Buffer:
         return "samplerBuffer";
     default:
-        fmt::print("Texture type: {}", type);
         throw NotImplementedException("Texture type: {}", type);
     }
 }
 
+std::string_view ImageType(TextureType type) {
+    switch (type) {
+    case TextureType::Color2D:
+        return "uimage2D";
+    default:
+        throw NotImplementedException("Image type: {}", type);
+    }
+}
+
+std::string_view ImageFormatString(ImageFormat format) {
+    switch (format) {
+    case ImageFormat::Typeless:
+        return "";
+    case ImageFormat::R8_UINT:
+        return ",r8ui";
+    case ImageFormat::R8_SINT:
+        return ",r8i";
+    case ImageFormat::R16_UINT:
+        return ",r16ui";
+    case ImageFormat::R16_SINT:
+        return ",r16i";
+    case ImageFormat::R32_UINT:
+        return ",r32ui";
+    case ImageFormat::R32G32_UINT:
+        return ",rg32ui";
+    case ImageFormat::R32G32B32A32_UINT:
+        return ",rgba32ui";
+    default:
+        throw NotImplementedException("Image format: {}", format);
+    }
+}
+
 std::string_view GetTessMode(TessPrimitive primitive) {
     switch (primitive) {
     case TessPrimitive::Triangles:
@@ -250,6 +281,7 @@ void EmitContext::SetupExtensions(std::string&) {
     // TODO: track this usage
     header += "#extension GL_ARB_sparse_texture2 : enable\n";
     header += "#extension GL_EXT_texture_shadow_lod : enable\n";
+    header += "#extension GL_EXT_shader_image_load_formatted : enable\n";
     if (info.uses_int64) {
         header += "#extension GL_ARB_gpu_shader_int64 : enable\n";
     }
@@ -396,15 +428,25 @@ void EmitContext::DefineHelperFunctions() {
 void EmitContext::SetupImages(Bindings& bindings) {
     image_buffer_bindings.reserve(info.image_buffer_descriptors.size());
     for (const auto& desc : info.image_buffer_descriptors) {
-        throw NotImplementedException("image_buffer_descriptors");
+        const auto indices{bindings.image + desc.count};
+        for (u32 index = bindings.image; index < indices; ++index) {
+            header += fmt::format("layout(binding={}) uniform uimageBuffer img{};", bindings.image,
+                                  index);
+        }
         image_buffer_bindings.push_back(bindings.image);
         bindings.image += desc.count;
     }
     image_bindings.reserve(info.image_descriptors.size());
     for (const auto& desc : info.image_descriptors) {
-        throw NotImplementedException("image_bindings");
-
         image_bindings.push_back(bindings.image);
+        const auto format{ImageFormatString(desc.format)};
+        const auto image_type{ImageType(desc.type)};
+        const auto qualifier{desc.is_written ? "" : "readonly "};
+        const auto indices{bindings.image + desc.count};
+        for (u32 index = bindings.image; index < indices; ++index) {
+            header += fmt::format("layout(binding={}{})uniform {}{} img{};", bindings.image, format,
+                                  qualifier, image_type, index);
+        }
         bindings.image += desc.count;
     }
     texture_buffer_bindings.reserve(info.texture_buffer_descriptors.size());

src/shader_recompiler/backend/glsl/emit_glsl_image.cpp

@@ -14,15 +14,25 @@ namespace {
 std::string Texture(EmitContext& ctx, const IR::TextureInstInfo& info,
                     [[maybe_unused]] const IR::Value& index) {
     if (info.type == TextureType::Buffer) {
-        throw NotImplementedException("TextureType::Buffer");
+        return fmt::format("tex{}", ctx.texture_buffer_bindings.at(info.descriptor_index));
     } else {
         return fmt::format("tex{}", ctx.texture_bindings.at(info.descriptor_index));
     }
 }
 
+std::string Image(EmitContext& ctx, const IR::TextureInstInfo& info,
+                  [[maybe_unused]] const IR::Value& index) {
+    if (info.type == TextureType::Buffer) {
+        return fmt::format("img{}", ctx.image_buffer_bindings.at(info.descriptor_index));
+    } else {
+        return fmt::format("img{}", ctx.image_bindings.at(info.descriptor_index));
+    }
+}
+
 std::string CastToIntVec(std::string_view value, const IR::TextureInstInfo& info) {
     switch (info.type) {
     case TextureType::Color1D:
+    case TextureType::Buffer:
         return fmt::format("int({})", value);
     case TextureType::ColorArray1D:
     case TextureType::Color2D:
@@ -41,6 +51,7 @@ std::string CastToIntVec(std::string_view value, const IR::TextureInstInfo& info
 std::string TexelFetchCastToInt(std::string_view value, const IR::TextureInstInfo& info) {
     switch (info.type) {
     case TextureType::Color1D:
+    case TextureType::Buffer:
         return fmt::format("int({})", value);
     case TextureType::ColorArray1D:
     case TextureType::Color2D:
@@ -349,8 +360,12 @@ void EmitImageFetch([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst
             ctx.Add("{}=texelFetchOffset({},{},int({}),{});", texel, texture,
                     TexelFetchCastToInt(coords, info), lod, TexelFetchCastToInt(offset, info));
         } else {
-            ctx.Add("{}=texelFetch({},{},int({}));", texel, texture,
+            if (info.type == TextureType::Buffer) {
-                    TexelFetchCastToInt(coords, info), lod);
+                ctx.Add("{}=texelFetch({},int({}));", texel, texture, coords);
+            } else {
+                ctx.Add("{}=texelFetch({},{},int({}));", texel, texture,
+                        TexelFetchCastToInt(coords, info), lod);
+            }
         }
         return;
     }
@@ -434,14 +449,22 @@ void EmitImageGradient([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::I
 void EmitImageRead([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
                    [[maybe_unused]] const IR::Value& index,
                    [[maybe_unused]] std::string_view coords) {
-    NotImplemented();
+    const auto info{inst.Flags<IR::TextureInstInfo>()};
+    const auto sparse_inst{PrepareSparse(inst)};
+    if (sparse_inst) {
+        throw NotImplementedException("EmitImageRead Sparse");
+    }
+    const auto image{Image(ctx, info, index)};
+    ctx.AddU32x4("{}=uvec4(imageLoad({},{}));", inst, image, TexelFetchCastToInt(coords, info));
 }
 
 void EmitImageWrite([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
                     [[maybe_unused]] const IR::Value& index,
                     [[maybe_unused]] std::string_view coords,
                     [[maybe_unused]] std::string_view color) {
-    NotImplemented();
+    const auto info{inst.Flags<IR::TextureInstInfo>()};
+    const auto image{Image(ctx, info, index)};
+    ctx.Add("imageStore({},{},{});", image, TexelFetchCastToInt(coords, info), color);
 }
 
 void EmitBindlessImageSampleImplicitLod(EmitContext&) {