glsl-in: relational vector functions improvements

src/front/glsl/builtins.rs

@@ -9,7 +9,7 @@ use super::{
 use crate::{
     BinaryOperator, Block, Constant, DerivativeAxis, Expression, Handle, ImageClass,
     ImageDimension as Dim, ImageQuery, MathFunction, Module, RelationalFunction, SampleLevel,
-    ScalarKind as Sk, Span, Type, TypeInner, VectorSize,
+    ScalarKind as Sk, Span, Type, TypeInner, UnaryOperator, VectorSize,
 };
 
 impl crate::ScalarKind {
@@ -825,7 +825,7 @@ fn inject_standard_builtins(
                     .push(module.add_builtin(args, MacroCall::MathFunction(fun)))
             }
         }
-        "all" | "any" => {
+        "all" | "any" | "not" => {
             // bits layout
             // bit 0 trough 1 - dims
             for bits in 0..0b11 {
@@ -841,17 +841,17 @@ fn inject_standard_builtins(
                     width: crate::BOOL_WIDTH,
                 }];
 
-                let fun = MacroCall::Relational(match name {
-                    "all" => RelationalFunction::All,
-                    "any" => RelationalFunction::Any,
+                let fun = match name {
+                    "all" => MacroCall::Relational(RelationalFunction::All),
+                    "any" => MacroCall::Relational(RelationalFunction::Any),
+                    "not" => MacroCall::Unary(UnaryOperator::Not),
                     _ => unreachable!(),
-                });
+                };
 
                 declaration.overloads.push(module.add_builtin(args, fun))
             }
         }
-        "lessThan" | "greaterThan" | "lessThanEqual" | "greaterThanEqual" | "equal"
-        | "notEqual" => {
+        "lessThan" | "greaterThan" | "lessThanEqual" | "greaterThanEqual" => {
             for bits in 0..0b1001 {
                 let (size, kind) = match bits {
                     0b0000 => (VectorSize::Bi, Sk::Float),
@@ -873,6 +873,39 @@ fn inject_standard_builtins(
                     "greaterThan" => BinaryOperator::Greater,
                     "lessThanEqual" => BinaryOperator::LessEqual,
                     "greaterThanEqual" => BinaryOperator::GreaterEqual,
+                    _ => unreachable!(),
+                });
+
+                declaration.overloads.push(module.add_builtin(args, fun))
+            }
+        }
+        "equal" | "notEqual" => {
+            for bits in 0..0b1100 {
+                let (size, kind) = match bits {
+                    0b0000 => (VectorSize::Bi, Sk::Float),
+                    0b0001 => (VectorSize::Tri, Sk::Float),
+                    0b0010 => (VectorSize::Quad, Sk::Float),
+                    0b0011 => (VectorSize::Bi, Sk::Sint),
+                    0b0100 => (VectorSize::Tri, Sk::Sint),
+                    0b0101 => (VectorSize::Quad, Sk::Sint),
+                    0b0110 => (VectorSize::Bi, Sk::Uint),
+                    0b0111 => (VectorSize::Tri, Sk::Uint),
+                    0b1000 => (VectorSize::Quad, Sk::Uint),
+                    0b1001 => (VectorSize::Bi, Sk::Bool),
+                    0b1010 => (VectorSize::Tri, Sk::Bool),
+                    _ => (VectorSize::Quad, Sk::Bool),
+                };
+
+                let width = if let Sk::Bool = kind {
+                    crate::BOOL_WIDTH
+                } else {
+                    width
+                };
+
+                let ty = || TypeInner::Vector { size, kind, width };
+                let args = vec![ty(), ty()];
+
+                let fun = MacroCall::Binary(match name {
                     "equal" => BinaryOperator::Equal,
                     "notEqual" => BinaryOperator::NotEqual,
                     _ => unreachable!(),
@@ -1157,6 +1190,31 @@ fn inject_double_builtin(declaration: &mut FunctionDeclaration, module: &mut Mod
                     .push(module.add_builtin(args, MacroCall::Clamp(size)))
             }
         }
+        "lessThan" | "greaterThan" | "lessThanEqual" | "greaterThanEqual" | "equal"
+        | "notEqual" => {
+            for bits in 0..0b11 {
+                let (size, kind) = match bits {
+                    0b00 => (VectorSize::Bi, Sk::Float),
+                    0b01 => (VectorSize::Tri, Sk::Float),
+                    _ => (VectorSize::Quad, Sk::Float),
+                };
+
+                let ty = || TypeInner::Vector { size, kind, width };
+                let args = vec![ty(), ty()];
+
+                let fun = MacroCall::Binary(match name {
+                    "lessThan" => BinaryOperator::Less,
+                    "greaterThan" => BinaryOperator::Greater,
+                    "lessThanEqual" => BinaryOperator::LessEqual,
+                    "greaterThanEqual" => BinaryOperator::GreaterEqual,
+                    "equal" => BinaryOperator::Equal,
+                    "notEqual" => BinaryOperator::NotEqual,
+                    _ => unreachable!(),
+                });
+
+                declaration.overloads.push(module.add_builtin(args, fun))
+            }
+        }
         // Add common builtins with doubles
         _ => inject_common_builtin(declaration, module, name, 8),
     }
@@ -1596,6 +1654,7 @@ pub enum MacroCall {
     BitfieldExtract,
     BitfieldInsert,
     Relational(RelationalFunction),
+    Unary(UnaryOperator),
     Binary(BinaryOperator),
     Mod(Option<VectorSize>),
     Splatted(MathFunction, Option<VectorSize>, usize),
@@ -1963,6 +2022,11 @@ impl MacroCall {
                 Span::default(),
                 body,
             ),
+            MacroCall::Unary(op) => ctx.add_expression(
+                Expression::Unary { op, expr: args[0] },
+                Span::default(),
+                body,
+            ),
             MacroCall::Binary(op) => ctx.add_expression(
                 Expression::Binary {
                     op,

tests/in/glsl/vector-functions.vert

@@ -0,0 +1,47 @@
+#version 450
+
+void ftest(vec4 a, vec4 b) {
+	bvec4 c = lessThan(a, b);
+	bvec4 d = lessThanEqual(a, b);
+	bvec4 e = greaterThan(a, b);
+	bvec4 f = greaterThanEqual(a, b);
+	bvec4 g = equal(a, b);
+	bvec4 h = notEqual(a, b);
+}
+
+void dtest(dvec4 a, dvec4 b) {
+	bvec4 c = lessThan(a, b);
+	bvec4 d = lessThanEqual(a, b);
+	bvec4 e = greaterThan(a, b);
+	bvec4 f = greaterThanEqual(a, b);
+	bvec4 g = equal(a, b);
+	bvec4 h = notEqual(a, b);
+}
+
+void itest(ivec4 a, ivec4 b) {
+	bvec4 c = lessThan(a, b);
+	bvec4 d = lessThanEqual(a, b);
+	bvec4 e = greaterThan(a, b);
+	bvec4 f = greaterThanEqual(a, b);
+	bvec4 g = equal(a, b);
+	bvec4 h = notEqual(a, b);
+}
+
+void utest(uvec4 a, uvec4 b) {
+	bvec4 c = lessThan(a, b);
+	bvec4 d = lessThanEqual(a, b);
+	bvec4 e = greaterThan(a, b);
+	bvec4 f = greaterThanEqual(a, b);
+	bvec4 g = equal(a, b);
+	bvec4 h = notEqual(a, b);
+}
+
+void btest(bvec4 a, bvec4 b) {
+	bvec4 c = equal(a, b);
+	bvec4 d = notEqual(a, b);
+	bool e = any(a);
+	bool f = all(a);
+	bvec4 g = not(a);
+}
+
+void main() {}