Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-04 16:34:53 +03:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

HLSL Cleanup, no whatsnew:

Browse Source 
- Fixed set_vector functionality and simplified shaders as a result
- Fixed HLSL presets, 0 to 3, in increasing level of terribleness
- Reduced options footprint from RGB triplets

Next plan: Separate INI writing.
This commit is contained in:
Ryan Holtz 2011-06-11 23:46:24 +00:00
parent 5d2798215c
commit 80d66bb1d6
12 changed files with 324 additions and 485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
hlsl/color.fx
View File

@ -76,28 +76,11 @@ VS_OUTPUT vs_main(VS_INPUT Input)
// Post-Processing Pixel Shader
//-----------------------------------------------------------------------------
uniform float RedFromRed = 1.0f;
uniform float RedFromGrn = 0.0f;
uniform float RedFromBlu = 0.0f;
uniform float GrnFromRed = 0.0f;
uniform float GrnFromGrn = 1.0f;
uniform float GrnFromBlu = 0.0f;
uniform float BluFromRed = 0.0f;
uniform float BluFromGrn = 0.0f;
uniform float BluFromBlu = 1.0f;
uniform float RedOffset = 0.0f;
uniform float GrnOffset = 0.0f;
uniform float BluOffset = 0.0f;
uniform float RedScale = 1.0f;
uniform float GrnScale = 1.0f;
uniform float BluScale = 1.0f;
uniform float RedFloor = 0.0f;
uniform float GrnFloor = 0.0f;
uniform float BluFloor = 0.0f;
uniform float3 RedRatios = float3(1.0f, 0.0f, 0.0f);
uniform float3 GrnRatios = float3(0.0f, 1.0f, 0.0f);
uniform float3 BluRatios = float3(0.0f, 0.0f, 1.0f);
uniform float3 Offset = float3(0.0f, 0.0f, 0.0f);
uniform float3 Scale = float3(1.0f, 1.0f, 1.0f);
uniform float Saturation = 1.0f;
float4 ps_main(PS_INPUT Input) : COLOR
@ -107,14 +90,12 @@ float4 ps_main(PS_INPUT Input) : COLOR
float3 OutRGB = BaseTexel.rgb;
// -- RGB Tint & Shift --
float ShiftedRed = dot(OutRGB, float3(RedFromRed, RedFromGrn, RedFromBlu));
float ShiftedGrn = dot(OutRGB, float3(GrnFromRed, GrnFromGrn, GrnFromBlu));
float ShiftedBlu = dot(OutRGB, float3(BluFromRed, BluFromGrn, BluFromBlu));
float ShiftedRed = dot(OutRGB, RedRatios);
float ShiftedGrn = dot(OutRGB, GrnRatios);
float ShiftedBlu = dot(OutRGB, BluRatios);
// -- RGB Offset & Scale --
float3 RGBScale = float3(RedScale, GrnScale, BluScale);
float3 RGBShift = float3(RedOffset, GrnOffset, BluOffset);
float3 OutTexel = float3(ShiftedRed, ShiftedGrn, ShiftedBlu) * RGBScale + RGBShift;
float3 OutTexel = float3(ShiftedRed, ShiftedGrn, ShiftedBlu) * Scale + Offset;
// -- Saturation --
float3 Gray = float3(0.3f, 0.59f, 0.11f);
@ -122,7 +103,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
float3 OutChroma = OutTexel - OutLuma;
float3 Saturated = OutLuma + OutChroma * Saturation;
return float4(OutRGB, BaseTexel.a);
return float4(Saturated, BaseTexel.a);
}
//-----------------------------------------------------------------------------

56
hlsl/deconverge.fx
View File

@ -23,10 +23,9 @@ struct VS_OUTPUT
{
float4 Position : POSITION;
float4 Color : COLOR0;
float2 RedCoord : TEXCOORD0;
float2 GrnCoord : TEXCOORD1;
float2 BluCoord : TEXCOORD2;
float2 TexCoord : TEXCOORD3;
float3 CoordX : TEXCOORD0;
float3 CoordY : TEXCOORD1;
float2 TexCoord : TEXCOORD2;
};
struct VS_INPUT
@ -39,22 +38,17 @@ struct VS_INPUT
struct PS_INPUT
{
float4 Color : COLOR0;
float2 RedCoord : TEXCOORD0;
float2 GrnCoord : TEXCOORD1;
float2 BluCoord : TEXCOORD2;
float2 TexCoord : TEXCOORD3;
float3 CoordX : TEXCOORD0;
float3 CoordY : TEXCOORD1;
float2 TexCoord : TEXCOORD2;
};
//-----------------------------------------------------------------------------
// Deconvergence Vertex Shader
//-----------------------------------------------------------------------------
uniform float RedConvergeX;
uniform float RedConvergeY;
uniform float GrnConvergeX;
uniform float GrnConvergeY;
uniform float BluConvergeX;
uniform float BluConvergeY;
uniform float3 ConvergeX = float3(0.0f, 0.0f, 0.0f);
uniform float3 ConvergeY = float3(0.0f, 0.0f, 0.0f);
uniform float TargetWidth;
uniform float TargetHeight;
@ -65,12 +59,8 @@ uniform float RawHeight;
uniform float WidthRatio;
uniform float HeightRatio;
uniform float RedRadialConvergeX;
uniform float RedRadialConvergeY;
uniform float GrnRadialConvergeX;
uniform float GrnRadialConvergeY;
uniform float BluRadialConvergeX;
uniform float BluRadialConvergeY;
uniform float3 RadialConvergeX = float3(0.0f, 0.0f, 0.0f);
uniform float3 RadialConvergeY = float3(0.0f, 0.0f, 0.0f);
uniform float Prescale;
@ -91,14 +81,8 @@ VS_OUTPUT vs_main(VS_INPUT Input)
Output.Color = Input.Color;
float2 TexCoord = Input.TexCoord;
Output.RedCoord.x = ((((TexCoord.x / Ratios.x) - 0.5f)) * (1.0f + RedRadialConvergeX / RawWidth) + 0.5f) * Ratios.x + RedConvergeX * invDims.x;
Output.GrnCoord.x = ((((TexCoord.x / Ratios.x) - 0.5f)) * (1.0f + GrnRadialConvergeX / RawWidth) + 0.5f) * Ratios.x + GrnConvergeX * invDims.x;
Output.BluCoord.x = ((((TexCoord.x / Ratios.x) - 0.5f)) * (1.0f + BluRadialConvergeX / RawWidth) + 0.5f) * Ratios.x + BluConvergeX * invDims.x;
Output.RedCoord.y = ((((TexCoord.y / Ratios.y) - 0.5f)) * (1.0f + RedRadialConvergeY / RawHeight) + 0.5f) * Ratios.y + RedConvergeY * invDims.y;
Output.GrnCoord.y = ((((TexCoord.y / Ratios.y) - 0.5f)) * (1.0f + GrnRadialConvergeY / RawHeight) + 0.5f) * Ratios.y + GrnConvergeY * invDims.y;
Output.BluCoord.y = ((((TexCoord.y / Ratios.y) - 0.5f)) * (1.0f + BluRadialConvergeY / RawHeight) + 0.5f) * Ratios.y + BluConvergeY * invDims.y;
Output.CoordX = ((((TexCoord.x / Ratios.x) - 0.5f)) * (1.0f + RadialConvergeX / RawWidth) + 0.5f) * Ratios.x + ConvergeX * invDims.x;
Output.CoordY = ((((TexCoord.y / Ratios.y) - 0.5f)) * (1.0f + RadialConvergeY / RawHeight) + 0.5f) * Ratios.y + ConvergeY * invDims.y;
Output.TexCoord = TexCoord;
return Output;
@ -120,17 +104,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
float2 TargetDims = float2(RawWidth, RawHeight);
float2 DimOffset = 0.0f / TargetDims;
float2 TexCoord = Input.TexCoord;
float2 RedCoord = Input.RedCoord;
float2 GrnCoord = Input.GrnCoord;
float2 BluCoord = Input.BluCoord;
float3 CoordX = Input.CoordX;
float3 CoordY = Input.CoordY;
RedCoord = lerp(TexCoord, RedCoord, Deconverge);
GrnCoord = lerp(TexCoord, GrnCoord, Deconverge);
BluCoord = lerp(TexCoord, BluCoord, Deconverge);
CoordX = lerp(TexCoord.x, CoordX, Deconverge);
CoordY = lerp(TexCoord.y, CoordY, Deconverge);
float RedTexel = tex2D(DiffuseSampler, RedCoord - DimOffset).r;
float GrnTexel = tex2D(DiffuseSampler, GrnCoord - DimOffset).g;
float BluTexel = tex2D(DiffuseSampler, BluCoord - DimOffset).b;
float RedTexel = tex2D(DiffuseSampler, float2(CoordX.x, CoordY.x) - DimOffset).r;
float GrnTexel = tex2D(DiffuseSampler, float2(CoordX.y, CoordY.y) - DimOffset).g;
float BluTexel = tex2D(DiffuseSampler, float2(CoordX.z, CoordY.z) - DimOffset).b;
//RedTexel *= Input.RedCoord.x < (WidthRatio / RawWidth) ? 0.0f : 1.0f;
//RedTexel *= Input.RedCoord.y < (HeightRatio / RawHeight) ? 0.0f : 1.0f;

