Cleanup (nw)

- removed unused pincushion.fx

hlsl/artwork_support/distortion.fx

@@ -4,6 +4,10 @@
 // Distortion Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture DiffuseTexture;
 
 sampler DiffuseSampler = sampler_state
@@ -85,7 +89,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
 // Distortion Effect
 //-----------------------------------------------------------------------------
 
-technique DistortionTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/artwork_support/post.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz,ImJezze
 //-----------------------------------------------------------------------------
-// Scanline & Shadowmask Effect
+// Scanline, Shadowmask & Distortion Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture DiffuseTexture;
@@ -98,7 +102,7 @@ float roundBox(float2 p, float2 b, float r)
 }
 
 //-----------------------------------------------------------------------------
-// Scanline & Shadowmask Vertex Shader
+// Scanline, Shadowmask & Distortion Vertex Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenDims; // size of the window or fullscreen
@@ -149,7 +153,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Post-Processing Pixel Shader
+// Scanline, Shadowmask & Distortion Pixel Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenScale = float2(1.0f, 1.0f);
@@ -511,14 +515,12 @@ float4 ps_main(PS_INPUT Input) : COLOR
 // Scanline & Shadowmask Effect
 //-----------------------------------------------------------------------------
 
-technique ScanMaskTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		//Sampler[0] = <DiffuseSampler>;
-
 		VertexShader = compile vs_3_0 vs_main();
 		PixelShader = compile ps_3_0 ps_main();
 	}

hlsl/bloom.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz,ImJezze
 //-----------------------------------------------------------------------------
-// Effect File Variables
+// Bloom Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture DiffuseA;
@@ -339,27 +343,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Bloom Effect
+// Bloom Technique
 //-----------------------------------------------------------------------------
 
-technique TestTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		Sampler[0] = <DiffuseSampler0>; // 2048x2048
-		Sampler[1] = <DiffuseSampler1>; // 1024x1024
-		Sampler[2] = <DiffuseSampler2>; // 512x512
-		Sampler[3] = <DiffuseSampler3>; // 256x256
-		Sampler[4] = <DiffuseSampler4>; // 128x128
-		Sampler[5] = <DiffuseSampler5>; // 64x64
-		Sampler[6] = <DiffuseSampler6>; // 32x32
-		Sampler[7] = <DiffuseSampler7>; // 16x16
-		Sampler[8] = <DiffuseSampler8>; // 8x8
-		Sampler[9] = <DiffuseSampler9>; // 4x4
-		Sampler[10] = <DiffuseSamplerA>; // 2x2
-
 		VertexShader = compile vs_3_0 vs_main();
 		PixelShader = compile ps_3_0 ps_main();
 	}

hlsl/color.fx

@@ -4,6 +4,10 @@
 // Color-Convolution Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture Diffuse;
 
 sampler DiffuseSampler = sampler_state
@@ -43,7 +47,7 @@ struct PS_INPUT
 };
 
 //-----------------------------------------------------------------------------
-// Post-Processing Vertex Shader
+// Color-Convolution Vertex Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenDims;
@@ -68,7 +72,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Post-Processing Pixel Shader
+// Color-Convolution Pixel Shader
 //-----------------------------------------------------------------------------
 
 uniform float3 RedRatios = float3(1.0f, 0.0f, 0.0f);
@@ -105,7 +109,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
 // Color-Convolution Technique
 //-----------------------------------------------------------------------------
 
-technique ColorTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/deconverge.fx

@@ -4,6 +4,10 @@
 // Deconvergence Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture Diffuse;
 
 sampler DiffuseSampler = sampler_state
@@ -112,10 +116,10 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Deconvergence Effect
+// Deconvergence Technique
 //-----------------------------------------------------------------------------
 
-technique DeconvergeTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/distortion.fx

@@ -4,6 +4,10 @@
 // Distortion Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture DiffuseTexture;
 
 sampler DiffuseSampler = sampler_state
@@ -109,7 +113,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Post-Processing Pixel Shader
+// Distortion Pixel Shader
 //-----------------------------------------------------------------------------
 
 uniform float CurvatureAmount = 0.0f;
