Gerold55
/
mame
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup (nw) 

- removed unused pincushion.fx
master
ImJezze 2015-12-31 16:32:35 +01:00
parent ff77b7897b
commit eea40fd0e4
17 changed files with 136 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
hlsl/artwork_support/distortion.fx
View File

@ -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
{

14
hlsl/artwork_support/post.fx
View File

@ -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();
}

22
hlsl/bloom.fx
View File

@ -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();
}

10
hlsl/color.fx
View File

@ -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
{

8
hlsl/deconverge.fx
View File

@ -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
{

10
hlsl/distortion.fx
View File

@ -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
{

12
hlsl/downsample.fx
View File

@ -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();
}

16
hlsl/focus.fx
View File

@ -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();
}

17
hlsl/phosphor.fx
View File

@ -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();
}

126
hlsl/pincushion.fx
View File

@ -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();
}
}

12
hlsl/post.fx
View File

@ -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();
}

14
hlsl/prescale.fx
View File

@ -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
{

16
hlsl/primary.fx
View File

@ -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();
}

10
hlsl/vector.fx
View File

@ -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
{

6
hlsl/yiq_decode.fx
View File

@ -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
{

6
hlsl/yiq_encode.fx
View File

@ -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
{

23
src/osd/modules/render/d3d/d3dhlsl.cpp
View File

@ -1072,15 +1072,20 @@ void shaders::begin_draw()
curr_effect = default_effect;
default_effect->set_technique("TestTechnique");
post_effect->set_technique("ScanMaskTechnique");
distortion_effect->set_technique("DistortionTechnique");
phosphor_effect->set_technique("TestTechnique");
focus_effect->set_technique("TestTechnique");
deconverge_effect->set_technique("DeconvergeTechnique");
color_effect->set_technique("ColorTechnique");
yiq_encode_effect->set_technique("EncodeTechnique");
yiq_decode_effect->set_technique("DecodeTechnique");
default_effect->set_technique("DefaultTechnique");
post_effect->set_technique("DefaultTechnique");
distortion_effect->set_technique("DefaultTechnique");
prescale_effect->set_technique("DefaultTechnique");
phosphor_effect->set_technique("DefaultTechnique");
focus_effect->set_technique("DefaultTechnique");
deconverge_effect->set_technique("DefaultTechnique");
color_effect->set_technique("DefaultTechnique");
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)