Add documentation and add ImageCoordinate trait

Author: XAMPPRocky

crates/rustc_codegen_spirv/src/abi.rs

@@ -810,57 +810,45 @@ fn trans_image<'tcx>(
             // Hardcode to float for now
             let sampled_type = SpirvType::Float(32).def(span, cx);
 
-            macro_rules! type_from_variant_index {
+            macro_rules! type_from_variant_discriminant {
                 ($(let $name:ident : $ty:ty = $exp:expr);+ ;) => {
-                    $(
-                        let $name = <$ty>::from_u64(
-                            cx.tcx
-                            .destructure_const(ParamEnv::reveal_all().and($exp))
-                            .variant
+                    $(let $name = {
+                        let const_ = $exp;
+                        let adt_def = const_.ty.ty_adt_def().unwrap();
+                        assert!(adt_def.is_enum());
+                        let destructured = cx.tcx.destructure_const(ParamEnv::reveal_all().and(const_));
+                        let idx = destructured.variant.unwrap();
+                        let value = const_.ty
+                            .discriminant_for_variant(cx.tcx, idx)
                             .unwrap()
-                            .as_u32() as u64,
-                        )
-                        .unwrap();
-                    )+
+                            .val as u64;
+                        <$ty>::from_u64(value).unwrap()
+                    };)+
                 }
             }
 
-            type_from_variant_index! {
+            type_from_variant_discriminant! {
                 let dim: spirv::Dim = substs.const_at(0);
                 let depth: u32 = substs.const_at(1);
                 let sampled: u32 = substs.const_at(4);
                 let image_format: spirv::ImageFormat = substs.const_at(5);
             }
 
-            let arrayed: bool = substs
-                .const_at(2)
-                .val
-                .try_to_value()
-                .unwrap()
-                .try_to_bool()
-                .unwrap();
-            let multisampled: bool = substs
-                .const_at(3)
-                .val
-                .try_to_value()
-                .unwrap()
-                .try_to_bool()
-                .unwrap();
+            let arrayed: bool = substs.const_at(2).val.try_to_bool().unwrap();
+            let multisampled: bool = substs.const_at(3).val.try_to_bool().unwrap();
             let access_qualifier = {
                 let option = cx
                     .tcx
                     .destructure_const(ParamEnv::reveal_all().and(substs.const_at(6)));
 
                 match option.variant.map(|i| i.as_u32()).unwrap_or(0) {
                     0 => None,
-                    1 => spirv::AccessQualifier::from_u64(
-                        option.fields[0]
-                            .val
-                            .try_to_scalar()
-                            .unwrap()
-                            .to_u64()
-                            .unwrap(),
-                    ),
+                    1 => {
+                        type_from_variant_discriminant! {
+                            let access_qualifier: spirv::AccessQualifier = option.fields[0];
+                        }
+                        Some(access_qualifier)
+                    },
                     _ => unreachable!(),
                 }
             };

crates/spirv-std/src/lib.rs

@@ -53,16 +53,6 @@ pub use glam;
 pub use num_traits;
 pub use textures::*;
 
-/// Marker trait for arguments that accept single scalar values or vectors
-/// of scalars.
-pub trait ScalarOrVector: sealed::Sealed {}
-
-impl ScalarOrVector for f32 {}
-impl ScalarOrVector for glam::Vec2 {}
-impl ScalarOrVector for glam::Vec3 {}
-impl ScalarOrVector for glam::Vec3A {}
-impl ScalarOrVector for glam::Vec4 {}
-
 #[cfg(all(not(test), target_arch = "spirv"))]
 #[panic_handler]
 fn panic(_: &core::panic::PanicInfo<'_>) -> ! {

crates/spirv-std/src/textures.rs

@@ -1,7 +1,6 @@
-use glam::Vec4;
-
-use crate::ScalarOrVector;
+use glam::{Vec2, Vec3, Vec3A, Vec4};
 
+/// The dimension of the image.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum Dimensionality {
     OneD = 0,
@@ -13,20 +12,35 @@ pub enum Dimensionality {
     SubpassData = 6,
 }
 
+/// Whether a given image contains [depth] information. **Note** Whether or not
+/// to perform depth comparisons is a property of the sampling code, not of this
+/// type declaration.
+///
+/// [depth]: https://en.wikipedia.org/wiki/Depth_map
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum ImageDepth {
+    /// Indicates that the image does not contain depth information.
     No = 0,
+    /// Indicates that the image contains depth information.
     Yes = 1,
+    /// Indicates that is not known ahead of time whether the image has depth
+    /// information or not.
     Unknown = 2,
 }
 
+/// Whether or not the image will be accessed in combination with a sampler.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum Sampled {
+    /// Indicates that it is not known ahead of time whether the image will use
+    /// a sampler or not.
     Unknown = 0,
+    /// The image will be used with a sampler.
     Yes = 1,
+    /// The image will not be used with a sampler.
     No = 2,
 }
 
+/// The underlying internal representation of the image.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum ImageFormat {
     Unknown = 0,
@@ -71,23 +85,32 @@ pub enum ImageFormat {
     R8ui = 39,
 }
 
+/// The access permissions for the image.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum AccessQualifier {
+    /// A read only image.
     ReadOnly = 0,
+    /// A write only image.
     WriteOnly = 1,
+    /// A readable and writable image.
     ReadWrite = 2,
 }
 
+/// Marker trait for arguments that accept single scalar values or vectors
+/// of scalars.
+pub trait ImageCoordinate<const DIM: Dimensionality>: crate::sealed::Sealed {}
+
+impl ImageCoordinate<{ Dimensionality::OneD }> for f32 {}
+impl ImageCoordinate<{ Dimensionality::TwoD }> for Vec2 {}
+impl ImageCoordinate<{ Dimensionality::ThreeD }> for Vec3 {}
+impl ImageCoordinate<{ Dimensionality::ThreeD }> for Vec3A {}
+impl ImageCoordinate<{ Dimensionality::Rect }> for Vec2 {}
+impl ImageCoordinate<{ Dimensionality::Cube }> for Vec2 {}
+impl ImageCoordinate<{ Dimensionality::Buffer }> for f32 {}
+
+/// An opaque image type. Corresponds to `OpTypeImage`.
 #[allow(unused_attributes)]
-#[spirv(image(
-    // sampled_type is hardcoded to f32 for now
-    dim = "Dim2D",
-    depth = 0,
-    arrayed = 0,
-    multisampled = 0,
-    sampled = 1,
-    image_format = "Unknown"
-))]
+#[spirv(image)]
 #[derive(Copy, Clone)]
 pub struct Image<
     const DIM: Dimensionality,
