From 7bced3f4e8f773d3d953573920e6085077f45f31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Capucho?= <jcapucho7@gmail.com>
Date: Tue, 6 Jul 2021 15:58:45 +0100
Subject: [PATCH] [glsl-in] Add support for all texture types

---
 src/front/glsl/functions.rs | 16 ++++++++-
 src/front/glsl/types.rs     | 68 +++++++++++++++++++++++++++++--------
 2 files changed, 69 insertions(+), 15 deletions(-)

diff --git a/src/front/glsl/functions.rs b/src/front/glsl/functions.rs
index a5b9c56c19..c2b1036df7 100644
--- a/src/front/glsl/functions.rs
+++ b/src/front/glsl/functions.rs
@@ -189,7 +189,21 @@ impl Program<'_> {
             }
             FunctionCallKind::Function(name) => {
                 match name.as_str() {
-                    "sampler2D" => {
+                    "sampler1D"
+                    | "sampler1DArray"
+                    | "sampler2D"
+                    | "sampler2DArray"
+                    | "sampler2DMS"
+                    | "sampler2DMSArray"
+                    | "sampler3D"
+                    | "samplerCube"
+                    | "samplerCubeArray"
+                    | "sampler1DShadow"
+                    | "sampler1DArrayShadow"
+                    | "sampler2DShadow"
+                    | "sampler2DArrayShadow"
+                    | "samplerCubeShadow"
+                    | "samplerCubeArrayShadow" => {
                         if args.len() != 2 {
                             return Err(ErrorKind::wrong_function_args(name, 2, args.len(), meta));
                         }
diff --git a/src/front/glsl/types.rs b/src/front/glsl/types.rs
index ed3ec36494..2b038242d9 100644
--- a/src/front/glsl/types.rs
+++ b/src/front/glsl/types.rs
@@ -1,4 +1,4 @@
-use crate::{ScalarKind, Type, TypeInner, VectorSize};
+use crate::{ImageClass, ImageDimension, ScalarKind, Type, TypeInner, VectorSize};
 
 pub fn parse_type(type_name: &str) -> Option<Type> {
     match type_name {
@@ -37,21 +37,12 @@ pub fn parse_type(type_name: &str) -> Option<Type> {
                 width: 4,
             },
         }),
-        "texture2D" => Some(Type {
+        "sampler" | "samplerShadow" => Some(Type {
             name: None,
-            inner: TypeInner::Image {
-                dim: crate::ImageDimension::D2,
-                arrayed: false,
-                class: crate::ImageClass::Sampled {
-                    kind: ScalarKind::Float,
-                    multi: false,
-                },
+            inner: TypeInner::Sampler {
+                comparison: type_name == "samplerShadow",
             },
         }),
-        "sampler" => Some(Type {
-            name: None,
-            inner: TypeInner::Sampler { comparison: false },
-        }),
         word => {
             fn kind_width_parse(ty: &str) -> Option<(ScalarKind, u8)> {
                 Some(match ty {
@@ -114,7 +105,56 @@ pub fn parse_type(type_name: &str) -> Option<Type> {
                 })
             };
 
-            vec_parse(word).or_else(|| mat_parse(word))
+            let texture_parse = |word: &str| {
+                let mut iter = word.split("texture");
+
+                let texture_kind = |ty| {
+                    Some(match ty {
+                        "" => ScalarKind::Float,
+                        "i" => ScalarKind::Sint,
+                        "u" => ScalarKind::Uint,
+                        _ => return None,
+                    })
+                };
+
+                let kind = iter.next()?;
+                let size = iter.next()?;
+                let kind = texture_kind(kind)?;
+
+                let sampled = |multi| ImageClass::Sampled { kind, multi };
+
+                let (dim, arrayed, class) = match size {
+                    "1D" => (ImageDimension::D1, false, sampled(false)),
+                    "1DArray" => (ImageDimension::D1, false, sampled(false)),
+                    "2D" => (ImageDimension::D2, false, sampled(false)),
+                    "2DArray" => (ImageDimension::D2, false, sampled(false)),
+                    "2DMS" => (ImageDimension::D2, true, sampled(true)),
+                    "2DMSArray" => (ImageDimension::D2, true, sampled(true)),
+                    "3D" => (ImageDimension::D3, false, sampled(false)),
+                    "Cube" => (ImageDimension::Cube, false, sampled(false)),
+                    "CubeArray" => (ImageDimension::D2, false, sampled(false)),
+                    "1DShadow" => (ImageDimension::D1, false, ImageClass::Depth),
+                    "1DArrayShadow" => (ImageDimension::D1, true, ImageClass::Depth),
+                    "2DShadow" => (ImageDimension::D2, false, ImageClass::Depth),
+                    "2DArrayShadow" => (ImageDimension::D2, true, ImageClass::Depth),
+                    "CubeShadow" => (ImageDimension::Cube, false, ImageClass::Depth),
+                    "CubeArrayShadow" => (ImageDimension::Cube, true, ImageClass::Depth),
+                    _ => return None,
+                };
+
+                Some(Type {
+                    name: None,
+                    inner: TypeInner::Image {
+                        dim,
+                        arrayed,
+                        class,
+                    },
+                })
+            };
+
+            vec_parse(word)
+                .or_else(|| mat_parse(word))
+                .or_else(|| texture_parse(word))
         }
     }
 }