[glsl-in] Fix function argument generation

gfx-rs · May 21, 2021 · c526c85 · c526c85
1 parent c22fa54
commit c526c85
Show file tree

Hide file tree

Showing 2 changed files with 21 additions and 11 deletions.
diff --git a/src/front/glsl/ast.rs b/src/front/glsl/ast.rs
@@ -276,7 +276,13 @@ impl<'function> Context<'function> {
     }
 
     /// Add function argument to current scope
-    pub fn add_function_arg(&mut self, name: Option<String>, ty: Handle<Type>, mutable: bool) {
+    pub fn add_function_arg(
+        &mut self,
+        body: &mut Block,
+        name: Option<String>,
+        ty: Handle<Type>,
+        parameter: ParameterQualifier,
+    ) {
         let index = self.arguments.len();
         self.arguments.push(FunctionArgument {
             name: name.clone(),
@@ -285,16 +291,20 @@ impl<'function> Context<'function> {
         });
 
         if let Some(name) = name {
-            if let Some(current) = self.scopes.last_mut() {
-                let expr = self
-                    .expressions
-                    .append(Expression::FunctionArgument(index as u32));
+            let expr = self.add_expression(Expression::FunctionArgument(index as u32), body);
+            let mutable = parameter != ParameterQualifier::Const;
+            let load = if parameter.is_lhs() {
+                Some(self.add_expression(Expression::Load { pointer: expr }, body))
+            } else {
+                None
+            };
 
+            if let Some(current) = self.scopes.last_mut() {
                 (*current).insert(
                     name,
                     VariableReference {
                         expr,
-                        load: None,
+                        load,
                         mutable,
                     },
                 );
@@ -520,7 +530,7 @@ pub enum StructLayout {
     Std140,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Copy)]
 pub enum ParameterQualifier {
     In,
     Out,

diff --git a/src/front/glsl/parser.rs b/src/front/glsl/parser.rs
@@ -577,7 +577,7 @@ impl<'source, 'program, 'options> Parser<'source, 'program, 'options> {
                                 &mut arguments,
                             );
 
-                            self.parse_function_args(&mut context, &mut parameters)?;
+                            self.parse_function_args(&mut context, &mut body, &mut parameters)?;
 
                             let end_meta = self.expect(TokenValue::RightParen)?.meta;
                             meta = meta.union(&end_meta);
@@ -1540,19 +1540,19 @@ impl<'source, 'program, 'options> Parser<'source, 'program, 'options> {
     fn parse_function_args(
         &mut self,
         context: &mut Context,
+        body: &mut Block,
         parameters: &mut Vec<ParameterQualifier>,
     ) -> Result<()> {
         loop {
             if self.peek_type_name() || self.peek_parameter_qualifier() {
                 let qualifier = self.parse_parameter_qualifier();
-                let mutable = qualifier != ParameterQualifier::Const;
                 parameters.push(qualifier);
                 let ty = self.parse_type_non_void()?.0;
 
                 match self.expect_peek()?.value {
                     TokenValue::Comma => {
                         self.bump()?;
-                        context.add_function_arg(None, ty, mutable);
+                        context.add_function_arg(body, None, ty, qualifier);
                         continue;
                     }
                     TokenValue::Identifier(_) => {
@@ -1561,7 +1561,7 @@ impl<'source, 'program, 'options> Parser<'source, 'program, 'options> {
                         let size = self.parse_array_specifier()?;
                         let ty = self.maybe_array(ty, size);
 
-                        context.add_function_arg(Some(name), ty, mutable);
+                        context.add_function_arg(body, Some(name), ty, qualifier);
 
                         if self.bump_if(TokenValue::Comma).is_some() {
                             continue;