feature: SHADER-F16

naga/Cargo.toml

@@ -25,8 +25,9 @@ dot-out = []
 glsl-in = ["dep:pp-rs"]
 glsl-out = []
 msl-out = []
-serialize = ["dep:serde", "bitflags/serde", "indexmap/serde"]
-deserialize = ["dep:serde", "bitflags/serde", "indexmap/serde"]
+f16 = ["half"]
+serialize = ["dep:serde", "bitflags/serde", "indexmap/serde", "half/serde"]
+deserialize = ["dep:serde", "bitflags/serde", "indexmap/serde", "half/serde"]
 arbitrary = ["dep:arbitrary", "bitflags/arbitrary", "indexmap/arbitrary"]
 spv-in = ["dep:petgraph", "dep:spirv"]
 spv-out = ["dep:spirv"]
@@ -59,6 +60,7 @@ pp-rs = { version = "0.2.1", optional = true }
 hexf-parse = { version = "0.2.1", optional = true }
 unicode-xid = { version = "0.2.3", optional = true }
 arrayvec.workspace = true
+half = {version = "2.4.1", optional = true}
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 criterion = { version = "0.5", features = [] }

naga/src/back/glsl/mod.rs

@@ -2571,6 +2571,10 @@ impl<'a, W: Write> Writer<'a, W> {
                     // decimal part even it's zero which is needed for a valid glsl float constant
                     crate::Literal::F64(value) => write!(self.out, "{:?}LF", value)?,
                     crate::Literal::F32(value) => write!(self.out, "{:?}", value)?,
+                    #[cfg(feature = "half")]
+                    crate::Literal::F16(value) => {
+                        return Err(Error::Custom("GLSL has no 16-bit float type".into()));
+                    }
                     // Unsigned integers need a `u` at the end
                     //
                     // While `core` doesn't necessarily need it, it's allowed and since `es` needs it we

naga/src/back/hlsl/writer.rs

@@ -2236,6 +2236,8 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                 // decimal part even it's zero
                 crate::Literal::F64(value) => write!(self.out, "{value:?}L")?,
                 crate::Literal::F32(value) => write!(self.out, "{value:?}")?,
+                #[cfg(feature = "half")]
+                crate::Literal::F16(value) => write!(self.out, "{value:?}h")?,
                 crate::Literal::U32(value) => write!(self.out, "{}u", value)?,
                 crate::Literal::I32(value) => write!(self.out, "{}", value)?,
                 crate::Literal::U64(value) => write!(self.out, "{}uL", value)?,

naga/src/back/msl/writer.rs

@@ -324,8 +324,12 @@ impl crate::Scalar {
         match self {
             Self {
                 kind: Sk::Float,
-                width: _,
+                width: 4,
             } => "float",
+            Self {
+                kind: Sk::Float,
+                width: 2,
+            } => "half",
             Self {
                 kind: Sk::Sint,
                 width: 4,
@@ -1266,6 +1270,10 @@ impl<W: Write> Writer<W> {
                 crate::Literal::F64(_) => {
                     return Err(Error::CapabilityNotSupported(valid::Capabilities::FLOAT64))
                 }
+                #[cfg(feature = "half")]
+                crate::Literal::F16(_) => {
+                    return Err(Error::CapabilityNotSupported(valid::Capabilities::FLOAT16))
+                }
                 crate::Literal::F32(value) => {
                     if value.is_infinite() {
                         let sign = if value.is_sign_negative() { "-" } else { "" };

naga/src/back/wgsl/writer.rs

@@ -1211,6 +1211,8 @@ impl<W: Write> Writer<W> {
 
         match expressions[expr] {
             Expression::Literal(literal) => match literal {
+                #[cfg(feature = "half")]
+                crate::Literal::F16(value) => write!(self.out, "{}h", value)?,
                 crate::Literal::F32(value) => write!(self.out, "{}f", value)?,
                 crate::Literal::U32(value) => write!(self.out, "{}u", value)?,
                 crate::Literal::I32(value) => {
@@ -1957,6 +1959,10 @@ const fn scalar_kind_str(scalar: crate::Scalar) -> &'static str {
             kind: Sk::Float,
             width: 4,
         } => "f32",
+        Scalar {
+            kind: Sk::Float,
+            width: 2,
+        } => "f16",
         Scalar {
             kind: Sk::Sint,
             width: 4,

naga/src/front/spv/mod.rs

@@ -43,6 +43,9 @@ use crate::{
     FastHashMap, FastHashSet, FastIndexMap,
 };
 
+#[cfg(feature = "half")]
+use half::f16;
+
 use petgraph::graphmap::GraphMap;
 use std::{convert::TryInto, mem, num::NonZeroU32, path::PathBuf};
 

naga/src/front/wgsl/lower/mod.rs

@@ -1656,6 +1656,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
         let expr: Typed<crate::Expression> = match *expr {
             ast::Expression::Literal(literal) => {
                 let literal = match literal {
+                    ast::Literal::Number(Number::F16(f)) => crate::Literal::F16(f),
                     ast::Literal::Number(Number::F32(f)) => crate::Literal::F32(f),
                     ast::Literal::Number(Number::I32(i)) => crate::Literal::I32(i),
                     ast::Literal::Number(Number::U32(u)) => crate::Literal::U32(u),

naga/src/front/wgsl/parse/number.rs

@@ -1,6 +1,9 @@
 use crate::front::wgsl::error::NumberError;
 use crate::front::wgsl::parse::lexer::Token;
 
+#[cfg(feature = "half")]
+use half::f16;
+
 /// When using this type assume no Abstract Int/Float for now
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum Number {
@@ -17,6 +20,8 @@ pub enum Number {
     /// Concrete u64
     U64(u64),
     /// Concrete f32
+    F16(f16),
+    /// Concrete f32
     F32(f32),
     /// Concrete f64
     F64(f64),

naga/src/lib.rs

@@ -286,6 +286,8 @@ pub use crate::arena::{Arena, Handle, Range, UniqueArena};
 pub use crate::span::{SourceLocation, Span, SpanContext, WithSpan};
 #[cfg(feature = "arbitrary")]
 use arbitrary::Arbitrary;
+#[cfg(feature = "half")]
+use half::f16;
 #[cfg(feature = "deserialize")]
 use serde::Deserialize;
 #[cfg(feature = "serialize")]
@@ -881,6 +883,8 @@ pub enum Literal {
     F64(f64),
     /// May not be NaN or infinity.
     F32(f32),
+    #[cfg(feature = "half")]
+    F16(f16),
     U32(u32),
     I32(i32),
     U64(u64),

naga/src/valid/mod.rs

@@ -114,6 +114,8 @@ bitflags::bitflags! {
         const SUBGROUP = 0x10000;
         /// Support for subgroup barriers.
         const SUBGROUP_BARRIER = 0x20000;
+        /// Support for 16-bit floating-point types.
+        const FLOAT16 = 0x40000;
     }
 }