Force inline sampler types after argument inlining (fixes #496) (#498)

Author: eldritchconundrum

Minifier/builtin.fs

@@ -28,6 +28,8 @@ let builtinMatrixTypes = set([
                 yield p+"mat"+c+"x"+r
 ])
 
+let isSamplerType (name: string) = name.Contains("sampler")
+
 let builtinTypes = set [ "void" ] + builtinScalarTypes + builtinVectorTypes + builtinMatrixTypes;
 
 let implicitConversions = // (from, to)

Minifier/inlining.fs

@@ -339,6 +339,12 @@ type ArgumentInlining(options: Options.Options) =
                 let _, body = options.visitor(applyExpr).mapStmt (BlockLevel.FunctionRoot fct) body
                 // Handle argument inlining for f. Remove the parameter from the declaration.
                 let fct = {fct with args = removeInlined f fct.args}
+                // Sampler types can be declared as globals or as function parameters but not as locals.
+                // This means we can inline them into the body of the function only if we inline them further.
+                for inl in argInlinings do
+                    match inl.varDecl.ty.name with
+                    | TypeName ident when Builtin.isSamplerType ident.Name -> inl.varDecl.decl.name.ToBeInlined <- true
+                    | _ -> ()
                 // Handle argument inlining for f. Insert in front of the body a declaration for each inlined argument.
                 let decls =
                     argInlinings

tests/unit/arg-inlining.expected

@@ -1,3 +1,6 @@
+#version 300 es
+
+precision highp float;
 float noinline_canInlineWhenResolvable()
 {
   return 11.;
@@ -78,7 +81,19 @@ float f()
   s+=s+noinline_cannotInlineWhenArgIsNotInlinable(s);
   return s+s+noinline_cannotInlineWhenArgIsNotInlinable(acos(s));
 }
+out vec4 fragColor;
+uniform sampler2D samp;
+vec3 dof()
+{
+  float f=10.;
+  for(;;)
+    {
+      vec3 a=texture(samp,vec2(0)).xyz;
+      return a.zyx+a.xyz*(f*=f);
+    }
+}
 void main()
 {
   f();
+  fragColor.xyz=dof();
 }

tests/unit/arg-inlining.frag

@@ -1,3 +1,6 @@
+#version 300 es
+precision highp float;
+
 // Argument inlining inlines the argument of a function call into the function body.
 
 float noinline_canInlineWhenResolvable(float a) { return a+10.; }
@@ -46,7 +49,20 @@ float f()
 	return s;
 }
 
+
+// sampler types are immutable and cannot be locals, they must always be inlined (#496)
+out vec4 fragColor;
+uniform sampler2D samp;
+vec3 dof(sampler2D tex, float f) {
+        for (;;) {
+                vec3 a = texture(tex,vec2(0)).rgb;
+                return a.zyx+a.xyz*(f*=f);
+        }
+}
+
+
 void main()
 {
 	f();
+	fragColor.xyz = dof(samp, 10.0);
 }