@@ -299,10 +303,10 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Distortion Effect
+// Distortion Technique
 //-----------------------------------------------------------------------------
 
-technique DistortionTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/downsample.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz,ImJezze
 //-----------------------------------------------------------------------------
-// Effect File Variables
+// Downsample Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture DiffuseTexture;
@@ -96,17 +100,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Downsample Effect
+// Downsample Technique
 //-----------------------------------------------------------------------------
 
-technique TestTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		Sampler[0] = <DiffuseSampler>;
-
 		VertexShader = compile vs_2_0 vs_main();
 		PixelShader = compile ps_2_0 ps_main();
 	}

hlsl/focus.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz,ImJezze
 //-----------------------------------------------------------------------------
-// Effect File Variables
+// Defocus Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture Diffuse;
@@ -51,7 +55,7 @@ bool xor(bool a, bool b)
 }
 
 //-----------------------------------------------------------------------------
-// Simple Vertex Shader
+// Defocus Vertex Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenDims;
@@ -80,7 +84,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Simple Pixel Shader
+// Defocus Pixel Shader
 //-----------------------------------------------------------------------------
 
 float2 Coord1Offset = float2( 0.75f,  0.50f);
@@ -124,17 +128,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Simple Effect
+// Defocus Technique
 //-----------------------------------------------------------------------------
 
-technique TestTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		Sampler[0] = <DiffuseSampler>;
-
 		VertexShader = compile vs_2_0 vs_main();
 		PixelShader = compile ps_2_0 ps_main();
 	}

hlsl/phosphor.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz
 //-----------------------------------------------------------------------------
-// Effect File Variables
+// Phosphor Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture Diffuse;
@@ -57,7 +61,7 @@ struct PS_INPUT
 };
 
 //-----------------------------------------------------------------------------
-// Simple Vertex Shader
+// Phosphor Vertex Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenDims;
@@ -86,7 +90,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Simple Pixel Shader
+// Phosphor Pixel Shader
 //-----------------------------------------------------------------------------
 
 uniform float3 Phosphor = float3(0.0f, 0.0f, 0.0f);
@@ -106,18 +110,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Simple Effect
+// Phosphor Technique
 //-----------------------------------------------------------------------------
 
-technique TestTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		Sampler[0] = <DiffuseSampler>;
-		Sampler[1] = <PreviousSampler>;
-
 		VertexShader = compile vs_2_0 vs_main();
 		PixelShader  = compile ps_2_0 ps_main();
 	}

hlsl/pincushion.fx

