review shader compaction & kept data

h3d/impl/DX12Driver.hx

@@ -813,6 +813,8 @@ class DX12Driver extends h3d.impl.Driver {
 	#if heaps_mt_hxsl_cache
 	var compileMutex  = new sys.thread.Mutex();
 	var shaderBinaryMutex  = new sys.thread.Mutex();
+	var compilingCount = 0;
+	var releaseQueue : Array<hxsl.RuntimeShader> = [];
 	#end
 	var psoConfigCache : PSOConfigCache;
 
@@ -1827,12 +1829,13 @@ class DX12Driver extends h3d.impl.Driver {
 	}
 
 	override function getNativeShaderCode( shader : hxsl.RuntimeShader ) {
-		var out = new hxsl.HlslOut();
-		var vsSource = out.run(shader.vertex.data);
+		inline function compile( sh : hxsl.RuntimeShader.RuntimeShaderData ) {
+			return sh.code ?? new hxsl.HlslOut().run(sh.data);
+		}
+		var vsSource = compile(shader.vertex);
 		if( shader.mode == Compute )
 			return vsSource;
-		var out = new hxsl.HlslOut();
-		var psSource = out.run(shader.fragment.data);
+		var psSource = compile(shader.fragment);
 		return vsSource+"\n\n\n\n"+psSource;
 	}
 
@@ -2165,6 +2168,45 @@ class DX12Driver extends h3d.impl.Driver {
 	}
 
 	function compileShader( shader : hxsl.RuntimeShader ) : CompiledShader {
+		#if heaps_mt_hxsl_cache
+		// data is only released once no thread is compiling, as another thread might be compiling the same shader
+		compileMutex.acquire();
+		var sh = compiledShaders.get(shader.id);
+		if( sh != null ) {
+			compileMutex.release();
+			return sh;
+		}
+		compilingCount++;
+		compileMutex.release();
+		var c = try doCompileShader(shader) catch( e : haxe.Exception ) {
+			endCompile(null);
+			throw e;
+		}
+		endCompile(shader);
+		return c;
+		#else
+		var c = doCompileShader(shader);
+		shader.releaseData();
+		return c;
+		#end
+	}
+
+	#if heaps_mt_hxsl_cache
+	function endCompile( shader : hxsl.RuntimeShader ) {
+		compileMutex.acquire();
+		compilingCount--;
+		if( shader != null )
+			releaseQueue.push(shader);
+		if( compilingCount == 0 ) {
+			for( s in releaseQueue )
+				s.releaseData();
+			releaseQueue = [];
+		}
+		compileMutex.release();
+	}
+	#end
+
+	function doCompileShader( shader : hxsl.RuntimeShader ) : CompiledShader {
 		#if heaps_mt_hxsl_cache
 		compileMutex.acquire();
 		#end

h3d/impl/DirectXDriver.hx

@@ -842,9 +842,6 @@ class DirectXDriver extends h3d.impl.Driver {
 		var h = new hxsl.HlslOut();
 		if( shader.code == null ){
 			shader.code = h.run(shader.data);
-			#if !heaps_compact_mem
-			shader.data.funs = null;
-			#end
 		}
 		var bytes = getBinaryPayload(shader.kind == Vertex, shader.code);
 		if( bytes == null ) {
@@ -908,7 +905,7 @@ class DirectXDriver extends h3d.impl.Driver {
 
 	override function getNativeShaderCode( shader : hxsl.RuntimeShader ) {
 		function dumpShader(s:hxsl.RuntimeShader.RuntimeShaderData) {
-			var code = new hxsl.HlslOut().run(s.data);
+			var code = s.code ?? new hxsl.HlslOut().run(s.data);
 			try {
 				var scomp = compileShader(s, true).bytes;
 				code += "\n// ASM=\n" + Driver.disassembleShader(scomp, None, null) + "\n\n";
@@ -1144,6 +1141,7 @@ class DirectXDriver extends h3d.impl.Driver {
 			s.format = hxd.BufferFormat.make(format);
 			s.semanticNames = semanticNames;
 			shaders.set(shader.id, s);
+			shader.releaseData();
 		}
 		if( s == currentShader )
 			return false;

h3d/impl/GlDriver.hx

@@ -304,12 +304,12 @@ class GlDriver extends Driver {
 	}
 
 	override function getNativeShaderCode( shader : hxsl.RuntimeShader ) {
-		inline function compile(sh) {
-			return makeCompiler().run(sh);
+		inline function compile( sh : hxsl.RuntimeShader.RuntimeShaderData ) {
+			return sh.code ?? makeCompiler().run(sh.data);
 		}
 		if( shader.mode == Compute )
-			return compile(shader.compute.data);
-		return "// vertex:\n" + compile(shader.vertex.data) + "// fragment:\n" + compile(shader.fragment.data);
+			return compile(shader.compute);
+		return "// vertex:\n" + compile(shader.vertex) + "// fragment:\n" + compile(shader.fragment);
 	}
 
 	override public function getDriverName(details:Bool) {
@@ -338,9 +338,6 @@ class GlDriver extends Driver {
 		var s = gl.createShader(type);
 		if( shader.code == null ){
 			shader.code = glout.run(shader.data);
-			#if !heaps_compact_mem
-			shader.data.funs = null;
-			#end
 		}
 		gl.shaderSource(s, shader.code);
 		gl.compileShader(s);
@@ -616,6 +613,7 @@ class GlDriver extends Driver {
 				}
 			p.format = hxd.BufferFormat.make(format);
 			programs.set(shader.id, p);
+			shader.releaseData();
 		}
 		if( curShader == p ) return false;
 		setProgram(p);

h3d/impl/NullDriver.hx

@@ -39,6 +39,7 @@ class NullDriver extends Driver {
 	override function selectShader( shader : hxsl.RuntimeShader ) {
 		if( cur == shader ) return false;
 		cur = shader;
+		shader.releaseData();
 		return true;
 	}
 

hxsl/Cache.hx

@@ -479,9 +479,6 @@ class Cache {
 		var flat = new Flatten();
 		var c = new RuntimeShaderData();
 		var data = flat.flatten(s, kind);
-		#if (hl && heaps_compact_mem)
-		data = hl.Api.compact(data, null, 0, null);
-		#end
 		var textures = [];
 		var buffers = [];
 		c.texturesCount = 0;

hxsl/CacheFile2.hx

@@ -565,12 +565,12 @@ class CacheFile2 extends Cache {
 						codedump.push("  " + @:privateAccess inst.shader.data.name + "(bits=" + inst.bits + ")");
 					if( rt.vertex != null && rt.vertex.data != null ) {
 						codedump.push("// --- vertex ---");
-						codedump.push(printer.shaderString(rt.vertex.data));
+						codedump.push(rt.vertex.code ?? printer.shaderString(rt.vertex.data));
 						codedump.push("\n");
 					}
 					if( rt.fragment != null && rt.fragment.data != null ) {
 						codedump.push("// --- fragment ---");
-						codedump.push(printer.shaderString(rt.fragment.data));
+						codedump.push(rt.fragment.code ?? printer.shaderString(rt.fragment.data));
 						codedump.push("\n");
 					}
 					codedump.push("\n\n");

hxsl/RuntimeShader.hx

@@ -126,6 +126,16 @@ class RuntimeShader {
 		return mode == Compute ? [compute] : [vertex, fragment];
 	}
 
+	public function releaseData() {
+		inline function release( s : RuntimeShaderData ) {
+			// vars and code are kept: the driver needs them to recompile the shader after a context loss
+			if( s != null && (s.data.funs == null || s.data.funs.length > 0) )
+				s.data = SharedShader.compactMem({ name : s.data.name, vars : s.data.vars, funs : [] });
+		}
+		release(vertex);
+		release(fragment);
+	}
+
 	public function getInputFormat( instance=false ) {
 		var format : Array<hxd.BufferFormat.BufferInput> = [];
 		for( v in vertex.data.vars )