@@ -120,7 +143,7 @@ impl<
         { ACCESS_QUALIFIER },
     >
 {
-    pub fn sample(&self, sampler: Sampler, coord: impl ScalarOrVector) -> Vec4 {
+    pub fn sample(&self, sampler: Sampler, coord: impl ImageCoordinate<{ DIM }>) -> Vec4 {
         #[cfg(not(target_arch = "spirv"))]
         {
             let _ = sampler;
@@ -184,7 +207,7 @@ impl<
         >,
     >
 {
-    pub fn sample(&self, coord: impl ScalarOrVector) -> Vec4 {
+    pub fn sample(&self, coord: impl ImageCoordinate<{ DIM }>) -> Vec4 {
         #[cfg(not(target_arch = "spirv"))]
         {
             let _ = coord;

examples/shaders/sky-shader/src/lib.rs

@@ -13,7 +13,7 @@ pub extern crate spirv_std_macros;
 
 use core::f32::consts::PI;
 use shared::*;
-use spirv_std::glam::{const_vec3, vec2, vec3, Vec2, Vec3, Vec4, Vec4Swizzles};
+use spirv_std::glam::{const_vec3, vec2, vec3, Vec2, Vec3, Vec4};
 use spirv_std::storage_class::{Input, Output, PushConstant, UniformConstant};
 use spirv_std::{Dimensionality, Image, ImageDepth, ImageFormat, Sampled, Sampler};
 
@@ -160,7 +160,7 @@ pub fn fs(constants: &ShaderConstants, frag_coord: Vec2) -> Vec4 {
 #[allow(unused_attributes)]
 #[spirv(fragment)]
 pub fn main_fs(
-    #[spirv(frag_coord)] in_frag_coord: Input<Vec4>,
+    #[spirv(frag_coord)] in_frag_coord: Input<Vec2>,
     constants: PushConstant<ShaderConstants>,
     #[spirv(binding = 0)] img: UniformConstant<
         Image<