20
hlsl/focus.fx
View File

@ -63,8 +63,7 @@ uniform float TargetHeight;
uniform float WidthRatio;
uniform float HeightRatio;
uniform float DefocusX;
uniform float DefocusY;
uniform float2 Defocus = float2(0.0f, 0.0f);
uniform float FocusEnable;
float2 Coord0Offset = float2( 0.0f, 0.0f);
@ -92,15 +91,14 @@ VS_OUTPUT vs_main(VS_INPUT Input)
float2 InvTexSize = float2(1.0f / TargetWidth, 1.0f / TargetHeight);
float2 TexCoord = Input.TexCoord;
TexCoord = TexCoord + 0.5f * InvTexSize;
float2 DefocusVal = float2(DefocusX, DefocusY);
Output.TexCoord0 = TexCoord + Coord0Offset * InvTexSize * DefocusVal;
Output.TexCoord1 = TexCoord + Coord1Offset * InvTexSize * DefocusVal;
Output.TexCoord2 = TexCoord + Coord2Offset * InvTexSize * DefocusVal;
Output.TexCoord3 = TexCoord + Coord3Offset * InvTexSize * DefocusVal;
Output.TexCoord4 = TexCoord + Coord4Offset * InvTexSize * DefocusVal;
Output.TexCoord5 = TexCoord + Coord5Offset * InvTexSize * DefocusVal;
Output.TexCoord6 = TexCoord + Coord6Offset * InvTexSize * DefocusVal;
Output.TexCoord7 = TexCoord + Coord7Offset * InvTexSize * DefocusVal;
Output.TexCoord0 = TexCoord + Coord0Offset * InvTexSize * Defocus;
Output.TexCoord1 = TexCoord + Coord1Offset * InvTexSize * Defocus;
Output.TexCoord2 = TexCoord + Coord2Offset * InvTexSize * Defocus;
Output.TexCoord3 = TexCoord + Coord3Offset * InvTexSize * Defocus;
Output.TexCoord4 = TexCoord + Coord4Offset * InvTexSize * Defocus;
Output.TexCoord5 = TexCoord + Coord5Offset * InvTexSize * Defocus;
Output.TexCoord6 = TexCoord + Coord6Offset * InvTexSize * Defocus;
Output.TexCoord7 = TexCoord + Coord7Offset * InvTexSize * Defocus;
return Output;
}

20
hlsl/post.fx
View File

@ -112,16 +112,8 @@ uniform float ShadowV = 0.375f;
uniform float ShadowWidth = 8.0f;
uniform float ShadowHeight = 8.0f;
uniform float RedFloor = 0.0f;
uniform float GrnFloor = 0.0f;
uniform float BluFloor = 0.0f;
uniform float SnapX = 0.0f;
uniform float SnapY = 0.0f;
uniform float RedPower = 2.2f;
uniform float GrnPower = 2.2f;
uniform float BluPower = 2.2f;
uniform float3 Power = float3(1.0f, 1.0f, 1.0f);
uniform float3 Floor = float3(0.0f, 0.0f, 0.0f);
float4 ps_main(PS_INPUT Input) : COLOR
{
@ -173,7 +165,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
float3 Scanned = BaseTexel.rgb * ScanBrightness;
// -- Color Compression (increasing the floor of the signal without affecting the ceiling) --
Scanned = float3(RedFloor + (1.0f - RedFloor) * Scanned.r, GrnFloor + (1.0f - GrnFloor) * Scanned.g, BluFloor + (1.0f - BluFloor) * Scanned.b);
Scanned = Floor + (1.0f - Floor) * Scanned;
float2 ShadowDims = float2(ShadowWidth, ShadowHeight);
float2 ShadowUV = float2(ShadowU, ShadowV);
@ -185,9 +177,9 @@ float4 ps_main(PS_INPUT Input) : COLOR
// -- Final Pixel --
float4 Output = float4(Scanned * lerp(1.0f, ShadowTexel, ShadowBrightness), BaseTexel.a) * Input.Color;
Output.r = pow(Output.r, RedPower);
Output.g = pow(Output.g, GrnPower);
Output.b = pow(Output.b, BluPower);
Output.r = pow(Output.r, Power.r);
Output.g = pow(Output.g, Power.g);
Output.b = pow(Output.b, Power.b);
return Output;
}

2
src/osd/windows/d3d8intf.c
View File

@ -638,7 +638,7 @@ static void d3d_effect_set_technique(d3d_effect *effect, const char *name)
}
static void d3d_effect_set_vector(d3d_effect *effect, const char *name, d3d_vector *vector)
static void d3d_effect_set_vector(d3d_effect *effect, const char *name, int count, float *vector)
{
assert(FALSE);
}

13
src/osd/windows/d3d9intf.c
View File

@ -717,10 +717,19 @@ static void d3d_effect_set_technique(d3d_effect *effect, const char *name)
}
static void d3d_effect_set_vector(d3d_effect *effect, const char *name, d3d_vector *vector)
static void d3d_effect_set_vector(d3d_effect *effect, const char *name, int count, float *vector)
{
static D3DXVECTOR4 out_vector;
ID3DXEffect *d3dfx = (ID3DXEffect*)effect;
d3dfx->SetVector(name, (D3DXVECTOR4*)vector);
if (count > 0)
out_vector.x = vector[0];
if (count > 1)
out_vector.y = vector[1];
if (count > 2)
out_vector.z = vector[2];
if (count > 3)
out_vector.w = vector[3];
d3dfx->SetVector(name, &out_vector);
}

429
src/osd/windows/d3dhlsl.c
View File

