HLSL Color Transforms and 3D LUT (mamedev#4043)

* Remove broken scanline uniform from post_pass

* Add 3D LUT to HLSL

* Allow individual LUTs for screen and UI

* WIP: Port 3D LUT to BGFX

* Finish porting LUT to BGFX

* Add individual phosphor color conversion for HLSL
	new file:   hlsl/chroma.fx
		Shader for converting xyY3 to sRGB
	modified:   hlsl/phosphor.fx
		Minor changes to emphasize idea that phosphors are color
agnostic
	modified:   hlsl/post.fx
		Conversion from signal RGB to xyY3
	modified:   src/osd/modules/render/d3d/d3dhlsl.cpp
	modified:   src/osd/modules/render/d3d/d3dhlsl.h
	modified:   src/osd/windows/winmain.cpp
	modified:   src/osd/windows/winmain.h

* Add phosphor examples and update presets

* Port phosphor color shaders to BGFX

* Fix missing newlines at EOF

bgfx/chains/lut.json

@@ -0,0 +1,36 @@
+{
+	"name": "3D LUT",
+	"author": "W. M. Martinez",
+	"targets": [
+		{
+			"name": "temp",
+			"mode": "guest"
+		}
+	],
+	"passes": [
+		{
+			"effect": "misc/blit",
+			"name": "Copy To Filtered Texture",
+			"input": [
+				{ "sampler": "s_tex", "texture": "screen" }
+			],
+			"output": "temp"
+		}, {
+			"effect": "misc/lut",
+			"name": "Apply LUT",
+			"input": [
+				{
+					"sampler": "s_tex",
+					"target": "temp"
+				}, {
+					"sampler": "s_3dlut",
+					"option": "bgfx_lut",
+					"bilinear": false,
+					"clamp": true,
+					"selection": "LUT Texture"
+				}
+			],
+			"output": "output"
+		}
+	]
+}

bgfx/effects/hlsl/chroma.json

@@ -0,0 +1,33 @@
+// license:BSD-3-Clause
+// copyright-holders:W. M. Martinez
+//============================================================
+//
+//  chroma.json: Phosphor chromaticity conversion
+//
+//============================================================
+{
+    "blend": {
+    	"equation": "add",
+    	"srcColor": "srcalpha",
+    	"dstColor": "1-srcalpha",
+    	"srcAlpha": "srcalpha",
+    	"dstAlpha": "1-srcalpha"
+    },
+    "depth": {
+    	"function": "always"
+    },
+    "cull": { "mode": "none" },
+    "write": {
+    	"rgb": true,
+    	"alpha": true
+    },
+    "vertex": "chains/hlsl/vs_chroma",
+    "fragment": "chains/hlsl/fs_chroma",
+    "uniforms": [
+    	{ "name": "s_tex",      "type": "int",  "values": [ 0.0 ] },
+	{ "name": "u_y_gain",   "type": "vec4", "values": [ 0.2124, 0.7011, 0.0866, 0.0 ] },
+	{ "name": "u_chroma_a", "type": "vec4", "values": [ 0.630, 0.340, 0.0, 0.0 ] },
+	{ "name": "u_chroma_b", "type": "vec4", "values": [ 0.310, 0.595, 0.0, 0.0 ] },
+	{ "name": "u_chroma_c", "type": "vec4", "values": [ 0.155, 0.070, 0.0, 0.0 ] }
+    ]
+}

bgfx/effects/hlsl/post.json

@@ -42,6 +42,8 @@
     	{ "name": "u_shadow_uv",              "type": "vec4", "values": [ 0.25, 0.25, 0.0, 0.0 ] },
     	{ "name": "u_shadow_uv_offset",       "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] },
     	{ "name": "u_power",                  "type": "vec4", "values": [ 1.0, 1.0, 1.0, 0.0 ] },
-    	{ "name": "u_floor",                  "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] }
+		{ "name": "u_floor",                  "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] },
+		{ "name": "u_chroma_mode",            "type": "vec4", "values": [ 3.0, 0.0, 0.0, 0.0 ] },
+		{ "name": "u_conversion_gain",        "type": "vec4", "values": [ 0.299, 0.587, 0.114, 0.0 ] }
     ]
-}
+}

bgfx/effects/misc/lut.json

@@ -0,0 +1,32 @@
+{
+	"blend": {
+		"equation": "add",
+    		"srcColor": "srcalpha",
+    		"dstColor": "1-srcalpha",
+    		"srcAlpha": "srcalpha",
+    		"dstAlpha": "1-srcalpha"
+	},
+	"depth": {
+		"function": "always"
+	},
+	"cull": {
+		"mode": "none"
+	},
+	"write": {
+		"rgb": true,
+		"alpha": true
+	},
+	"vertex": "chains/misc/vs_lut",
+	"fragment": "chains/misc/fs_lut",
+	"uniforms": [
+		{
+			"name": "s_tex",
+			"type": "int",
+			"values": [ 1.0 ]
+		}, {
+			"name": "s_3dlut",
+			"type": "int",
+			"values": [ 1.0 ]
+		}
+	]
+}

hlsl/chroma.fx

@@ -0,0 +1,122 @@
+// license:BSD-3-Clause
+// copyright-holders:W. M. Martinez
+//-----------------------------------------------------------------------------
+// Phosphor Chromaticity to sRGB Transform Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
+texture Diffuse;
+
+sampler DiffuseSampler = sampler_state
+{
+	Texture   = <Diffuse>;
+	MipFilter = LINEAR;
+	MinFilter = LINEAR;
+	MagFilter = LINEAR;
+	AddressU = CLAMP;
+	AddressV = CLAMP;
+	AddressW = CLAMP;
+};
+
+//-----------------------------------------------------------------------------
+// Vertex Definitions
+//-----------------------------------------------------------------------------
+
+struct VS_OUTPUT
+{
+	float4 Position : POSITION;
+	float4 Color : COLOR0;
+	float2 TexCoord : TEXCOORD0;
+	float2 PrevCoord : TEXCOORD1;
+};
+
+struct VS_INPUT
+{
+	float3 Position : POSITION;
+	float4 Color : COLOR0;
+	float2 TexCoord : TEXCOORD0;
+};
+
+struct PS_INPUT
+{
+	float4 Color : COLOR0;
+	float2 TexCoord : TEXCOORD0;
+	float2 PrevCoord : TEXCOORD1;
+};
+
+//-----------------------------------------------------------------------------
+// Chroma Vertex Shader
+//-----------------------------------------------------------------------------
+
+uniform float2 ScreenDims;
+uniform float2 TargetDims;
+
+uniform bool Passthrough;
+
+VS_OUTPUT vs_main(VS_INPUT Input)
+{
+	VS_OUTPUT Output = (VS_OUTPUT)0.0;
+
+	Output.Position = float4(Input.Position.xyz, 1.0);
+	Output.Position.xy /= ScreenDims;
+	Output.Position.y = 1.0 - Output.Position.y; // flip y
+	Output.Position.xy -= 0.5; // center
+	Output.Position.xy *= 2.0; // zoom
+
+	Output.TexCoord = Input.TexCoord;
+	Output.TexCoord += 0.5 / TargetDims; // half texel offset correction (DX9)
+
+	Output.PrevCoord = Output.TexCoord;
+
+	Output.Color = Input.Color;
+
+	return Output;
+}
+
+//-----------------------------------------------------------------------------
+// Chroma Pixel Shader
+//-----------------------------------------------------------------------------
+
+uniform float3 YGain = float3(0.2126, 0.7152, 0.0722);
+uniform float2 ChromaA = float2(0.630, 0.340);
+uniform float2 ChromaB = float2(0.310, 0.595);
+uniform float2 ChromaC = float2(0.155, 0.070);
+
+static const float3x3 XYZ_TO_sRGB = {
+	 3.2406, -1.5372, -0.4986,
+        -0.9689,  1.8758,  0.0415,
+	 0.0557, -0.2040,  1.0570
+};
+
+float4 ps_main(PS_INPUT Input) : COLOR
+{
+	const float4 cin = tex2D(DiffuseSampler, Input.TexCoord);
+	float4 cout = float4(0.0, 0.0, 0.0, cin.a);
+	const float3x2 xy = { ChromaA, ChromaB, ChromaC };
+
+	for (int i = 0; i < 3; ++i) {
+		const float Y = YGain[i] * cin[i];
+		const float X = xy[i].x * (Y / xy[i].y);
+		const float Z = (1.0 - xy[i].x - xy[i].y) * (Y / xy[i].y);
+		cout.rgb += mul(XYZ_TO_sRGB, float3(X, Y, Z));
+	}
+	return cout;
+}
+
+//-----------------------------------------------------------------------------
+// Phosphor Technique
+//-----------------------------------------------------------------------------
+
+technique DefaultTechnique
+{
+	pass Pass0
+	{
+		Lighting = FALSE;
+
+		VertexShader = compile vs_2_0 vs_main();
+		PixelShader  = compile ps_2_0 ps_main();
+	}
+}

hlsl/phosphor.fx

@@ -71,16 +71,16 @@ uniform bool Passthrough;
 
 VS_OUTPUT vs_main(VS_INPUT Input)
 {
-	VS_OUTPUT Output = (VS_OUTPUT)0;
+	VS_OUTPUT Output = (VS_OUTPUT)0.0;
 
-	Output.Position = float4(Input.Position.xyz, 1.0f);
+	Output.Position = float4(Input.Position.xyz, 1.0);
 	Output.Position.xy /= ScreenDims;
-	Output.Position.y = 1.0f - Output.Position.y; // flip y
-	Output.Position.xy -= 0.5f; // center
-	Output.Position.xy *= 2.0f; // zoom
+	Output.Position.y = 1.0 - Output.Position.y; // flip y
+	Output.Position.xy -= 0.5; // center
+	Output.Position.xy *= 2.0; // zoom
 
 	Output.TexCoord = Input.TexCoord;
-	Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
+	Output.TexCoord += 0.5 / TargetDims; // half texel offset correction (DX9)
 
 	Output.PrevCoord = Output.TexCoord;
 
@@ -93,24 +93,23 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 // Phosphor Pixel Shader
 //-----------------------------------------------------------------------------
 
-uniform float3 Phosphor = float3(0.0f, 0.0f, 0.0f);
-uniform float DeltaTime = 0.0f;
-static const float F = 30.0f;
+uniform float DeltaTime = 0.0;
+uniform float3 Phosphor = float3(0.0, 0.0, 0.0);
+
+static const float F = 30.0;
 
 float4 ps_main(PS_INPUT Input) : COLOR
 {
-	float4 CurrPix = tex2D(DiffuseSampler, Input.TexCoord);
-	float3 PrevPix = tex2D(PreviousSampler, Input.PrevCoord).rgb;
-
-	PrevPix.r *= Phosphor.r == 0 ? 0 : pow(Phosphor.r, F * DeltaTime);
-	PrevPix.g *= Phosphor.g == 0 ? 0 : pow(Phosphor.g, F * DeltaTime);
-	PrevPix.b *= Phosphor.b == 0 ? 0 : pow(Phosphor.b, F * DeltaTime);
-	float RedMax = max(CurrPix.r, PrevPix.r);
-	float GreenMax = max(CurrPix.g, PrevPix.g);
-	float BlueMax = max(CurrPix.b, PrevPix.b);
-
-	return Passthrough ?
-	       CurrPix : float4(RedMax, GreenMax, BlueMax, CurrPix.a);
+	float4 CurrY = tex2D(DiffuseSampler, Input.TexCoord);
+	float3 PrevY = tex2D(PreviousSampler, Input.PrevCoord).rgb;
+
+	PrevY[0] *= Phosphor[0] == 0.0 ? 0.0 : pow(Phosphor[0], F * DeltaTime);
+	PrevY[1] *= Phosphor[1] == 0.0 ? 0.0 : pow(Phosphor[1], F * DeltaTime);
+	PrevY[2] *= Phosphor[2] == 0.0 ? 0.0 : pow(Phosphor[2], F * DeltaTime);
+	float a = max(PrevY[0], CurrY[0]);
+	float b = max(PrevY[1], CurrY[1]);
+	float c = max(PrevY[2], CurrY[2]);
+	return Passthrough ? CurrY : float4(a, b, c, CurrY.a);
 }
 
 //-----------------------------------------------------------------------------