added constsToGlobals to store all constants in shader globals

h3d/shader/Manager.hx

@@ -8,6 +8,9 @@ class Manager {
 
 	public function new(output) {
 		shaderCache = hxsl.Cache.get();
+		#if flash
+		shaderCache.constsToGlobal = true;
+		#end
 		globals = new hxsl.Globals();
 		this.output = shaderCache.allocOutputVars(output);
 	}
@@ -101,7 +104,13 @@ class Manager {
 		inline function fill(buf:Buffers.ShaderBuffers, s:hxsl.RuntimeShader.RuntimeShaderData) {
 			for( g in s.globals ) {
 				var v = globals.fastGet(g.gid);
-				if( v == null ) throw "Missing global value " + g.path;
+				if( v == null ) {
+					if( g.path == "__consts__" ) {
+						fillRec(s.consts, g.type, buf.globals, g.pos);
+						continue;
+					}
+					throw "Missing global value " + g.path;
+				}
 				fillRec(v, g.type, buf.globals, g.pos);
 			}
 		}

hxsl/Cache.hx

@@ -14,8 +14,10 @@ class Cache {
 	var linkCache : Map<Int,SearchMap>;
 	var outVarsMap : Map<String, Int>;
 	var outVars : Array<Array<String>>;
+	public var constsToGlobal : Bool;
 	
 	function new() {
+		constsToGlobal = false;
 		linkCache = new Map();
 		outVarsMap = new Map();
 		outVars = [];
@@ -98,7 +100,8 @@ class Cache {
 	function flattenShader( s : ShaderData, kind : FunctionKind, params : Map < Int, { instance:Int, index:Int } > ) {
 		var flat = new Flatten();
 		var c = new RuntimeShaderData();
-		var data = flat.flatten(s, kind);
+		var data = flat.flatten(s, kind, constsToGlobal);
+		c.consts = flat.consts;
 		for( g in flat.allocData.keys() ) {
 			var alloc = flat.allocData.get(g);
 			switch( g.kind ) {

hxsl/Flatten.hx

@@ -21,15 +21,41 @@ class Flatten {
 	var params : Array<TVar>;
 	var outVars : Array<TVar>;
 	var varMap : Map<TVar,Alloc>;
+	var econsts : TExpr;
+	public var consts : Array<Float>;
 	public var allocData : Map< TVar, Array<Alloc> >;
 	
 	public function new() {
 	}
 	
-	public function flatten( s : ShaderData, kind : FunctionKind ) : ShaderData {
+	public function flatten( s : ShaderData, kind : FunctionKind, constsToGlobal : Bool ) : ShaderData {
 		globals = [];
 		params = [];
 		outVars = [];
+		if( constsToGlobal ) {
+			consts = [];
+			var p = s.funs[0].expr.p;
+			var gc : TVar = {
+				id : Tools.allocVarId(),
+				name : "__consts__",
+				kind : Global,
+				type : null,
+			};
+			econsts = {
+				e : TVar(gc),
+				t : null,
+				p : p,
+			};
+			s = {
+				name : s.name,
+				vars : s.vars.copy(),
+				funs : [for( f in s.funs ) mapFun(f, mapConsts)],
+			};
+			if( consts.length > 0 ) {
+				gc.type = econsts.t = TArray(TFloat, SConst(consts.length));
+				s.vars.push(gc);
+			}
+		}
 		varMap = new Map();
 		allocData = new Map();
 		for( v in s.vars )
@@ -45,13 +71,17 @@ class Flatten {
 		return {
 			name : s.name,
 			vars : outVars,
-			funs : [for( f in s.funs ) {
-				kind : f.kind,
-				ret : f.ret,
-				args : f.args,
-				ref : f.ref,
-				expr : mapExpr(f.expr),
-			}],
+			funs : [for( f in s.funs ) mapFun(f, mapExpr)],
+		};
+	}
+	
+	function mapFun( f : TFunction, mapExpr : TExpr -> TExpr ) : TFunction {
+		return {
+			kind : f.kind,
+			ret : f.ret,
+			args : f.args,
+			ref : f.ref,
+			expr : mapExpr(f.expr),
 		};
 	}
 	
@@ -83,6 +113,31 @@ class Flatten {
 		};
 		return optimize(e);
 	}
+	
+	function mapConsts( e : TExpr ) : TExpr {
+		switch( e.e ) {
+		case TArray(ea, eindex = { e : TConst(CInt(_)) } ):
+			return { e : TArray(mapConsts(ea), eindex), t : e.t, p : e.p };
+		case TConst(c):
+			switch( c ) {
+			case CFloat(v):
+				return allocConst(v, e.p);
+			default:
+				return e;
+			}
+		default:
+			return e.map(mapConsts);
+		}
+	}
+	
+	function allocConst( v : Float, p ) : TExpr {
+		var index = consts.indexOf(v);
+		if( index < 0 ) {
+			index = consts.length;
+			consts.push(v);
+		}
+		return { e : TArray(econsts, { e : TConst(CInt(index)), t : TInt, p : p } ), t : TFloat, p : p };
+	}
 
 	inline function mkInt(v:Int,pos) {
 		return { e : TConst(CInt(v)), t : TInt, p : pos };

hxsl/RuntimeShader.hx

@@ -37,6 +37,7 @@ class RuntimeShaderData {
 	public var globals : Array<AllocGlobal>;
 	public var globalsSize : Int;
 	public var textures : Array<AllocParam>;
+	public var consts : Array<Float>;
 	public function new() {
 	}
 }