@ -82,86 +82,84 @@
// GLOBALS
//============================================================
static hlsl_options g_hlsl_presets[6] =
static hlsl_options g_hlsl_presets[4] =
{
{ 0.00f, 1, 1, 0.1875f, 0.1875f,
{ // 25% Shadow mask, 50% Scanlines, 3% Pincushion, 0 defocus, No Tint, 0.9 Exponent, 5% Floor, 25% Phosphor Return, 120% Saturation
0.25f, 320, 240, 0.09375f, 0.109375f,
0.03f, 0.03f,
0.25f, 1.0f, 1.0f, 0.6f, 0.0f,
0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f,
1.1f, 1.1f, 1.1f,
0.9f, 0.9f, 0.9f,
0.05f, 0.05f, 0.05f,
0.45f, 0.45f, 0.45f,
1.4f },
{ 0.15f, 512, 384, 0.1875f, 0.1875f,
0.5f, 1.0f, 0.5f, 1.0f, 0.0f, 0.0f,
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f },
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f },
{ 0.9f, 0.9f, 0.9f },
{ 0.05f,0.05f,0.05f},
{ 0.25f,0.25f,0.25f},
1.2f,
},
{ // 25% Shadow mask, 0% Scanlines, 3% Pincushion, 0 defocus, No Tint, 0.9 Exponent, 5% Floor, 25% Phosphor Return, 120% Saturation
0.25f, 320, 240, 0.09375f, 0.109375f,
0.03f, 0.03f,
0.25f, 1.0f, 1.0f, 0.6f, 0.0f,
0.0f, 1.0f, 0.5f, 1.0f, 0.0f, 0.0f,
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f },
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f },
{ 0.9f, 0.9f, 0.9f },
{ 0.05f,0.05f,0.05f},
{ 0.25f,0.25f,0.25f},
1.2f,
},
{ // 25% Shadow mask, 0% Scanlines, 0% Pincushion, 0 defocus, No Tint, 0.9 Exponent, 5% Floor, 25% Phosphor Return, 120% Saturation
0.25f, 320, 240, 0.09375f, 0.109375f,
0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f,
1.1f, 1.1f, 1.1f,
0.9f, 0.9f, 0.9f,
0.05f, 0.05f, 0.05f,
0.45f, 0.45f, 0.45f,
1.4f },
{ 0.15f, 512, 384, 0.1875f, 0.1875f,
0.03f, 0.03f,
0.25f, 1.0f, 1.0f, 0.6f, 0.0f,
0.0f, 0.0f,
0.4f, 0.1f, 0.0, 0.0f,-0.25f,-0.3f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f,
1.1f, 1.1f, 1.1f,
0.9f, 0.9f, 0.9f,
0.05f, 0.05f, 0.05f,
0.45f, 0.45f, 0.45f,
1.4f },
{ 0.15f, 512, 384, 0.1875f, 0.1875f,
0.03f, 0.03f,
0.25f, 1.0f, 1.0f, 0.6f, 0.0f,
0.0f, 0.0f,
0.4f, 0.1f, 0.0, 0.0f,-0.25f,-0.3f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
0.05f, 0.05f, 0.05f,
0.45f, 0.45f, 0.45f,
1.0f },
{ 0.15f, 512, 384, 0.1875f, 0.1875f,
0.03f, 0.03f,
0.25f, 1.0f, 1.0f, 0.6f, 0.0f,
0.0f, 0.0f,
0.4f, 0.1f, 0.0, 0.0f,-0.25f,-0.3f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
0.05f, 0.05f, 0.05f,
0.45f, 0.45f, 0.45f,
0.8f },
{ 0.15f, 512, 384, 0.1875f, 0.1875f,
0.03f, 0.03f,
0.25f, 1.0f, 1.0f, 0.6f, 0.0f,
0.0f, 0.0f,
0.4f, 0.1f, 0.0, 0.0f,-0.25f,-0.3f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.7f, 0.3f, 0.0f, 0.0f, 0.7f, 0.3f, 0.3f, 0.0f, 0.7f,
0.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
0.05f, 0.05f, 0.05f,
0.45f, 0.45f, 0.45f,
0.8f }
0.0f, 1.0f, 0.5f, 1.0f, 0.0f, 0.0f,
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f },
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f },
{ 0.9f, 0.9f, 0.9f },
{ 0.05f,0.05f,0.05f},
{ 0.25f,0.25f,0.25f},
1.2f,
},
{ // 25% Shadow mask, 100% Scanlines, 15% Pincushion, 3 defocus, 24-degree Tint Out, 1.5 Exponent, 5% Floor, 70% Phosphor Return, 80% Saturation, Bad Convergence
0.25f, 320, 240, 0.09375f, 0.109375f,
0.15f, 0.15f,
1.0f, 1.0f, 0.5f, 1.0f, 0.0f, 0.5f,
{ 3.0f, 3.0f, 3.0f, 3.0f },
{ 0.5f,-0.33f,0.7f },
{ 0.0f,-1.0f, 0.5f },
{ 0.0f, 0.2f, 0.3f },
{ 0.0f, 0.2f, 0.0f },
{ 0.8f, 0.2f, 0.0f },
{ 0.0f, 0.8f, 0.2f},
{ 0.2f, 0.0f, 0.8f},
{ 0.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f },
{ 1.5f, 1.5f, 1.5f },
{ 0.05f,0.05f,0.05f},
{ 0.7f, 0.7f, 0.7f},
0.8f,
},
};
static slider_state *g_slider_list;
@ -172,6 +170,7 @@ static slider_state *g_slider_list;
// PROTOTYPES
//============================================================
static void get_vector(const char *data, int count, float *out, int report_error);
static file_error open_next(d3d_info *d3d, emu_file &file, const char *extension, int idx);
@ -618,6 +617,7 @@ void hlsl_info::init(d3d *d3dintf, win_window_info *window)
prescale_size_x = 1;
prescale_size_y = 1;
preset = downcast<windows_options &>(window->machine().options()).d3d_hlsl_preset();
printf("%d\n", preset);
snap_width = downcast<windows_options &>(window->machine().options()).d3d_snap_width();
snap_height = downcast<windows_options &>(window->machine().options()).d3d_snap_height();
@ -641,18 +641,18 @@ void hlsl_info::init_fsfx_quad(void *vertbuf)
return;
// fill in the vertexes clockwise
windows_options &options = downcast<windows_options &>(window->machine().options());
float scale_top = options.screen_scale_top();
float scale_bottom = options.screen_scale_bottom();
fsfx_vertices[0].x = (d3d->width * (scale_top * 0.5f - 0.5f));
fsfx_vertices[0].x = 0.0f;
fsfx_vertices[0].y = 0.0f;
fsfx_vertices[1].x = d3d->width - (d3d->width * (scale_top * 0.5f - 0.5f));
fsfx_vertices[1].x = d3d->width;
fsfx_vertices[1].y = 0.0f;
fsfx_vertices[2].x = (d3d->width * (scale_bottom * 0.5f - 0.5f));
fsfx_vertices[2].x = 0.0f;
fsfx_vertices[2].y = d3d->height;
fsfx_vertices[3].x = d3d->width - (d3d->width * (scale_bottom * 0.5f - 0.5f));
fsfx_vertices[3].y = d3d->height;
fsfx_vertices[3].x = d3d->width;// - 1.5f;
fsfx_vertices[3].y = 0.0f;// - 1.5f;
fsfx_vertices[4].x = 0.0f;// - 1.5f;
fsfx_vertices[4].y = d3d->height;// - 1.5f;
fsfx_vertices[5].x = d3d->width;// - 1.5f;
fsfx_vertices[5].y = d3d->height;// - 1.5f;
fsfx_vertices[0].u0 = 0.0f;
fsfx_vertices[0].v0 = 0.0f;
@ -660,11 +660,15 @@ void hlsl_info::init_fsfx_quad(void *vertbuf)
fsfx_vertices[1].v0 = 0.0f;
fsfx_vertices[2].u0 = 0.0f;
fsfx_vertices[2].v0 = 1.0f;
fsfx_vertices[3].u0 = 1.0f;
fsfx_vertices[3].v0 = 1.0f;
fsfx_vertices[3].u0 = 1.0f;// + 0.5f / d3d->width;
fsfx_vertices[3].v0 = 0.0f;// + 0.5f / d3d->height;
fsfx_vertices[4].u0 = 0.0f;// + 0.5f / d3d->width;
fsfx_vertices[4].v0 = 1.0f;// + 0.5f / d3d->height;
fsfx_vertices[5].u0 = 1.0f;// + 0.5f / d3d->width;
fsfx_vertices[5].v0 = 1.0f;// + 0.5f / d3d->height;
// set the color, Z parameters to standard values
for (int i = 0; i < 4; i++)
for (int i = 0; i < 6; i++)
{
fsfx_vertices[i].z = 0.0f;
fsfx_vertices[i].rhw = 1.0f;
@ -741,44 +745,18 @@ int hlsl_info::create_resources()
options->scanline_bright_scale = winoptions.screen_scanline_bright_scale();
options->scanline_bright_offset = winoptions.screen_scanline_bright_offset();
options->scanline_offset = winoptions.screen_scanline_offset();
options->defocus_x = winoptions.screen_defocus_x();
options->defocus_y = winoptions.screen_defocus_y();
options->red_converge_x = winoptions.screen_red_converge_x();
options->red_converge_y = winoptions.screen_red_converge_y();
options->green_converge_x = winoptions.screen_green_converge_x();
options->green_converge_y = winoptions.screen_green_converge_y();
options->blue_converge_x = winoptions.screen_blue_converge_x();
options->blue_converge_y = winoptions.screen_blue_converge_y();
options->red_radial_converge_x = winoptions.screen_red_radial_converge_x();
options->red_radial_converge_y = winoptions.screen_red_radial_converge_y();
options->green_radial_converge_x = winoptions.screen_green_radial_converge_x();
options->green_radial_converge_y = winoptions.screen_green_radial_converge_y();
options->blue_radial_converge_x = winoptions.screen_blue_radial_converge_x();
options->blue_radial_converge_y = winoptions.screen_blue_radial_converge_y();
options->red_from_red = winoptions.screen_red_from_red();
options->red_from_green = winoptions.screen_red_from_green();
options->red_from_blue = winoptions.screen_red_from_blue();
options->green_from_red = winoptions.screen_green_from_red();
options->green_from_green = winoptions.screen_green_from_green();
options->green_from_blue = winoptions.screen_green_from_blue();
options->blue_from_red = winoptions.screen_blue_from_red();
options->blue_from_green = winoptions.screen_blue_from_green();
options->blue_from_blue = winoptions.screen_blue_from_blue();
options->red_offset = winoptions.screen_red_offset();
options->green_offset = winoptions.screen_green_offset();
options->blue_offset = winoptions.screen_blue_offset();
options->red_scale = winoptions.screen_red_scale();
options->green_scale = winoptions.screen_green_scale();
options->blue_scale = winoptions.screen_blue_scale();
options->red_power = winoptions.screen_red_power();
options->green_power = winoptions.screen_green_power();
options->blue_power = winoptions.screen_blue_power();
options->red_floor = winoptions.screen_red_floor();
options->green_floor = winoptions.screen_green_floor();
options->blue_floor = winoptions.screen_blue_floor();
options->red_phosphor_life = winoptions.screen_red_phosphor();
options->green_phosphor_life = winoptions.screen_green_phosphor();
options->blue_phosphor_life = winoptions.screen_blue_phosphor();
get_vector(winoptions.screen_defocus(), 2, options->defocus, TRUE);
get_vector(winoptions.screen_converge_x(), 3, options->converge_x, TRUE);
get_vector(winoptions.screen_converge_y(), 3, options->converge_y, TRUE);
get_vector(winoptions.screen_radial_converge_x(), 3, options->radial_converge_x, TRUE);
get_vector(winoptions.screen_radial_converge_y(), 3, options->radial_converge_y, TRUE);
get_vector(winoptions.screen_grn_ratio(), 3, options->grn_ratio, TRUE);
get_vector(winoptions.screen_blu_ratio(), 3, options->blu_ratio, TRUE);
get_vector(winoptions.screen_offset(), 3, options->offset, TRUE);
get_vector(winoptions.screen_scale(), 3, options->scale, TRUE);
get_vector(winoptions.screen_power(), 3, options->power, TRUE);
get_vector(winoptions.screen_floor(), 3, options->floor, TRUE);
get_vector(winoptions.screen_phosphor(), 3, options->phosphor, TRUE);
options->saturation = winoptions.screen_saturation();
}
else
@ -994,9 +972,7 @@ void hlsl_info::init_effect_info(d3d_poly_info *poly)
(*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "RedFloor", options->red_floor);
(*d3dintf->effect.set_float)(curr_effect, "GrnFloor", options->green_floor);
(*d3dintf->effect.set_float)(curr_effect, "BluFloor", options->blue_floor);
(*d3dintf->effect.set_vector)(curr_effect, "Floor", 3, options->floor);
(*d3dintf->effect.set_float)(curr_effect, "SnapX", snap_width);
(*d3dintf->effect.set_float)(curr_effect, "SnapY", snap_height);
(*d3dintf->effect.set_float)(curr_effect, "PincushionAmount", options->pincushion);
@ -1016,9 +992,7 @@ void hlsl_info::init_effect_info(d3d_poly_info *poly)
(*d3dintf->effect.set_float)(curr_effect, "ScanlineBrightScale", options->scanline_bright_scale);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineBrightOffset", options->scanline_bright_offset);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineOffset", (poly->texture->cur_frame == 0) ? 0.0f : options->scanline_offset);
(*d3dintf->effect.set_float)(curr_effect, "RedPower", options->red_power);
(*d3dintf->effect.set_float)(curr_effect, "GrnPower", options->green_power);
(*d3dintf->effect.set_float)(curr_effect, "BluPower", options->blue_power);
(*d3dintf->effect.set_vector)(curr_effect, "Power", 3, options->power);
}
else
{
@ -1083,7 +1057,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1124,7 +1098,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1146,21 +1120,11 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "YIQEnable", yiq_enable ? 1.0f : 0.0f);
(*d3dintf->effect.set_float)(curr_effect, "RedFromRed", options->red_from_red);
(*d3dintf->effect.set_float)(curr_effect, "RedFromGrn", options->red_from_green);
(*d3dintf->effect.set_float)(curr_effect, "RedFromBlu", options->red_from_blue);
(*d3dintf->effect.set_float)(curr_effect, "GrnFromRed", options->green_from_red);
(*d3dintf->effect.set_float)(curr_effect, "GrnFromGrn", options->green_from_green);
(*d3dintf->effect.set_float)(curr_effect, "GrnFromBlu", options->green_from_blue);
(*d3dintf->effect.set_float)(curr_effect, "BluFromRed", options->blue_from_red);
(*d3dintf->effect.set_float)(curr_effect, "BluFromGrn", options->blue_from_green);
(*d3dintf->effect.set_float)(curr_effect, "BluFromBlu", options->blue_from_blue);
(*d3dintf->effect.set_float)(curr_effect, "RedOffset", options->red_offset);
(*d3dintf->effect.set_float)(curr_effect, "GrnOffset", options->green_offset);
(*d3dintf->effect.set_float)(curr_effect, "BluOffset", options->blue_offset);
(*d3dintf->effect.set_float)(curr_effect, "RedScale", options->red_scale);
(*d3dintf->effect.set_float)(curr_effect, "GrnScale", options->green_scale);
(*d3dintf->effect.set_float)(curr_effect, "BluScale", options->blue_scale);
(*d3dintf->effect.set_vector)(curr_effect, "RedRatios", 3, options->red_ratio);
(*d3dintf->effect.set_vector)(curr_effect, "GrnRatios", 3, options->grn_ratio);
(*d3dintf->effect.set_vector)(curr_effect, "BluRatios", 3, options->blu_ratio);
(*d3dintf->effect.set_vector)(curr_effect, "Offset", 3, options->offset);
(*d3dintf->effect.set_vector)(curr_effect, "Scale", 3, options->scale);
(*d3dintf->effect.set_float)(curr_effect, "Saturation", options->saturation);
HRESULT result = (*d3dintf->device.set_render_target)(d3d->device, 0, smalltarget0[poly->texture->target_index]);
@ -1175,7 +1139,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1204,7 +1168,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1222,18 +1186,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
(*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
(*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_float)(curr_effect, "RedConvergeX", options->red_converge_x);
(*d3dintf->effect.set_float)(curr_effect, "RedConvergeY", options->red_converge_y);
(*d3dintf->effect.set_float)(curr_effect, "GrnConvergeX", options->green_converge_x);
(*d3dintf->effect.set_float)(curr_effect, "GrnConvergeY", options->green_converge_y);
(*d3dintf->effect.set_float)(curr_effect, "BluConvergeX", options->blue_converge_x);
(*d3dintf->effect.set_float)(curr_effect, "BluConvergeY", options->blue_converge_y);
(*d3dintf->effect.set_float)(curr_effect, "RedRadialConvergeX", options->red_radial_converge_x);
(*d3dintf->effect.set_float)(curr_effect, "RedRadialConvergeY", options->red_radial_converge_y);
(*d3dintf->effect.set_float)(curr_effect, "GrnRadialConvergeX", options->green_radial_converge_x);
(*d3dintf->effect.set_float)(curr_effect, "GrnRadialConvergeY", options->green_radial_converge_y);
(*d3dintf->effect.set_float)(curr_effect, "BluRadialConvergeX", options->blue_radial_converge_x);
(*d3dintf->effect.set_float)(curr_effect, "BluRadialConvergeY", options->blue_radial_converge_y);
(*d3dintf->effect.set_vector)(curr_effect, "ConvergeX", 3, options->converge_x);
(*d3dintf->effect.set_vector)(curr_effect, "ConvergeY", 3, options->converge_y);
(*d3dintf->effect.set_vector)(curr_effect, "RadialConvergeX", 3, options->radial_converge_x);
(*d3dintf->effect.set_vector)(curr_effect, "RadialConvergeY", 3, options->radial_converge_y);
(*d3dintf->effect.begin)(curr_effect, &num_passes, 0);
@ -1246,15 +1202,15 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
(*d3dintf->effect.end)(curr_effect);
float defocus_x = options->defocus_x;
float defocus_y = options->defocus_y;
float defocus_x = options->defocus[0];
float defocus_y = options->defocus[1];
bool focus_enable = defocus_x != 0.0f || defocus_y != 0.0f;
if(focus_enable)
{
@ -1269,8 +1225,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
(*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->ustop - poly->texture->ustart)) : 0.0f);
(*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->vstop - poly->texture->vstart)) : 0.0f);
(*d3dintf->effect.set_float)(curr_effect, "DefocusX", defocus_x);
(*d3dintf->effect.set_float)(curr_effect, "DefocusY", defocus_y);
(*d3dintf->effect.set_vector)(curr_effect, "Defocus", 2, &options->defocus[0]);
(*d3dintf->effect.set_float)(curr_effect, "FocusEnable", (defocus_x == 0.0f && defocus_y == 0.0f) ? 0.0f : 1.0f);
(*d3dintf->effect.begin)(curr_effect, &num_passes, 0);
@ -1284,7 +1239,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1301,8 +1256,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
(*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f);
(*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f);
(*d3dintf->effect.set_float)(curr_effect, "DefocusX", defocus_x);
(*d3dintf->effect.set_float)(curr_effect, "DefocusY", defocus_y);
(*d3dintf->effect.set_vector)(curr_effect, "Defocus", 2, &options->defocus[0]);
(*d3dintf->effect.set_float)(curr_effect, "FocusEnable", (defocus_x == 0.0f && defocus_y == 0.0f) ? 0.0f : 1.0f);
(*d3dintf->effect.begin)(curr_effect, &num_passes, 0);
@ -1314,7 +1268,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1331,9 +1285,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
(*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
(*d3dintf->effect.set_float)(curr_effect, "RedPhosphor", options->red_phosphor_life);
(*d3dintf->effect.set_float)(curr_effect, "GreenPhosphor", options->green_phosphor_life);
(*d3dintf->effect.set_float)(curr_effect, "BluePhosphor", options->blue_phosphor_life);
(*d3dintf->effect.set_vector)(curr_effect, "Phosphor", 3, options->phosphor);
(*d3dintf->effect.set_texture)(curr_effect, "Diffuse", focus_enable ? texture1[poly->texture->target_index] : texture2[poly->texture->target_index]);
(*d3dintf->effect.set_texture)(curr_effect, "LastPass", last_texture[poly->texture->target_index]);
@ -1349,7 +1301,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1375,7 +1327,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.begin_pass)(curr_effect, pass);
// add the primitives
result = (*d3dintf->device.draw_primitive)(d3d->device, poly->type, 0, poly->count);
result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLELIST, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
(*d3dintf->effect.end_pass)(curr_effect);
}
@ -1433,9 +1385,6 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
snap_rendered = true;
}
(*d3dintf->effect.set_float)(curr_effect, "SnapX", d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "SnapY", d3d->height);
/* Scanlines and shadow mask */
curr_effect = post_effect;
@ -1469,8 +1418,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "PostPass", 0.0f);
(*d3dintf->effect.set_float)(curr_effect, "PincushionAmountX", options->pincushion);
(*d3dintf->effect.set_float)(curr_effect, "PincushionAmountY", options->pincushion);
(*d3dintf->effect.set_float)(curr_effect, "PincushionAmount", options->pincushion);
(*d3dintf->effect.begin)(curr_effect, &num_passes, 0);
@ -1966,6 +1914,35 @@ void hlsl_info::delete_resources()
}
//============================================================
// get_vector
//============================================================
static void get_vector(const char *data, int count, float *out, int report_error)
{
if (count > 3)
{
if (sscanf(data, "%f,%f,%f,%f", &out[0], &out[1], &out[2], &out[3]) < 4 && report_error)
mame_printf_error("Illegal quad vector value = %s\n", data);
}
else if(count > 2)
{
if (sscanf(data, "%f,%f,%f", &out[0], &out[1], &out[2]) < 3 && report_error)
mame_printf_error("Illegal triple vector value = %s\n", data);
}
else if(count > 1)
{
if (sscanf(data, "%f,%f", &out[0], &out[1]) < 2 && report_error)
mame_printf_error("Illegal double vector value = %s\n", data);
}
else if(count > 0)
{
if (sscanf(data, "%f", &out[0]) < 1 && report_error)
mame_printf_error("Illegal single vector value = %s\n", data);
}
}
/*-------------------------------------------------
slider_alloc - allocate a new slider entry
currently duplicated from ui.c, this could
@ -2073,192 +2050,202 @@ static INT32 slider_scanline_offset(running_machine &machine, void *arg, astring
static INT32 slider_defocus_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->defocus_x), 0.5f, "%2.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->defocus[0]), 0.5f, "%2.1f", string, newval);
}
static INT32 slider_defocus_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->defocus_y), 0.5f, "%2.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->defocus[1]), 0.5f, "%2.1f", string, newval);
}
static INT32 slider_post_defocus_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->defocus[2]), 0.5f, "%2.1f", string, newval);
}
static INT32 slider_post_defocus_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->defocus[3]), 0.5f, "%2.1f", string, newval);
}
static INT32 slider_red_converge_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_converge_x), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->converge_x[0]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_red_converge_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_converge_y), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->converge_y[0]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_green_converge_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_converge_x), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->converge_x[1]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_green_converge_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_converge_y), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->converge_y[1]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_blue_converge_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_converge_x), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->converge_x[2]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_blue_converge_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_converge_y), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->converge_y[2]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_red_radial_converge_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_radial_converge_x), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->radial_converge_x[0]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_red_radial_converge_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_radial_converge_y), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->radial_converge_y[0]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_green_radial_converge_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_radial_converge_x), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->radial_converge_x[1]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_green_radial_converge_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_radial_converge_y), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->radial_converge_y[1]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_blue_radial_converge_x(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_radial_converge_x), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->radial_converge_x[2]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_blue_radial_converge_y(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_radial_converge_y), 0.1f, "%3.1f", string, newval);
return slider_set(&(((hlsl_options*)arg)->radial_converge_y[2]), 0.1f, "%3.1f", string, newval);
}
static INT32 slider_red_from_r(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_from_red), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->red_ratio[0]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_red_from_g(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_from_green), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->red_ratio[1]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_red_from_b(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_from_blue), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->red_ratio[2]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_green_from_r(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_from_red), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->grn_ratio[0]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_green_from_g(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_from_green), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->grn_ratio[1]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_green_from_b(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_from_blue), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->grn_ratio[2]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_blue_from_r(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_from_red), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->blu_ratio[0]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_blue_from_g(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_from_green), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->blu_ratio[1]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_blue_from_b(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_from_blue), 0.005f, "%2.3f", string, newval);
return slider_set(&(((hlsl_options*)arg)->blu_ratio[2]), 0.005f, "%2.3f", string, newval);
}
static INT32 slider_red_offset(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_offset), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->offset[0]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_green_offset(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_offset), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->offset[1]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_blue_offset(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_offset), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->offset[2]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_red_scale(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_scale), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->scale[0]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_green_scale(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_scale), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->scale[1]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_blue_scale(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_scale), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->scale[2]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_red_power(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_power), 0.05f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->power[0]), 0.05f, "%2.2f", string, newval);
}
static INT32 slider_green_power(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_power), 0.05f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->power[1]), 0.05f, "%2.2f", string, newval);
}
static INT32 slider_blue_power(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_power), 0.05f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->power[2]), 0.05f, "%2.2f", string, newval);
}
static INT32 slider_red_floor(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_floor), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->floor[0]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_green_floor(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_floor), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->floor[1]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_blue_floor(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_floor), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->floor[2]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_red_phosphor_life(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->red_phosphor_life), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->phosphor[0]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_green_phosphor_life(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->green_phosphor_life), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->phosphor[1]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_blue_phosphor_life(running_machine &machine, void *arg, astring *string, INT32 newval)
{
return slider_set(&(((hlsl_options*)arg)->blue_phosphor_life), 0.01f, "%2.2f", string, newval);
return slider_set(&(((hlsl_options*)arg)->phosphor[2]), 0.01f, "%2.2f", string, newval);
}
static INT32 slider_saturation(running_machine &machine, void *arg, astring *string, INT32 newval)
@ -2297,6 +2284,8 @@ slider_state *hlsl_info::init_slider_list()
*tailptr = slider_alloc(window->machine(), "Scanline Jitter", 0, 0, 40, 1, slider_scanline_offset, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Defocus X", 0, 0, 64, 1, slider_defocus_x, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Defocus Y", 0, 0, 64, 1, slider_defocus_y, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Phosphor Defocus X", 0, 0, 64, 1, slider_post_defocus_x, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Phosphor Defocus Y", 0, 0, 64, 1, slider_post_defocus_y, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Red Position Offset X", -1500, 0, 1500, 1, slider_red_converge_x, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Red Position Offset Y", -1500, 0, 1500, 1, slider_red_converge_y, (void*)options); tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(window->machine(), "Green Position Offset X", -1500, 0, 1500, 1, slider_green_converge_x, (void*)options); tailptr = &(*tailptr)->next;

51
src/osd/windows/d3dhlsl.h
View File

@ -68,44 +68,19 @@ struct _hlsl_options
float scanline_bright_scale;
float scanline_bright_offset;
float scanline_offset;
float defocus_x;
float defocus_y;
float red_converge_x;
float red_converge_y;
float green_converge_x;
float green_converge_y;
float blue_converge_x;
float blue_converge_y;
float red_radial_converge_x;
float red_radial_converge_y;
float green_radial_converge_x;
float green_radial_converge_y;
float blue_radial_converge_x;
float blue_radial_converge_y;
float red_from_red;
float red_from_green;
float red_from_blue;
float green_from_red;
float green_from_green;
float green_from_blue;
float blue_from_red;
float blue_from_green;
float blue_from_blue;
float red_offset;
float green_offset;
float blue_offset;
float red_scale;
float green_scale;
float blue_scale;
float red_power;
float green_power;
float blue_power;
float red_floor;
float green_floor;
float blue_floor;
float red_phosphor_life;
float green_phosphor_life;
float blue_phosphor_life;
float defocus[4];
float converge_x[3];
float converge_y[3];
float radial_converge_x[3];
float radial_converge_y[3];
float red_ratio[3];
float grn_ratio[3];
float blu_ratio[3];
float offset[3];
float scale[3];
float power[3];
float floor[3];
float phosphor[3];
float saturation;
};

2
src/osd/windows/d3dintf.h
View File

@ -258,7 +258,7 @@ struct _d3d_effect_interface
void (*begin_pass)(d3d_effect *effect, UINT pass);
void (*end_pass)(d3d_effect *effect);
void (*set_technique)(d3d_effect *effect, const char *name);
void (*set_vector)(d3d_effect *effect, const char *name, d3d_vector *vector);
void (*set_vector)(d3d_effect *effect, const char *name, int count, float *vector);
void (*set_float)(d3d_effect *effect, const char *name, float value);
void (*set_int)(d3d_effect *effect, const char *name, int value);
void (*set_matrix)(d3d_effect *effect, const char *name, d3d_matrix *matrix);

4
src/osd/windows/drawd3d.c
View File

@ -604,7 +604,7 @@ mtlog_add("drawd3d_window_draw: begin_scene");
// loop over primitives
if(d3d->hlsl->enabled())
{
d3d->hlsl_buf = (void*)primitive_alloc(d3d, 4);
d3d->hlsl_buf = (void*)primitive_alloc(d3d, 6);
d3d->hlsl->init_fsfx_quad(d3d->hlsl_buf);
}
@ -1655,7 +1655,7 @@ static void primitive_flush_pending(d3d_info *d3d)
// first remember the original render target in case we need to set a new one
if(d3d->hlsl->enabled() && d3dintf->post_fx_available)
{
vertnum = 4;
vertnum = 6;
}
else
{

61
src/osd/windows/winmain.c
View File

@ -331,7 +331,7 @@ const options_entry windows_options::s_option_entries[] =
{ WINOPTION_HLSL_ENABLE";hlsl", "0", OPTION_BOOLEAN, "enable HLSL post-processing (PS3.0 required)" },
{ WINOPTION_HLSLPATH, "hlsl", OPTION_STRING, "path to hlsl files" },
{ WINOPTION_HLSL_PRESCALE_SIZE, "3", OPTION_INTEGER, "HLSL scaling pre-pass factor (usually 2 or 3)" },
{ WINOPTION_HLSL_PRESET";(-1-5)", "-1", OPTION_INTEGER, "HLSL preset to use (0-5)" },
{ WINOPTION_HLSL_PRESET";(-1-3)", "-1", OPTION_INTEGER, "HLSL preset to use (0-3)" },
{ WINOPTION_HLSL_WRITE, NULL, OPTION_STRING, "enable HLSL AVI writing (huge disk bandwidth suggested)" },
{ WINOPTION_HLSL_SNAP_WIDTH, "2048", OPTION_STRING, "HLSL upscaled-snapshot width" },
{ WINOPTION_HLSL_SNAP_HEIGHT, "1536", OPTION_STRING, "HLSL upscaled-snapshot height" },
@ -342,8 +342,6 @@ const options_entry windows_options::s_option_entries[] =
{ WINOPTION_SHADOW_MASK_USIZE";fs_shadwu(0.0-1.0)", "0.09375", OPTION_FLOAT, "shadow mask texture size in U direction" },
{ WINOPTION_SHADOW_MASK_VSIZE";fs_shadwv(0.0-1.0)", "0.109375", OPTION_FLOAT, "shadow mask texture size in V direction" },
{ WINOPTION_CURVATURE";fs_curv(0.0-4.0)", "0.0", OPTION_FLOAT, "screen curvature amount" },
{ WINOPTION_SCREEN_SCALE_TOP";fs_scalex(0.0-2.0)", "1.0", OPTION_FLOAT, "screen scale, top" },
{ WINOPTION_SCREEN_SCALE_BOTTOM";fs_scaley(0.0-2.0)", "1.0", OPTION_FLOAT, "screen scale, bottom" },
/* Beam-related values below this line*/
{ WINOPTION_PINCUSHION";fs_pin(0.0-4.0)", "0.0", OPTION_FLOAT, "pincushion amount" },
{ WINOPTION_SCANLINE_AMOUNT";fs_scanam(0.0-4.0)", "0.0", OPTION_FLOAT, "overall alpha scaling value for scanlines" },
@ -352,52 +350,21 @@ const options_entry windows_options::s_option_entries[] =
{ WINOPTION_SCANLINE_BRIGHT_SCALE";fs_scanbs(0.0-2.0)", "1.0", OPTION_FLOAT, "overall brightness scaling value for scanlines (multiplicative)" },
{ WINOPTION_SCANLINE_BRIGHT_OFFSET";fs_scanbo(0.0-1.0)", "0.0", OPTION_FLOAT, "overall brightness offset value for scanlines (additive)" },
{ WINOPTION_SCANLINE_OFFSET";fs_scanjt(0.0-4.0)", "0.0", OPTION_FLOAT, "overall interlace jitter scaling value for scanlines" },
{ WINOPTION_DEFOCUS_X";fs_focusx(0.0-16.0)", "0.0", OPTION_FLOAT, "overall defocus scaling value in screen-relative X direction" },
{ WINOPTION_DEFOCUS_Y";fs_focusy(0.0-16.0)", "0.0", OPTION_FLOAT, "overall defocus scaling value in screen-relative Y direction" },
{ WINOPTION_RED_CONVERGE_X";fs_redcvx(-1.0-1.0)", "0.0", OPTION_FLOAT, "red convergence in screen-relative X direction" },
{ WINOPTION_RED_CONVERGE_Y";fs_redcvy(-1.0-1.0)", "0.0", OPTION_FLOAT, "red convergence in screen-relative Y direction" },
{ WINOPTION_GREEN_CONVERGE_X";fs_grncvx(-1.0-1.0)", "0.0", OPTION_FLOAT, "green convergence in screen-relative X direction" },
{ WINOPTION_GREEN_CONVERGE_Y";fs_grncvy(-1.0-1.0)", "0.0", OPTION_FLOAT, "green convergence in screen-relative Y direction" },
{ WINOPTION_BLUE_CONVERGE_X";fs_blucvx(-1.0-1.0)", "0.0", OPTION_FLOAT, "blue convergence in screen-relative X direction" },
{ WINOPTION_BLUE_CONVERGE_Y";fs_blucvy(-1.0-1.0)", "0.0", OPTION_FLOAT, "blue convergence in screen-relative Y direction" },
{ WINOPTION_RED_RADIAL_CONVERGE_X";fs_redrcvx(-16 - 16)", "0.0", OPTION_FLOAT, "red radial convergence in screen-relative X direction" },
{ WINOPTION_RED_RADIAL_CONVERGE_Y";fs_redrcvy(-16 - 16)", "0.0", OPTION_FLOAT, "red radial convergence in screen-relative Y direction" },
{ WINOPTION_GREEN_RADIAL_CONVERGE_X";fs_grnrcvx(-16 - 16)", "0.0", OPTION_FLOAT, "green radial convergence in screen-relative X direction" },
{ WINOPTION_GREEN_RADIAL_CONVERGE_Y";fs_grnrcvy(-16 - 16)", "0.0", OPTION_FLOAT, "green radial convergence in screen-relative Y direction" },
{ WINOPTION_BLUE_RADIAL_CONVERGE_X";fs_blurcvx(-16 - 16)", "0.0", OPTION_FLOAT, "blue radial convergence in screen-relative X direction" },
{ WINOPTION_BLUE_RADIAL_CONVERGE_Y";fs_blurcvy(-16 - 16)", "0.0", OPTION_FLOAT, "blue radial convergence in screen-relative Y direction" },
{ WINOPTION_DEFOCUS";fs_focus", "0.0,0.0", OPTION_STRING, "overall defocus value in screen-relative coords" },
{ WINOPTION_CONVERGE_X";fs_convx", "0.0,0.0,0.0",OPTION_STRING, "convergence in screen-relative X direction" },
{ WINOPTION_CONVERGE_Y";fs_convy", "0.0,0.0,0.0",OPTION_STRING, "convergence in screen-relative Y direction" },
{ WINOPTION_RADIAL_CONVERGE_X";fs_rconvx", "0.0,0.0,0.0",OPTION_STRING, "radial convergence in screen-relative X direction" },
{ WINOPTION_RADIAL_CONVERGE_Y";fs_rconvy", "0.0,0.0,0.0",OPTION_STRING, "radial convergence in screen-relative Y direction" },
/* RGB colorspace convolution below this line */
{ WINOPTION_RED_MATRIX_R";fs_matrr(-2.0-2.0)", "1.0", OPTION_FLOAT, "red output signal generated by red input signal" },
{ WINOPTION_RED_MATRIX_G";fs_matrg(-2.0-2.0)", "0.0", OPTION_FLOAT, "red output signal generated by green input signal" },
{ WINOPTION_RED_MATRIX_B";fs_matrb(-2.0-2.0)", "0.0", OPTION_FLOAT, "red output signal generated by blue input signal" },
{ WINOPTION_GREEN_MATRIX_R";fs_matgr(-2.0-2.0)", "0.0", OPTION_FLOAT, "green output signal generated by red input signal" },
{ WINOPTION_GREEN_MATRIX_G";fs_matgg(-2.0-2.0)", "1.0", OPTION_FLOAT, "green output signal generated by green input signal" },
{ WINOPTION_GREEN_MATRIX_B";fs_matgb(-2.0-2.0)", "0.0", OPTION_FLOAT, "green output signal generated by blue input signal" },
{ WINOPTION_BLUE_MATRIX_R";fs_matbr(-2.0-2.0)", "0.0", OPTION_FLOAT, "blue output signal generated by red input signal" },
{ WINOPTION_BLUE_MATRIX_G";fs_matbg(-2.0-2.0)", "0.0", OPTION_FLOAT, "blue output signal generated by green input signal" },
{ WINOPTION_BLUE_MATRIX_B";fs_matbb(-2.0-2.0)", "1.0", OPTION_FLOAT, "blue output signal generated by blue input signal" },
{ WINOPTION_GREEN_MATRIX_R";fs_matgr(-2.0-2.0)", "0.0", OPTION_FLOAT, "green output signal generated by red input signal" },
{ WINOPTION_GREEN_MATRIX_G";fs_matgg(-2.0-2.0)", "1.0", OPTION_FLOAT, "green output signal generated by green input signal" },
{ WINOPTION_GREEN_MATRIX_B";fs_matgb(-2.0-2.0)", "0.0", OPTION_FLOAT, "green output signal generated by blue input signal" },
{ WINOPTION_BLUE_MATRIX_R";fs_matbr(-2.0-2.0)", "0.0", OPTION_FLOAT, "blue output signal generated by red input signal" },
{ WINOPTION_BLUE_MATRIX_G";fs_matbg(-2.0-2.0)", "0.0", OPTION_FLOAT, "blue output signal generated by green input signal" },
{ WINOPTION_BLUE_MATRIX_B";fs_matbb(-2.0-2.0)", "1.0", OPTION_FLOAT, "blue output signal generated by blue input signal" },
{ WINOPTION_RED_RATIO";fs_redratio", "1.0,0.0,0.0",OPTION_STRING, "red output signal generated by input signal" },
{ WINOPTION_GRN_RATIO";fs_grnratio", "0.0,1.0,0.0",OPTION_STRING, "green output signal generated by input signal" },
{ WINOPTION_BLU_RATIO";fs_bluratio", "0.0,0.0,1.0",OPTION_STRING, "blue output signal generated by input signal" },
{ WINOPTION_SATURATION";fs_sat(0.0-4.0)", "1.0", OPTION_FLOAT, "saturation scaling value" },
{ WINOPTION_RED_OFFSET";fs_redoff(-1.0-1.0)", "0.0", OPTION_FLOAT, "red signal offset value (additive)" },
{ WINOPTION_GREEN_OFFSET";fs_grnoff(-1.0-1.0)", "0.0", OPTION_FLOAT, "green signal offset value (additive)" },
{ WINOPTION_BLUE_OFFSET";fs_bluoff(-1.0-1.0)", "0.0", OPTION_FLOAT, "blue signal offset value (additive)" },
{ WINOPTION_RED_SCALE";fs_redmul(0.0-2.0)", "1.0", OPTION_FLOAT, "red signal scaling value (multiplicative)" },
{ WINOPTION_GREEN_SCALE";fs_grnmul(0.0-2.0)", "1.0", OPTION_FLOAT, "green signal scaling value (multiplicative)" },
{ WINOPTION_BLUE_SCALE";fs_blumul(0.0-2.0)", "1.0", OPTION_FLOAT, "blue signal scaling value (multiplicative)" },
{ WINOPTION_RED_POWER";fs_redpow(0.01-4.0)", "1.0", OPTION_FLOAT, "red signal power value (exponential)" },
{ WINOPTION_GREEN_POWER";fs_grnpow(0.01-4.0)", "1.0", OPTION_FLOAT, "green signal power value (exponential)" },
{ WINOPTION_BLUE_POWER";fs_blupow(0.01-4.0)", "1.0", OPTION_FLOAT, "blue signal power value (exponential)" },
{ WINOPTION_RED_FLOOR";fs_redfl(0.0-1.0)", "0.0", OPTION_FLOAT, "red signal floor level" },
{ WINOPTION_GREEN_FLOOR";fs_grnfl(0.0-1.0)", "0.0", OPTION_FLOAT, "green signal floor level" },
{ WINOPTION_BLUE_FLOOR";fs_blufl(0.0-1.0)", "0.0", OPTION_FLOAT, "blue signal floor level" },
{ WINOPTION_RED_PHOSPHOR";fs_redpho(0.0-1.0)", "0.0", OPTION_FLOAT, "red phosphorescence decay rate (0.0 is instant, 1.0 is forever)" },
{ WINOPTION_GREEN_PHOSPHOR";fs_grnpho(0.0-1.0)", "0.0", OPTION_FLOAT, "green phosphorescence decay rate (0.0 is instant, 1.0 is forever)" },
{ WINOPTION_BLUE_PHOSPHOR";fs_grnpho(0.0-1.0)", "0.0", OPTION_FLOAT, "blue phosphorescence decay rate (0.0 is instant, 1.0 is forever)" },
{ WINOPTION_OFFSET";fs_offset", "0.0,0.0,0.0",OPTION_STRING, "signal offset value (additive)" },
{ WINOPTION_SCALE";fs_scale", "1.0,1.0,1.0",OPTION_STRING, "signal scaling value (multiplicative)" },
{ WINOPTION_POWER";fs_power", "1.0,1.0,1.0",OPTION_STRING, "signal power value (exponential)" },
{ WINOPTION_FLOOR";fs_floor", "0.0,0.0,0.0",OPTION_STRING, "signal floor level" },
{ WINOPTION_PHOSPHOR";fs_phosphor", "0.0,0.0,0.0",OPTION_STRING, "phosphorescence decay rate (0.0 is instant, 1.0 is forever)" },
/* NTSC simulation below this line */
{ WINOPTION_YIQ_ENABLE";yiq", "0", OPTION_BOOLEAN, "enable YIQ-space HLSL post-processing" },
{ WINOPTION_YIQ_CCVALUE";yiqcc", "3.59754545",OPTION_FLOAT, "Color Carrier frequency for NTSC signal processing" },