@@ -1,126 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Ryan Holtz
-//-----------------------------------------------------------------------------
-// Pincushion Post-Processing Effect
-//-----------------------------------------------------------------------------
-
-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 RedCoord : TEXCOORD2;
-	float2 GreenCoord : TEXCOORD3;
-	float2 BlueCoord : TEXCOORD4;
-};
-
-struct VS_INPUT
-{
-	float3 Position : POSITION;
-	float4 Color : COLOR0;
-	float2 TexCoord : TEXCOORD0;
-	float2 Unused : TEXCOORD1;
-};
-
-struct PS_INPUT
-{
-	float4 Color : COLOR0;
-	float2 TexCoord : TEXCOORD0;
-	float2 RedCoord : TEXCOORD2;
-	float2 GreenCoord : TEXCOORD3;
-	float2 BlueCoord : TEXCOORD4;
-};
-
-//-----------------------------------------------------------------------------
-// Post-Processing Vertex Shader
-//-----------------------------------------------------------------------------
-
-uniform float TargetWidth;
-uniform float TargetHeight;
-
-uniform float RawWidth;
-uniform float RawHeight;
-
-VS_OUTPUT vs_main(VS_INPUT Input)
-{
-	VS_OUTPUT Output = (VS_OUTPUT)0;
-	
-	float2 invDims = float2(1.0f / RawWidth, 1.0f / RawHeight);
-	Output.Position = float4(Input.Position.xyz, 1.0f);
-	Output.Position.x /= TargetWidth;
-	Output.Position.y /= TargetHeight;
-	Output.Position.y = 1.0f - Output.Position.y;
-	Output.Position.x -= 0.5f;
-	Output.Position.y -= 0.5f;
-	Output.Position *= float4(2.0f, 2.0f, 1.0f, 1.0f);
-	Output.Color = Input.Color;
-	Output.TexCoord = Input.TexCoord;
-	
-	Output.TexCoord.x -= 0.25f;
-	Output.TexCoord.y -= 0.25f;
-	Output.TexCoord.x -= 0.5f;
-	Output.TexCoord.y -= 0.5f;
-	Output.TexCoord.x /= 18.0f * (TargetWidth / RawWidth);
-	Output.TexCoord.y /= 18.0f * (TargetHeight / RawHeight);
-	Output.TexCoord.x += 0.5f;
-	Output.TexCoord.y += 0.5f;
-
-	return Output;
-}
-
-//-----------------------------------------------------------------------------
-// Post-Processing Pixel Shader
-//-----------------------------------------------------------------------------
-
-uniform float PI = 3.14159265f;
-
-uniform float PincushionAmountX = 0.1f;
-uniform float PincushionAmountY = 0.1f;
-
-uniform float2 ActiveArea;
-
-float4 ps_main(PS_INPUT Input) : COLOR
-{
-	// -- Screen Pincushion Calculation --
-	float2 UnitCoord = Input.TexCoord * ActiveArea * 2.0f - 1.0f;
-
-	float PincushionR2 = pow(length(UnitCoord),2.0f) / pow(length(ActiveArea), 2.0f);
-	float2 PincushionCurve = UnitCoord * PincushionAmountX * PincushionR2;
-	float2 BaseCoord = Input.TexCoord + PincushionCurve;
-
-	return tex2D(DiffuseSampler, BaseCoord);
-}
-
-//-----------------------------------------------------------------------------
-// Post-Processing Effect
-//-----------------------------------------------------------------------------
-
-technique TestTechnique
-{
-	pass Pass0
-	{
-		Lighting = FALSE;
-
-		Sampler[0] = <DiffuseSampler>;
-
-		VertexShader = compile vs_2_0 vs_main();
-		PixelShader  = compile ps_2_0 ps_main();
-	}
-}

hlsl/post.fx

@@ -4,6 +4,10 @@
 // Scanline & Shadowmask Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture DiffuseTexture;
 
 sampler DiffuseSampler = sampler_state
@@ -121,7 +125,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Post-Processing Pixel Shader
+// Scanline & Shadowmask Pixel Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenScale = float2(1.0f, 1.0f);
@@ -264,17 +268,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Scanline & Shadowmask Effect
+// Scanline & Shadowmask Technique
 //-----------------------------------------------------------------------------
 
-technique ScanMaskTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		Sampler[0] = <DiffuseSampler>;
-
 		VertexShader = compile vs_3_0 vs_main();
 		PixelShader = compile ps_3_0 ps_main();
 	}

hlsl/prescale.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz
 //-----------------------------------------------------------------------------
-// Passthrough Effect
+// Prescale Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture Diffuse;
@@ -41,7 +45,7 @@ struct PS_INPUT
 };
 
 //-----------------------------------------------------------------------------
-// Passthrough Vertex Shader
+// Prescale Vertex Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenDims;
@@ -62,7 +66,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Passthrough Pixel Shader
+// Prescale Pixel Shader
 //-----------------------------------------------------------------------------
 
 float4 ps_main(PS_INPUT Input) : COLOR
@@ -71,10 +75,10 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Passthrough Effect
+// Prescale Technique
 //-----------------------------------------------------------------------------
 
-technique DeconvergeTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/primary.fx

@@ -1,7 +1,11 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz
 //-----------------------------------------------------------------------------
-// Effect File Variables
+// Primary Effect
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Sampler Definitions
 //-----------------------------------------------------------------------------
 
 texture Diffuse;
@@ -42,7 +46,7 @@ struct PS_INPUT
 };
 
 //-----------------------------------------------------------------------------
-// Simple Vertex Shader
+// Primary Vertex Shader
 //-----------------------------------------------------------------------------
 
 static const float Epsilon = 1.0e-7f;