106
src/osd/windows/winmain.h
View File

@ -93,8 +93,6 @@
#define WINOPTION_SHADOW_MASK_USIZE "shadow_mask_usize"
#define WINOPTION_SHADOW_MASK_VSIZE "shadow_mask_vsize"
#define WINOPTION_PINCUSHION "pincushion"
#define WINOPTION_SCREEN_SCALE_TOP "screen_scale_top"
#define WINOPTION_SCREEN_SCALE_BOTTOM "screen_scale_bottom"
#define WINOPTION_CURVATURE "curvature"
#define WINOPTION_SCANLINE_AMOUNT "scanline_alpha"
#define WINOPTION_SCANLINE_SCALE "scanline_size"
@ -102,44 +100,19 @@
#define WINOPTION_SCANLINE_BRIGHT_SCALE "scanline_bright_scale"
#define WINOPTION_SCANLINE_BRIGHT_OFFSET "scanline_bright_offset"
#define WINOPTION_SCANLINE_OFFSET "scanline_jitter"
#define WINOPTION_DEFOCUS_X "defocus_x"
#define WINOPTION_DEFOCUS_Y "defocus_y"
#define WINOPTION_RED_CONVERGE_X "red_converge_x"
#define WINOPTION_RED_CONVERGE_Y "red_converge_y"
#define WINOPTION_GREEN_CONVERGE_X "green_converge_x"
#define WINOPTION_GREEN_CONVERGE_Y "green_converge_y"
#define WINOPTION_BLUE_CONVERGE_X "blue_converge_x"
#define WINOPTION_BLUE_CONVERGE_Y "blue_converge_y"
#define WINOPTION_RED_RADIAL_CONVERGE_X "red_radial_converge_x"
#define WINOPTION_RED_RADIAL_CONVERGE_Y "red_radial_converge_y"
#define WINOPTION_GREEN_RADIAL_CONVERGE_X "green_radial_converge_x"
#define WINOPTION_GREEN_RADIAL_CONVERGE_Y "green_radial_converge_y"
#define WINOPTION_BLUE_RADIAL_CONVERGE_X "blue_radial_converge_x"
#define WINOPTION_BLUE_RADIAL_CONVERGE_Y "blue_radial_converge_y"
#define WINOPTION_RED_MATRIX_R "red_from_r"
#define WINOPTION_RED_MATRIX_G "red_from_g"
#define WINOPTION_RED_MATRIX_B "red_from_b"
#define WINOPTION_GREEN_MATRIX_R "green_from_r"
#define WINOPTION_GREEN_MATRIX_G "green_from_g"
#define WINOPTION_GREEN_MATRIX_B "green_from_b"
#define WINOPTION_BLUE_MATRIX_R "blue_from_r"
#define WINOPTION_BLUE_MATRIX_G "blue_from_g"
#define WINOPTION_BLUE_MATRIX_B "blue_from_b"
#define WINOPTION_RED_OFFSET "red_offset"
#define WINOPTION_GREEN_OFFSET "green_offset"
#define WINOPTION_BLUE_OFFSET "blue_offset"
#define WINOPTION_RED_SCALE "red_scale"
#define WINOPTION_GREEN_SCALE "green_scale"
#define WINOPTION_BLUE_SCALE "blue_scale"
#define WINOPTION_RED_POWER "red_power"
#define WINOPTION_GREEN_POWER "green_power"
#define WINOPTION_BLUE_POWER "blue_power"
#define WINOPTION_RED_FLOOR "red_floor"
#define WINOPTION_GREEN_FLOOR "green_floor"
#define WINOPTION_BLUE_FLOOR "blue_floor"
#define WINOPTION_RED_PHOSPHOR "red_phosphor_life"
#define WINOPTION_GREEN_PHOSPHOR "green_phosphor_life"
#define WINOPTION_BLUE_PHOSPHOR "blue_phosphor_life"
#define WINOPTION_DEFOCUS "defocus"
#define WINOPTION_CONVERGE_X "converge_x"
#define WINOPTION_CONVERGE_Y "converge_y"
#define WINOPTION_RADIAL_CONVERGE_X "radial_converge_x"
#define WINOPTION_RADIAL_CONVERGE_Y "radial_converge_y"
#define WINOPTION_RED_RATIO "red_ratio"
#define WINOPTION_GRN_RATIO "grn_ratio"
#define WINOPTION_BLU_RATIO "blu_ratio"
#define WINOPTION_OFFSET "offset"
#define WINOPTION_SCALE "scale"
#define WINOPTION_POWER "power"
#define WINOPTION_FLOOR "floor"
#define WINOPTION_PHOSPHOR "phosphor_life"
#define WINOPTION_SATURATION "saturation"
#define WINOPTION_YIQ_ENABLE "yiq_enable"
#define WINOPTION_YIQ_CCVALUE "yiq_cc"
@ -237,32 +210,15 @@ public:
float screen_scanline_bright_offset() const { return float_value(WINOPTION_SCANLINE_BRIGHT_OFFSET); }
float screen_scanline_offset() const { return float_value(WINOPTION_SCANLINE_OFFSET); }
float screen_pincushion() const { return float_value(WINOPTION_PINCUSHION); }
float screen_scale_top() const { return float_value(WINOPTION_SCREEN_SCALE_TOP); }
float screen_scale_bottom() const { return float_value(WINOPTION_SCREEN_SCALE_BOTTOM); }
float screen_curvature() const { return float_value(WINOPTION_CURVATURE); }
float screen_defocus_x() const { return float_value(WINOPTION_DEFOCUS_X); }
float screen_defocus_y() const { return float_value(WINOPTION_DEFOCUS_Y); }
float screen_red_converge_x() const { return float_value(WINOPTION_RED_CONVERGE_X); }
float screen_red_converge_y() const { return float_value(WINOPTION_RED_CONVERGE_Y); }
float screen_green_converge_x() const { return float_value(WINOPTION_GREEN_CONVERGE_X); }
float screen_green_converge_y() const { return float_value(WINOPTION_GREEN_CONVERGE_Y); }
float screen_blue_converge_x() const { return float_value(WINOPTION_BLUE_CONVERGE_X); }
float screen_blue_converge_y() const { return float_value(WINOPTION_BLUE_CONVERGE_Y); }
float screen_red_radial_converge_x() const { return float_value(WINOPTION_RED_RADIAL_CONVERGE_X); }
float screen_red_radial_converge_y() const { return float_value(WINOPTION_RED_RADIAL_CONVERGE_Y); }
float screen_green_radial_converge_x() const { return float_value(WINOPTION_GREEN_RADIAL_CONVERGE_X); }
float screen_green_radial_converge_y() const { return float_value(WINOPTION_GREEN_RADIAL_CONVERGE_Y); }
float screen_blue_radial_converge_x() const { return float_value(WINOPTION_BLUE_RADIAL_CONVERGE_X); }
float screen_blue_radial_converge_y() const { return float_value(WINOPTION_BLUE_RADIAL_CONVERGE_Y); }
float screen_red_from_red() const { return float_value(WINOPTION_RED_MATRIX_R); }
float screen_red_from_green() const { return float_value(WINOPTION_RED_MATRIX_G); }
float screen_red_from_blue() const { return float_value(WINOPTION_RED_MATRIX_B); }
float screen_green_from_red() const { return float_value(WINOPTION_GREEN_MATRIX_R); }
float screen_green_from_green() const { return float_value(WINOPTION_GREEN_MATRIX_G); }
float screen_green_from_blue() const { return float_value(WINOPTION_GREEN_MATRIX_B); }
float screen_blue_from_red() const { return float_value(WINOPTION_BLUE_MATRIX_R); }
float screen_blue_from_green() const { return float_value(WINOPTION_BLUE_MATRIX_G); }
float screen_blue_from_blue() const { return float_value(WINOPTION_BLUE_MATRIX_B); }
const char *screen_defocus() const { return value(WINOPTION_DEFOCUS); }
const char *screen_converge_x() const { return value(WINOPTION_CONVERGE_X); }
const char *screen_converge_y() const { return value(WINOPTION_CONVERGE_Y); }
const char *screen_radial_converge_x() const { return value(WINOPTION_RADIAL_CONVERGE_X); }
const char *screen_radial_converge_y() const { return value(WINOPTION_RADIAL_CONVERGE_Y); }
const char *screen_red_ratio() const { return value(WINOPTION_RED_RATIO); }
const char *screen_grn_ratio() const { return value(WINOPTION_GRN_RATIO); }
const char *screen_blu_ratio() const { return value(WINOPTION_BLU_RATIO); }
bool screen_yiq_enable() const { return bool_value(WINOPTION_YIQ_ENABLE); }
float screen_yiq_cc() const { return float_value(WINOPTION_YIQ_CCVALUE); }
float screen_yiq_a() const { return float_value(WINOPTION_YIQ_AVALUE); }
@ -275,22 +231,12 @@ public:
float screen_yiq_q() const { return float_value(WINOPTION_YIQ_QVALUE); }
float screen_yiq_scan_time() const { return float_value(WINOPTION_YIQ_SCAN_TIME); }
int screen_yiq_phase_count() const { return int_value(WINOPTION_YIQ_PHASE_COUNT); }
float screen_red_offset() const { return float_value(WINOPTION_RED_OFFSET); }
float screen_green_offset() const { return float_value(WINOPTION_GREEN_OFFSET); }
float screen_blue_offset() const { return float_value(WINOPTION_BLUE_OFFSET); }
float screen_red_scale() const { return float_value(WINOPTION_RED_SCALE); }
float screen_green_scale() const { return float_value(WINOPTION_GREEN_SCALE); }
float screen_blue_scale() const { return float_value(WINOPTION_BLUE_SCALE); }
float screen_red_power() const { return float_value(WINOPTION_RED_POWER); }
float screen_green_power() const { return float_value(WINOPTION_GREEN_POWER); }
float screen_blue_power() const { return float_value(WINOPTION_BLUE_POWER); }
float screen_red_floor() const { return float_value(WINOPTION_RED_FLOOR); }
float screen_green_floor() const { return float_value(WINOPTION_GREEN_FLOOR); }
float screen_blue_floor() const { return float_value(WINOPTION_BLUE_FLOOR); }
const char *screen_offset() const { return value(WINOPTION_OFFSET); }
const char *screen_scale() const { return value(WINOPTION_SCALE); }
const char *screen_power() const { return value(WINOPTION_POWER); }
const char *screen_floor() const { return value(WINOPTION_FLOOR); }
const char *screen_phosphor() const { return value(WINOPTION_PHOSPHOR); }
float screen_saturation() const { return float_value(WINOPTION_SATURATION); }
float screen_red_phosphor() const { return float_value(WINOPTION_RED_PHOSPHOR); }
float screen_green_phosphor() const { return float_value(WINOPTION_GREEN_PHOSPHOR); }
float screen_blue_phosphor() const { return float_value(WINOPTION_BLUE_PHOSPHOR); }
// per-window options
const char *screen() const { return value(WINOPTION_SCREEN); }