@@ -79,7 +83,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Simple Pixel Shader
+// Primary Pixel Shader
 //-----------------------------------------------------------------------------
 
 float4 ps_main(PS_INPUT Input) : COLOR
@@ -91,17 +95,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Simple Effect
+// Primary Technique
 //-----------------------------------------------------------------------------
 
-technique TestTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{
 		Lighting = FALSE;
 
-		Sampler[0] = <DiffuseSampler>;
-
 		VertexShader = compile vs_2_0 vs_main();
 		PixelShader  = compile ps_2_0 ps_main();
 	}

hlsl/vector.fx

@@ -1,7 +1,7 @@
 // license:BSD-3-Clause
 // copyright-holders:Ryan Holtz
 //-----------------------------------------------------------------------------
-// Effect File Variables
+// Vector Effect
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
@@ -32,7 +32,7 @@ struct PS_INPUT
 };
 
 //-----------------------------------------------------------------------------
-// Simple Vertex Shader
+// Vector Vertex Shader
 //-----------------------------------------------------------------------------
 
 uniform float2 ScreenDims;
@@ -59,7 +59,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
 }
 
 //-----------------------------------------------------------------------------
-// Simple Pixel Shader
+// Vector Pixel Shader
 //-----------------------------------------------------------------------------
 
 // TimeParams.x: Frame time of the vector
@@ -80,10 +80,10 @@ float4 ps_main(PS_INPUT Input) : COLOR
 }
 
 //-----------------------------------------------------------------------------
-// Simple Effect
+// Vector Technique
 //-----------------------------------------------------------------------------
 
-technique TestTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/yiq_decode.fx

@@ -4,6 +4,10 @@
 // YIQ Decode Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture Composite;
 
 sampler CompositeSampler = sampler_state
@@ -175,7 +179,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
 // YIQ Decode Technique
 //-----------------------------------------------------------------------------
 
-technique DecodeTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

hlsl/yiq_encode.fx

@@ -4,6 +4,10 @@
 // YIQ Encode Effect
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Sampler Definitions
+//-----------------------------------------------------------------------------
+
 texture Diffuse;
 
 sampler DiffuseSampler = sampler_state
@@ -118,7 +122,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
 // YIQ Encode Technique
 //-----------------------------------------------------------------------------
 
-technique EncodeTechnique
+technique DefaultTechnique
 {
 	pass Pass0
 	{

src/osd/modules/render/d3d/d3dhlsl.cpp

@@ -1072,15 +1072,20 @@ void shaders::begin_draw()
 
 	curr_effect = default_effect;
 
-	default_effect->set_technique("TestTechnique");
+	default_effect->set_technique("DefaultTechnique");
-	post_effect->set_technique("ScanMaskTechnique");
+	post_effect->set_technique("DefaultTechnique");
-	distortion_effect->set_technique("DistortionTechnique");
+	distortion_effect->set_technique("DefaultTechnique");
-	phosphor_effect->set_technique("TestTechnique");
+	prescale_effect->set_technique("DefaultTechnique");
-	focus_effect->set_technique("TestTechnique");
+	phosphor_effect->set_technique("DefaultTechnique");
-	deconverge_effect->set_technique("DeconvergeTechnique");
+	focus_effect->set_technique("DefaultTechnique");
-	color_effect->set_technique("ColorTechnique");
+	deconverge_effect->set_technique("DefaultTechnique");
-	yiq_encode_effect->set_technique("EncodeTechnique");
+	color_effect->set_technique("DefaultTechnique");
-	yiq_decode_effect->set_technique("DecodeTechnique");
+	yiq_encode_effect->set_technique("DefaultTechnique");
+	yiq_decode_effect->set_technique("DefaultTechnique");
+	color_effect->set_technique("DefaultTechnique");
+	bloom_effect->set_technique("DefaultTechnique");
+	downsample_effect->set_technique("DefaultTechnique");
+	vector_effect->set_technique("DefaultTechnique");
 
 	HRESULT result = (*d3dintf->device.get_render_target)(d3d->get_device(), 0, &backbuffer);
 	if (result != D3D_OK)