summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--artwork/monochrome-matrix.pngbin33194 -> 33047 bytes
-rw-r--r--docs/hlsl.txt2
-rw-r--r--hlsl/artwork_support/distortion.fx101
-rw-r--r--hlsl/artwork_support/post.fx541
-rw-r--r--hlsl/deconverge.fx43
-rw-r--r--hlsl/distortion.fx52
-rw-r--r--hlsl/downsample.fx13
-rw-r--r--hlsl/focus.fx15
-rw-r--r--hlsl/ntsc.fx2
-rw-r--r--hlsl/phosphor.fx2
-rw-r--r--hlsl/post.fx72
-rw-r--r--hlsl/prescale.fx40
-rw-r--r--hlsl/primary.fx23
-rw-r--r--src/osd/modules/render/d3d/d3dcomm.h3
-rw-r--r--src/osd/modules/render/d3d/d3dhlsl.cpp191
-rw-r--r--src/osd/modules/render/d3d/d3dhlsl.h11
-rw-r--r--src/osd/modules/render/drawd3d.cpp267
-rw-r--r--src/osd/modules/render/drawd3d.h15
-rw-r--r--src/osd/windows/winmain.cpp2
-rw-r--r--src/osd/windows/winmain.h4
20 files changed, 381 insertions, 1018 deletions
diff --git a/artwork/monochrome-matrix.png b/artwork/monochrome-matrix.png
index c1180363087..f68ac273519 100644
--- a/artwork/monochrome-matrix.png
+++ b/artwork/monochrome-matrix.png
Binary files differ
diff --git a/docs/hlsl.txt b/docs/hlsl.txt
index d42f608c5c5..93fd8ca1ac4 100644
--- a/docs/hlsl.txt
+++ b/docs/hlsl.txt
@@ -8,8 +8,6 @@ yiq_enable 0/1 Enables YIQ-colorspace post-processing.
NTSC TV appearance on TV-based systems when configured
properly.
hlslpath [path] Path to the .fx files that are in use. (default: hlsl)
-hlsl_prescale_x [horizontal] HLSL pre-scale override factor for X. (0 for auto)
-hlsl_prescale_y [vertical] HLSL pre-scale override factor for Y. (0 for auto)
hlsl_write [filename] Enables HLSL AVI writing. (huge disk bandwidth suggested)
hlsl_snap_width [width] HLSL upscaled-snapshot width. (default: 2048)
hlsl_snap_height [height] HLSL upscaled-snapshot height. (default: 1536)
diff --git a/hlsl/artwork_support/distortion.fx b/hlsl/artwork_support/distortion.fx
deleted file mode 100644
index 333363afeb8..00000000000
--- a/hlsl/artwork_support/distortion.fx
+++ /dev/null
@@ -1,101 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:ImJezze
-//-----------------------------------------------------------------------------
-// Distortion Effect
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// Sampler Definitions
-//-----------------------------------------------------------------------------
-
-texture DiffuseTexture;
-
-sampler DiffuseSampler = sampler_state
-{
- Texture = <DiffuseTexture>;
- MipFilter = LINEAR;
- MinFilter = LINEAR;
- MagFilter = LINEAR;
- AddressU = CLAMP;
- AddressV = CLAMP;
- AddressW = CLAMP;
-};
-
-//-----------------------------------------------------------------------------
-// Vertex Definitions
-//-----------------------------------------------------------------------------
-
-struct VS_INPUT
-{
- float4 Position : POSITION;
- float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
-};
-
-struct VS_OUTPUT
-{
- float4 Position : POSITION;
- float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
-};
-
-struct PS_INPUT
-{
- float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
-};
-
-//-----------------------------------------------------------------------------
-// Distortion Vertex Shader
-//-----------------------------------------------------------------------------
-
-uniform float2 ScreenDims; // size of the window or fullscreen
-uniform float2 TargetDims;
-
-VS_OUTPUT vs_main(VS_INPUT Input)
-{
- VS_OUTPUT Output = (VS_OUTPUT)0;
-
- Output.Position = float4(Input.Position.xyz, 1.0f);
- Output.Position.xy /= ScreenDims;
- Output.Position.y = 1.0f - Output.Position.y; // flip y
- Output.Position.xy -= 0.5f; // center
- Output.Position.xy *= 2.0f; // zoom
-
- Output.Color = Input.Color;
-
- Output.TexCoord = Input.Position.xy / ScreenDims;
- Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
-
- return Output;
-}
-
-//-----------------------------------------------------------------------------
-// Post-Processing Pixel Shader
-//-----------------------------------------------------------------------------
-
-float4 ps_main(PS_INPUT Input) : COLOR
-{
- float2 BaseCoord = Input.TexCoord;
-
- // Color
- float4 BaseColor = tex2D(DiffuseSampler, BaseCoord);
- BaseColor.a = 1.0f;
-
- return BaseColor;
-}
-
-//-----------------------------------------------------------------------------
-// Distortion Effect
-//-----------------------------------------------------------------------------
-
-technique DefaultTechnique
-{
- pass Pass0
- {
- Lighting = FALSE;
-
- VertexShader = compile vs_3_0 vs_main();
- PixelShader = compile ps_3_0 ps_main();
- }
-} \ No newline at end of file
diff --git a/hlsl/artwork_support/post.fx b/hlsl/artwork_support/post.fx
deleted file mode 100644
index 7547d109788..00000000000
--- a/hlsl/artwork_support/post.fx
+++ /dev/null
@@ -1,541 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Ryan Holtz,ImJezze
-//-----------------------------------------------------------------------------
-// Scanline, Shadowmask & Distortion Effect
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// Sampler Definitions
-//-----------------------------------------------------------------------------
-
-texture DiffuseTexture;
-
-sampler DiffuseSampler = sampler_state
-{
- Texture = <DiffuseTexture>;
- MipFilter = LINEAR;
- MinFilter = LINEAR;
- MagFilter = LINEAR;
- AddressU = CLAMP;
- AddressV = CLAMP;
- AddressW = CLAMP;
-};
-
-texture ShadowTexture;
-
-sampler ShadowSampler = sampler_state
-{
- Texture = <ShadowTexture>;
- MipFilter = LINEAR;
- MinFilter = LINEAR;
- MagFilter = LINEAR;
- AddressU = WRAP;
- AddressV = WRAP;
- AddressW = WRAP;
-};
-
-//-----------------------------------------------------------------------------
-// Vertex Definitions
-//-----------------------------------------------------------------------------
-
-struct VS_INPUT
-{
- float4 Position : POSITION;
- float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
-};
-
-struct VS_OUTPUT
-{
- float4 Position : POSITION;
- float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
- float2 ScreenCoord : TEXCOORD1;
-};
-
-struct PS_INPUT
-{
- float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
- float2 ScreenCoord : TEXCOORD1;
-};
-
-//-----------------------------------------------------------------------------
-// Constants
-//-----------------------------------------------------------------------------
-
-static const float Epsilon = 1.0e-7f;
-static const float PI = 3.1415927f;
-static const float PHI = 1.618034f;
-static const float E = 2.7182817f;
-static const float Gelfond = 23.140692f; // e^pi (Gelfond constant)
-static const float GelfondSchneider = 2.6651442f; // 2^sqrt(2) (Gelfond-Schneider constant)
-
-//-----------------------------------------------------------------------------
-// Functions
-//-----------------------------------------------------------------------------
-
-// www.stackoverflow.com/questions/5149544/can-i-generate-a-random-number-inside-a-pixel-shader/
-float random(float2 seed)
-{
- // irrationals for pseudo randomness
- float2 i = float2(Gelfond, GelfondSchneider);
-
- return frac(cos(dot(seed, i)) * 123456.0f);
-}
-
-// www.dinodini.wordpress.com/2010/04/05/normalized-tunable-sigmoid-functions/
-float normalizedSigmoid(float n, float k)
-{
- // valid for n and k in range of -1.0 and 1.0
- return (n - n * k) / (k - abs(n) * 2.0f * k + 1);
-}
-
-// www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
-float roundBox(float2 p, float2 b, float r)
-{
- return length(max(abs(p) - b + r, 0.0f)) - r;
-}
-
-//-----------------------------------------------------------------------------
-// Scanline, Shadowmask & Distortion Vertex Shader
-//-----------------------------------------------------------------------------
-
-uniform float2 ScreenDims; // size of the window or fullscreen
-uniform float2 SourceDims; // size of the texture in power-of-two size
-uniform float2 SourceRect; // size of the uv rectangle
-uniform float2 TargetDims; // size of the target surface
-uniform float2 QuadDims; // size of the screen quad
-
-uniform float2 ShadowDims = float2(32.0f, 32.0f); // size of the shadow texture (extended to power-of-two size)
-uniform float2 ShadowUVOffset = float2(0.0f, 0.0f);
-
-uniform bool SwapXY = false;
-
-uniform int RotationType = 0; // 0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°
-
-uniform bool PrepareBloom = false; // disables some effects for rendering bloom textures
-uniform bool PrepareVector = false;
-
-VS_OUTPUT vs_main(VS_INPUT Input)
-{
- VS_OUTPUT Output = (VS_OUTPUT)0;
-
- float2 shadowUVOffset = ShadowUVOffset;
- shadowUVOffset = SwapXY
- ? shadowUVOffset.yx
- : shadowUVOffset.xy;
-
- float2 ScreenCoordOffset = 0.0f;
- ScreenCoordOffset += shadowUVOffset;
-
- Output.ScreenCoord = Input.Position.xy;
- Output.ScreenCoord += ScreenCoordOffset;
-
- Output.Position = float4(Input.Position.xyz, 1.0f);
- Output.Position.xy /= ScreenDims;
- Output.Position.y = 1.0f - Output.Position.y; // flip y
- Output.Position.xy -= 0.5f; // center
- Output.Position.xy *= 2.0f; // zoom
-
- Output.TexCoord = PrepareVector
- ? Input.Position.xy / ScreenDims
- : Input.TexCoord;
- Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
-
- Output.Color = Input.Color;
-
- return Output;
-}
-
-//-----------------------------------------------------------------------------
-// Scanline, Shadowmask & Distortion Pixel Shader
-//-----------------------------------------------------------------------------
-
-uniform float HumBarDesync = 60.0f / 59.94f - 1.0f; // difference between the 59.94 Hz field rate and 60 Hz line frequency (NTSC)
-uniform float HumBarAlpha = 0.0f;
-
-uniform float TimeMilliseconds = 0.0f;
-
-uniform float2 ScreenScale = float2(1.0f, 1.0f);
-uniform float2 ScreenOffset = float2(0.0f, 0.0f);
-
-uniform float ScanlineAlpha = 1.0f;
-uniform float ScanlineScale = 1.0f;
-uniform float ScanlineBrightScale = 1.0f;
-uniform float ScanlineBrightOffset = 1.0f;
-uniform float ScanlineOffset = 1.0f;
-uniform float ScanlineHeight = 1.0f;
-
-uniform float3 BackColor = float3(0.0f, 0.0f, 0.0f);
-
-uniform float CurvatureAmount = 1.0f;
-uniform float RoundCornerAmount = 0.0f;
-uniform float SmoothBorderAmount = 0.0f;
-uniform float VignettingAmount = 0.0f;
-uniform float ReflectionAmount = 0.0f;
-
-uniform int ShadowTileMode = 0; // 0 based on screen dimension, 1 based on source dimension
-uniform float ShadowAlpha = 0.0f;
-uniform float2 ShadowCount = float2(6.0f, 6.0f);
-uniform float2 ShadowUV = float2(0.25f, 0.25f);
-
-uniform float3 Power = float3(1.0f, 1.0f, 1.0f);
-uniform float3 Floor = float3(0.0f, 0.0f, 0.0f);
-
-float2 GetRatioCorrection()
-{
- if (PrepareVector)
- {
- float ScreenRatio = ScreenDims.x / ScreenDims.y;
- float QuadRatio = QuadDims.x / QuadDims.y;
- float ScreenQuadRatio = QuadRatio / ScreenRatio;
-
- return ScreenQuadRatio > 1.0f
- ? float2(1.0, 1.0f / ScreenQuadRatio)
- : float2(ScreenQuadRatio, 1.0);
- }
- else
- {
- return SourceRect;
- }
-}
-
-float GetNoiseFactor(float n, float random)
-{
- // smaller n become more noisy
- return 1.0f + random * max(0.0f, 0.25f * pow(E, -8 * n));
-}
-
-float GetVignetteFactor(float2 coord, float amount)
-{
- float2 VignetteCoord = coord;
-
- float VignetteLength = length(VignetteCoord);
- float VignetteBlur = (amount * 0.75f) + 0.25;
-
- // 0.5 full screen fitting circle
- float VignetteRadius = 1.0f - (amount * 0.25f);
- float Vignette = smoothstep(VignetteRadius, VignetteRadius - VignetteBlur, VignetteLength);
-
- return saturate(Vignette);
-}
-
-float GetSpotAddend(float2 coord, float amount)
-{
- float2 RatioCorrection = GetRatioCorrection();
-
- // normalized screen canvas ratio
- float2 CanvasRatio = PrepareVector
- ? float2(1.0f, QuadDims.y / QuadDims.x)
- : float2(1.0f, SwapXY
- ? QuadDims.x / QuadDims.y
- : QuadDims.y / QuadDims.x);
-
- // upper right quadrant
- float2 spotOffset = PrepareVector
- ? RotationType == 1 // 90°
- ? float2(-0.25f, -0.25f)
- : RotationType == 2 // 180°
- ? float2(0.25f, -0.25f)
- : RotationType == 3 // 270°
- ? float2(0.25f, 0.25f)
- : float2(-0.25f, 0.25f)
- : SwapXY
- ? float2(0.25f, 0.25f)
- : float2(-0.25f, 0.25f);
-
- float2 SpotCoord = coord;
- SpotCoord += spotOffset * RatioCorrection;
- SpotCoord *= CanvasRatio;
- SpotCoord /= RatioCorrection;
-
- float SpotBlur = amount;
-
- // 0.5 full screen fitting circle
- float SpotRadius = amount * 0.75f;
- float Spot = smoothstep(SpotRadius, SpotRadius - SpotBlur, length(SpotCoord));
-
- float SigmoidSpot = amount * normalizedSigmoid(Spot, 0.75);
-
- // increase strength by 100%
- SigmoidSpot = SigmoidSpot * 2.0f;
-
- return saturate(SigmoidSpot);
-}
-
-float GetRoundCornerFactor(float2 coord, float radiusAmount, float smoothAmount)
-{
- float2 RatioCorrection = GetRatioCorrection();
-
- // reduce smooth amount down to radius amount
- smoothAmount = min(smoothAmount, radiusAmount);
-
- float2 CanvasDims = PrepareVector
- ? ScreenDims
- : SwapXY
- ? QuadDims.yx / SourceRect
- : QuadDims.xy / SourceRect;
-
- coord = PrepareVector
- ? coord
- : coord - 1.0f / SourceDims; // alignment correction (raster graphics)
-
- float range = min(QuadDims.x, QuadDims.y) * 0.5;
- float radius = range * max(radiusAmount, 0.0025f);
- float smooth = 1.0 / (range * max(smoothAmount, 0.0025f));
-
- // compute box
- float box = roundBox(CanvasDims * (coord * 2.0f), CanvasDims * RatioCorrection, radius);
-
- // apply smooth
- box *= smooth;
- box += 1.0f - pow(smooth * 0.5f, 0.5f);
-
- float border = smoothstep(1.0f, 0.0f, box);
-
- return saturate(border);
-}
-
-// www.francois-tarlier.com/blog/cubic-lens-distortion-shader/
-float2 GetDistortedCoords(float2 centerCoord, float amount)
-{
- // lens distortion coefficient
- float k = amount;
-
- // cubic distortion value
- float kcube = amount * 2.0f;
-
- // compute cubic distortion factor
- float r2 = centerCoord.x * centerCoord.x + centerCoord.y * centerCoord.y;
- float f = kcube == 0.0f
- ? 1.0f + r2 * k
- : 1.0f + r2 * (k + kcube * sqrt(r2));
-
- // fit screen bounds
- f /= 1.0f + amount * 0.5f;
-
- // apply cubic distortion factor
- centerCoord *= f;
-
- return centerCoord;
-}
-
-float2 GetCoords(float2 coord, float2 centerOffset, float distortionAmount)
-{
- float2 RatioCorrection = GetRatioCorrection();
-
- // center coordinates
- coord -= centerOffset;
-
- // apply ratio difference between screen and quad
- coord /= RatioCorrection;
-
- // distort coordinates
- coord = GetDistortedCoords(coord, distortionAmount);
-
- // revert ratio difference between screen and quad
- coord *= RatioCorrection;
-
- // un-center coordinates
- coord += centerOffset;
-
- return coord;
-}
-
-float2 GetAdjustedCoords(float2 coord, float2 centerOffset, float distortionAmount)
-{
- float2 RatioCorrection = GetRatioCorrection();
-
- // center coordinates
- coord -= centerOffset;
-
- // apply ratio difference between screen and quad
- coord /= RatioCorrection;
-
- // apply screen scale
- coord /= ScreenScale;
-
- // distort coordinates
- coord = GetDistortedCoords(coord, distortionAmount);
-
- // revert ratio difference between screen and quad
- coord *= RatioCorrection;
-
- // un-center coordinates
- coord += centerOffset;
-
- // apply screen offset
- coord += (centerOffset * 2.0) * ScreenOffset;
-
- return coord;
-}
-
-float4 ps_main(PS_INPUT Input) : COLOR
-{
- float2 ScreenTexelDims = 1.0f / ScreenDims;
- float2 SourceTexelDims = 1.0f / SourceDims;
-
- float2 HalfSourceRect = SourceRect * 0.5f;
-
- float2 ScreenCoord = Input.ScreenCoord / ScreenDims;
- ScreenCoord = GetCoords(ScreenCoord, float2(0.5f, 0.5f), CurvatureAmount * 0.25f); // reduced amount
-
- float2 DistortionCoord = Input.TexCoord;
- DistortionCoord = GetCoords(DistortionCoord, HalfSourceRect, CurvatureAmount * 0.25f); // reduced amount
-
- float2 BaseCoord = Input.TexCoord;
- BaseCoord = GetAdjustedCoords(BaseCoord, HalfSourceRect, CurvatureAmount * 0.25f); // reduced amount
-
- float2 DistortionCoordCentered = DistortionCoord;
- DistortionCoordCentered -= HalfSourceRect;
-
- float2 BaseCoordCentered = BaseCoord;
- BaseCoordCentered -= HalfSourceRect;
-
- float4 BaseColor = tex2D(DiffuseSampler, BaseCoord);
- BaseColor.a = 1.0f;
-
- if (BaseCoord.x < 0.0f || BaseCoord.y < 0.0f)
- {
- BaseColor.rgb = 0.0f;
- }
-
- // Mask Simulation (may not affect bloom)
- if (!PrepareBloom && ShadowAlpha > 0.0f)
- {
- float2 shadowDims = ShadowDims;
- shadowDims = SwapXY
- ? shadowDims.yx
- : shadowDims.xy;
-
- float2 shadowUV = ShadowUV;
- // shadowUV = SwapXY
- // ? shadowUV.yx
- // : shadowUV.xy;
-
- float2 screenCoord = ShadowTileMode == 0 ? ScreenCoord : BaseCoord;
- screenCoord = SwapXY
- ? screenCoord.yx
- : screenCoord.xy;
-
- float2 shadowCount = ShadowCount;
- shadowCount = SwapXY
- ? shadowCount.yx
- : shadowCount.xy;
-
- float2 shadowTile = ((ShadowTileMode == 0 ? ScreenTexelDims : SourceTexelDims) * shadowCount);
- shadowTile = SwapXY
- ? shadowTile.yx
- : shadowTile.xy;
-
- float2 ShadowFrac = frac(screenCoord / shadowTile);
- float2 ShadowCoord = (ShadowFrac * shadowUV);
- ShadowCoord += 0.5f / shadowDims; // half texel offset
- // ShadowCoord = SwapXY
- // ? ShadowCoord.yx
- // : ShadowCoord.xy;
-
- float4 ShadowColor = tex2D(ShadowSampler, ShadowCoord);
- float3 ShadowMaskColor = lerp(1.0f, ShadowColor.rgb, ShadowAlpha);
- float ShadowMaskClear = (1.0f - ShadowColor.a) * ShadowAlpha;
-
- // apply shadow mask color
- BaseColor.rgb *= ShadowMaskColor;
- // clear shadow mask by background color
- BaseColor.rgb = lerp(BaseColor.rgb, BackColor, ShadowMaskClear);
- }
-
- // Color Compression (may not affect bloom)
- if (!PrepareBloom)
- {
- // increasing the floor of the signal without affecting the ceiling
- BaseColor.rgb = Floor + (1.0f - Floor) * BaseColor.rgb;
- }
-
- // Color Power (may affect bloom)
- BaseColor.r = pow(BaseColor.r, Power.r);
- BaseColor.g = pow(BaseColor.g, Power.g);
- BaseColor.b = pow(BaseColor.b, Power.b);
-
- // Scanline Simulation (may not affect bloom)
- if (!PrepareBloom)
- {
- // Scanline Simulation (may not affect vector screen)
- if (!PrepareVector && ScanlineAlpha > 0.0f)
- {
- float BrightnessOffset = (ScanlineBrightOffset * ScanlineAlpha);
- float BrightnessScale = (ScanlineBrightScale * ScanlineAlpha) + (1.0f - ScanlineAlpha);
-
- float ColorBrightness = 0.299f * BaseColor.r + 0.587f * BaseColor.g + 0.114 * BaseColor.b;
-
- float ScanlineCoord = BaseCoord.y * SourceDims.y * ScanlineScale * PI;
- float ScanlineCoordJitter = ScanlineOffset * PHI;
- float ScanlineSine = sin(ScanlineCoord + ScanlineCoordJitter);
- float ScanlineWide = ScanlineHeight + max(1.0f, ScanlineHeight) * (1.0f - ColorBrightness);
- float ScanlineAmount = pow(ScanlineSine * ScanlineSine, ScanlineWide);
- float ScanlineBrightness = ScanlineAmount * BrightnessScale + BrightnessOffset * BrightnessScale;
-
- BaseColor.rgb *= lerp(1.0f, ScanlineBrightness, ScanlineAlpha);
- }
-
- // Hum Bar Simulation (may not affect vector screen)
- if (!PrepareVector && HumBarAlpha > 0.0f)
- {
- float HumBarStep = frac(TimeMilliseconds * HumBarDesync);
- float HumBarBrightness = 1.0 - frac(BaseCoord.y / SourceRect.y + HumBarStep) * HumBarAlpha;
- BaseColor.rgb *= HumBarBrightness;
- }
- }
-
- // Output
- float4 Output = PrepareVector
- ? BaseColor * (Input.Color + float4(1.0f, 1.0f, 1.0f, 0.0f))
- : BaseColor * Input.Color;
- Output.a = 1.0f;
-
- // Vignetting Simulation (may not affect bloom)
- if (!PrepareBloom)
- {
- float2 VignetteCoord = DistortionCoordCentered;
-
- float VignetteFactor = GetVignetteFactor(VignetteCoord, VignettingAmount);
- Output.rgb *= VignetteFactor;
- }
-
- // Light Reflection Simulation (may not affect bloom)
- if (!PrepareBloom)
- {
- float3 LightColor = float3(1.0f, 0.90f, 0.80f);
-
- float2 SpotCoord = DistortionCoordCentered;
- float2 NoiseCoord = DistortionCoordCentered;
-
- float SpotAddend = GetSpotAddend(SpotCoord, ReflectionAmount);
- float NoiseFactor = GetNoiseFactor(SpotAddend, random(NoiseCoord));
- Output.rgb += SpotAddend * NoiseFactor * LightColor;
- }
-
- // Round Corners Simulation (may affect bloom)
- float2 RoundCornerCoord = DistortionCoordCentered;
-
- float roundCornerFactor = GetRoundCornerFactor(RoundCornerCoord, RoundCornerAmount, SmoothBorderAmount);
- Output.rgb *= roundCornerFactor;
-
- return Output;
-}
-
-//-----------------------------------------------------------------------------
-// Scanline & Shadowmask Effect
-//-----------------------------------------------------------------------------
-
-technique DefaultTechnique
-{
- pass Pass0
- {
- Lighting = FALSE;
-
- VertexShader = compile vs_3_0 vs_main();
- PixelShader = compile ps_3_0 ps_main();
- }
-} \ No newline at end of file
diff --git a/hlsl/deconverge.fx b/hlsl/deconverge.fx
index 3c1cbeeeb1f..df5bc2e6b49 100644
--- a/hlsl/deconverge.fx
+++ b/hlsl/deconverge.fx
@@ -68,48 +68,47 @@ VS_OUTPUT vs_main(VS_INPUT Input)
{
VS_OUTPUT Output = (VS_OUTPUT)0;
- float2 HalfSourceRect = SourceRect * 0.5f;
-
- float2 QuadRatio =
- float2(1.0f, SwapXY
- ? QuadDims.y / QuadDims.x
- : QuadDims.x / QuadDims.y);
-
- // imaginary texel dimensions independed from quad dimensions, but dependend on quad ratio
- float2 FixedTexelDims = (1.0f / 1024.0) * SourceRect * QuadRatio;
-
Output.Position = float4(Input.Position.xyz, 1.0f);
Output.Position.xy /= ScreenDims;
Output.Position.y = 1.0f - Output.Position.y; // flip y
Output.Position.xy -= 0.5f; // center
Output.Position.xy *= 2.0f; // toom
- float2 TexCoord = Input.TexCoord;
+ float2 TexCoord = Input.Position.xy / ScreenDims;
TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
-
- Output.Color = Input.Color;
+
+ // we have to handle the swap of the coordinates ourself, because we are using screen not texture coordinates
+ float3 convergeX = SwapXY ? ConvergeY : ConvergeX;
+ float3 convergeY = SwapXY ? ConvergeX : ConvergeY;
+ float3 radialConvergeX = SwapXY ? RadialConvergeY : RadialConvergeX;
+ float3 radialConvergeY = SwapXY ? RadialConvergeX : RadialConvergeY;
+
+ // imaginary texel dimensions independed from screen dimension, but ratio
+ float2 TexelDims = (1.0f / 1024) * (QuadDims / ScreenDims);
Output.TexCoordX = TexCoord.xxx;
Output.TexCoordY = TexCoord.yyy;
// center coordinates
- Output.TexCoordX -= HalfSourceRect.xxx;
- Output.TexCoordY -= HalfSourceRect.yyy;
+ Output.TexCoordX -= 0.5f * SourceRect.xxx;
+ Output.TexCoordY -= 0.5f * SourceRect.yyy;
// radial converge offset to "translate" the most outer pixel as thay would be translated by the linar converge with the same amount
float2 radialConvergeOffset = 2.0f / SourceRect;
// radial converge
- Output.TexCoordX *= 1.0f + RadialConvergeX * FixedTexelDims.xxx * radialConvergeOffset.xxx;
- Output.TexCoordY *= 1.0f + RadialConvergeY * FixedTexelDims.yyy * radialConvergeOffset.yyy;
-
+ Output.TexCoordX *= 1.0f + radialConvergeX * TexelDims.xxx * radialConvergeOffset.xxx;
+ Output.TexCoordY *= 1.0f + radialConvergeY * TexelDims.yyy * radialConvergeOffset.yyy;
+
// un-center coordinates
- Output.TexCoordX += HalfSourceRect.xxx;
- Output.TexCoordY += HalfSourceRect.yyy;
+ Output.TexCoordX += 0.5f * SourceRect.xxx;
+ Output.TexCoordY += 0.5f * SourceRect.yyy;
// linear converge
- Output.TexCoordX += ConvergeX * FixedTexelDims.xxx;
- Output.TexCoordY += ConvergeY * FixedTexelDims.yyy;
+ Output.TexCoordX += convergeX * TexelDims.xxx;
+ Output.TexCoordY += convergeY * TexelDims.yyy;
+
+ Output.Color = Input.Color;
return Output;
}
diff --git a/hlsl/distortion.fx b/hlsl/distortion.fx
index 63d35789393..6fd27a99795 100644
--- a/hlsl/distortion.fx
+++ b/hlsl/distortion.fx
@@ -119,7 +119,7 @@ uniform float ReflectionAmount = 0.0f;
uniform int RotationType = 0; // 0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°
-float2 GetRatioCorrection()
+float2 GetScreenQuadRatio()
{
float ScreenRatio = ScreenDims.x / ScreenDims.y;
float QuadRatio = QuadDims.x / QuadDims.y;
@@ -130,6 +130,15 @@ float2 GetRatioCorrection()
: float2(ScreenQuadRatio, 1.0);
}
+float2 GetQuadRatio()
+{
+ float QuadRatio = QuadDims.x / QuadDims.y;
+
+ return QuadRatio > 1.0f
+ ? float2 (1.0f, 1.0f / QuadRatio)
+ : float2 (QuadRatio, 1.0f);
+}
+
float GetNoiseFactor(float3 n, float random)
{
// smaller n become more noisy
@@ -138,7 +147,7 @@ float GetNoiseFactor(float3 n, float random)
float GetVignetteFactor(float2 coord, float amount)
{
- float2 VignetteCoord = coord;
+ float2 VignetteCoord = coord / (QuadDims / ScreenDims);
float VignetteLength = length(VignetteCoord);
float VignetteBlur = (amount * 0.75f) + 0.25;
@@ -152,10 +161,7 @@ float GetVignetteFactor(float2 coord, float amount)
float GetSpotAddend(float2 coord, float amount)
{
- float2 RatioCorrection = GetRatioCorrection();
-
- // normalized screen quad ratio
- float2 QuadRatio = float2 (1.0f, QuadDims.y / QuadDims.x);
+ float2 QuadRatio = GetQuadRatio();
// upper right quadrant
float2 spotOffset =
@@ -167,10 +173,9 @@ float GetSpotAddend(float2 coord, float amount)
? float2(0.25f, 0.25f)
: float2(-0.25f, 0.25f);
- float2 SpotCoord = coord;
- SpotCoord += spotOffset * RatioCorrection;
+ float2 SpotCoord = coord / (QuadDims / ScreenDims);
+ SpotCoord += spotOffset * QuadRatio;
SpotCoord *= QuadRatio;
- SpotCoord /= RatioCorrection;
float SpotBlur = amount;
@@ -188,7 +193,7 @@ float GetSpotAddend(float2 coord, float amount)
float GetRoundCornerFactor(float2 coord, float radiusAmount, float smoothAmount)
{
- float2 RatioCorrection = GetRatioCorrection();
+ float2 ScreenQuadRatio = GetScreenQuadRatio();
// reduce smooth amount down to radius amount
smoothAmount = min(smoothAmount, radiusAmount);
@@ -198,7 +203,7 @@ float GetRoundCornerFactor(float2 coord, float radiusAmount, float smoothAmount)
float smooth = 1.0 / (range * max(smoothAmount, 0.0025f));
// compute box
- float box = roundBox(ScreenDims * (coord * 2.0f), ScreenDims * RatioCorrection, radius);
+ float box = roundBox(ScreenDims * (coord * 2.0f), ScreenDims * ScreenQuadRatio, radius);
// apply smooth
box *= smooth;
@@ -235,19 +240,19 @@ float2 GetDistortedCoords(float2 centerCoord, float amount)
float2 GetCoords(float2 coord, float distortionAmount)
{
- float2 RatioCorrection = GetRatioCorrection();
+ float2 ScreenQuadRatio = GetScreenQuadRatio();
// center coordinates
coord -= 0.5f;
// apply ratio difference between screen and quad
- coord /= RatioCorrection;
+ coord /= ScreenQuadRatio;
// distort coordinates
coord = GetDistortedCoords(coord, distortionAmount);
// revert ratio difference between screen and quad
- coord *= RatioCorrection;
+ coord *= ScreenQuadRatio;
// un-center coordinates
coord += 0.5f;
@@ -257,21 +262,18 @@ float2 GetCoords(float2 coord, float distortionAmount)
float4 ps_main(PS_INPUT Input) : COLOR
{
- float2 TexCoord = Input.TexCoord;
- float2 BaseCoord = TexCoord;
-
// Screen Curvature
- BaseCoord = GetCoords(BaseCoord, CurvatureAmount * 0.25f); // reduced amount
+ float2 TexCoord = GetCoords(Input.TexCoord, CurvatureAmount * 0.25f); // reduced amount
- float2 BaseCoordCentered = BaseCoord;
- BaseCoordCentered -= 0.5f;
+ float2 TexCoordCentered = TexCoord;
+ TexCoordCentered -= 0.5f;
// Color
- float4 BaseColor = tex2D(DiffuseSampler, BaseCoord);
+ float4 BaseColor = tex2D(DiffuseSampler, TexCoord);
BaseColor.a = 1.0f;
// Vignetting Simulation
- float2 VignetteCoord = BaseCoordCentered;
+ float2 VignetteCoord = TexCoordCentered;
float VignetteFactor = GetVignetteFactor(VignetteCoord, VignettingAmount);
BaseColor.rgb *= VignetteFactor;
@@ -279,15 +281,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
// Light Reflection Simulation
float3 LightColor = float3(1.0f, 0.90f, 0.80f); // color temperature 5.000 Kelvin
- float2 SpotCoord = BaseCoordCentered;
- float2 NoiseCoord = BaseCoordCentered;
+ float2 SpotCoord = TexCoordCentered;
+ float2 NoiseCoord = TexCoordCentered;
float SpotAddend = GetSpotAddend(SpotCoord, ReflectionAmount);
float NoiseFactor = GetNoiseFactor(SpotAddend, random(NoiseCoord));
BaseColor.rgb += SpotAddend * NoiseFactor * LightColor;
// Round Corners Simulation
- float2 RoundCornerCoord = BaseCoordCentered;
+ float2 RoundCornerCoord = TexCoordCentered;
float roundCornerFactor = GetRoundCornerFactor(RoundCornerCoord, RoundCornerAmount, SmoothBorderAmount);
BaseColor.rgb *= roundCornerFactor;
diff --git a/hlsl/downsample.fx b/hlsl/downsample.fx
index 6cb18f53935..3afcdc703dd 100644
--- a/hlsl/downsample.fx
+++ b/hlsl/downsample.fx
@@ -53,9 +53,11 @@ struct PS_INPUT
uniform float2 ScreenDims;
uniform float2 TargetDims;
+uniform float2 SourceDims;
uniform float2 SourceRect;
+uniform float2 QuadDims;
-uniform bool PrepareVector;
+uniform bool VectorScreen;
static const float2 Coord0Offset = float2(-0.5f, -0.5f);
static const float2 Coord1Offset = float2( 0.5f, -0.5f);
@@ -67,6 +69,8 @@ VS_OUTPUT vs_main(VS_INPUT Input)
VS_OUTPUT Output = (VS_OUTPUT)0;
float2 TargetTexelDims = 1.0f / TargetDims;
+ float2 ScreenTexelDims = 1.0f / ScreenDims;
+ float2 SourceTexelDims = 1.0f / SourceDims;
Output.Position = float4(Input.Position.xyz, 1.0f);
Output.Position.xy /= ScreenDims;
@@ -79,6 +83,13 @@ VS_OUTPUT vs_main(VS_INPUT Input)
float2 TexCoord = Input.Position.xy / ScreenDims;
TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
+ float2 VectorTexelOffset = ScreenTexelDims * -0.5;
+ float2 RasterTexelOffset = SourceTexelDims * (0.5f * SourceRect) * (1.0f - (QuadDims / ScreenDims));
+
+ TexCoord += VectorScreen
+ ? VectorTexelOffset
+ : RasterTexelOffset;
+
Output.TexCoord01.xy = TexCoord + Coord0Offset * TargetTexelDims;
Output.TexCoord01.zw = TexCoord + Coord1Offset * TargetTexelDims;
Output.TexCoord23.xy = TexCoord + Coord2Offset * TargetTexelDims;
diff --git a/hlsl/focus.fx b/hlsl/focus.fx
index 5f329e9634e..1e2e668911b 100644
--- a/hlsl/focus.fx
+++ b/hlsl/focus.fx
@@ -51,7 +51,6 @@ struct PS_INPUT
uniform float2 ScreenDims;
uniform float2 TargetDims;
-uniform float2 SourceRect;
uniform float2 QuadDims;
VS_OUTPUT vs_main(VS_INPUT Input)
@@ -64,7 +63,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
Output.Position.xy -= 0.5f; // center
Output.Position.xy *= 2.0f; // zoom
- float2 TexCoord = Input.TexCoord;
+ float2 TexCoord = Input.Position.xy / ScreenDims;
TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
Output.TexCoord = TexCoord;
@@ -93,15 +92,13 @@ static const float2 Coord8Offset = float2( 1.00f, -0.25f);
float4 ps_main(PS_INPUT Input) : COLOR
{
- float2 QuadRatio =
- float2(1.0f, SwapXY
- ? QuadDims.y / QuadDims.x
- : QuadDims.x / QuadDims.y);
+ // we have to handle the swap of the coordinates ourself, because we are using screen not texture coordinates
+ float2 defocus = SwapXY ? Defocus.yx : Defocus.xy;
- // imaginary texel dimensions independed from quad dimensions, but dependend on quad ratio
- float2 TexelDims = (1.0f / 1024.0) * SourceRect * QuadRatio;
+ // imaginary texel dimensions independed from screen dimension, but ratio
+ float2 TexelDims = (1.0f / 1024) * (QuadDims / ScreenDims);
- float2 DefocusTexelDims = Defocus * TexelDims;
+ float2 DefocusTexelDims = defocus * TexelDims;
float4 d = tex2D(DiffuseSampler, Input.TexCoord);
float3 d1 = tex2D(DiffuseSampler, Input.TexCoord + Coord1Offset * DefocusTexelDims).rgb;
diff --git a/hlsl/ntsc.fx b/hlsl/ntsc.fx
index 107be16af16..94460ea6be0 100644
--- a/hlsl/ntsc.fx
+++ b/hlsl/ntsc.fx
@@ -44,7 +44,7 @@ struct PS_INPUT
};
//-----------------------------------------------------------------------------
-// YIQ Decode Vertex Shader
+// YIQ Vertex Shader
//-----------------------------------------------------------------------------
uniform float2 ScreenDims;
diff --git a/hlsl/phosphor.fx b/hlsl/phosphor.fx
index 7d665b44749..97defea0205 100644
--- a/hlsl/phosphor.fx
+++ b/hlsl/phosphor.fx
@@ -79,7 +79,7 @@ VS_OUTPUT vs_main(VS_INPUT Input)
Output.Position.xy -= 0.5f; // center
Output.Position.xy *= 2.0f; // zoom
- Output.TexCoord = Input.TexCoord;
+ Output.TexCoord = Input.Position.xy / ScreenDims;
Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
Output.PrevCoord = Output.TexCoord;
diff --git a/hlsl/post.fx b/hlsl/post.fx
index 7bd698c4bb6..d972926f629 100644
--- a/hlsl/post.fx
+++ b/hlsl/post.fx
@@ -49,15 +49,17 @@ struct VS_OUTPUT
{
float4 Position : POSITION;
float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
- float2 ScreenCoord : TEXCOORD1;
+ float2 SourceCoord : TEXCOORD0;
+ float2 TexCoord : TEXCOORD1;
+ float2 ScreenCoord : TEXCOORD2;
};
struct PS_INPUT
{
float4 Color : COLOR0;
- float2 TexCoord : TEXCOORD0;
- float2 ScreenCoord : TEXCOORD1;
+ float2 SourceCoord : TEXCOORD0;
+ float2 TexCoord : TEXCOORD1;
+ float2 ScreenCoord : TEXCOORD2;
};
//-----------------------------------------------------------------------------
@@ -82,34 +84,31 @@ uniform float2 ShadowUVOffset = float2(0.0f, 0.0f);
uniform bool SwapXY = false;
uniform bool PrepareBloom = false; // disables some effects for rendering bloom textures
-uniform bool PrepareVector = false;
+uniform bool VectorScreen = false;
VS_OUTPUT vs_main(VS_INPUT Input)
{
VS_OUTPUT Output = (VS_OUTPUT)0;
- float2 shadowUVOffset = ShadowUVOffset;
- shadowUVOffset = SwapXY
- ? shadowUVOffset.yx
- : shadowUVOffset.xy;
-
- float2 ScreenCoordOffset = 0.0f;
- ScreenCoordOffset += shadowUVOffset;
-
- Output.ScreenCoord = Input.Position.xy;
- Output.ScreenCoord += ScreenCoordOffset;
-
Output.Position = float4(Input.Position.xyz, 1.0f);
Output.Position.xy /= ScreenDims;
Output.Position.y = 1.0f - Output.Position.y; // flip y
Output.Position.xy -= 0.5f; // center
Output.Position.xy *= 2.0f; // zoom
- Output.TexCoord = PrepareVector
- ? Input.Position.xy / ScreenDims
- : Input.TexCoord;
+ Output.TexCoord = Input.Position.xy / ScreenDims;
Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
+ Output.SourceCoord = Input.TexCoord;
+
+ float2 ScreenCoordOffset = ShadowUVOffset;
+ ScreenCoordOffset = SwapXY
+ ? ShadowUVOffset.yx
+ : ShadowUVOffset.xy;
+
+ Output.ScreenCoord = Input.Position.xy / ScreenDims;
+ Output.ScreenCoord += ScreenCoordOffset / ScreenDims;
+
Output.Color = Input.Color;
return Output;
@@ -165,21 +164,16 @@ float4 ps_main(PS_INPUT Input) : COLOR
{
float2 ScreenTexelDims = 1.0f / ScreenDims;
float2 SourceTexelDims = 1.0f / SourceDims;
- float2 SourceRes = SourceDims * SourceRect;
-
- float2 HalfSourceRect = SourceRect * 0.5f;
- float2 ScreenCoord = Input.ScreenCoord / ScreenDims;
- float2 BaseCoord = GetAdjustedCoords(Input.TexCoord, HalfSourceRect);
+ float2 ScreenCoord = Input.ScreenCoord;
+ float2 TexCoord = GetAdjustedCoords(Input.TexCoord, 0.5f);
+ float2 SourceCoord = GetAdjustedCoords(Input.SourceCoord, 0.5f * SourceRect);
// Color
- float4 BaseColor = tex2D(DiffuseSampler, BaseCoord);
+ float4 BaseColor = tex2D(DiffuseSampler, TexCoord);
BaseColor.a = 1.0f;
- if (BaseCoord.x < 0.0f || BaseCoord.y < 0.0f)
- {
- BaseColor.rgb = 0.0f;
- }
+ clip(TexCoord < 0.0f || TexCoord > 1.0f ? -1 : 1);
// Mask Simulation (may not affect bloom)
if (!PrepareBloom && ShadowAlpha > 0.0f)
@@ -194,7 +188,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
// ? shadowUV.yx
// : shadowUV.xy;
- float2 screenCoord = ShadowTileMode == 0 ? ScreenCoord : BaseCoord;
+ float2 screenCoord = ShadowTileMode == 0 ? ScreenCoord : SourceCoord;
screenCoord = SwapXY
? screenCoord.yx
: screenCoord.xy;
@@ -204,7 +198,7 @@ float4 ps_main(PS_INPUT Input) : COLOR
? shadowCount.yx
: shadowCount.xy;
- float2 shadowTile = ((ShadowTileMode == 0 ? ScreenTexelDims : SourceTexelDims) * shadowCount);
+ float2 shadowTile = (ShadowTileMode == 0 ? ScreenTexelDims : SourceTexelDims) * shadowCount;
shadowTile = SwapXY
? shadowTile.yx
: shadowTile.xy;
@@ -242,14 +236,14 @@ float4 ps_main(PS_INPUT Input) : COLOR
if (!PrepareBloom)
{
// Scanline Simulation (may not affect vector screen)
- if (!PrepareVector && ScanlineAlpha > 0.0f)
+ if (!VectorScreen && ScanlineAlpha > 0.0f)
{
float BrightnessOffset = (ScanlineBrightOffset * ScanlineAlpha);
float BrightnessScale = (ScanlineBrightScale * ScanlineAlpha) + (1.0f - ScanlineAlpha);
float ColorBrightness = 0.299f * BaseColor.r + 0.587f * BaseColor.g + 0.114 * BaseColor.b;
- float ScanlineCoord = BaseCoord.y * SourceDims.y * ScanlineScale * PI;
+ float ScanlineCoord = SourceCoord.y * SourceDims.y * ScanlineScale * PI;
float ScanlineCoordJitter = ScanlineOffset * PHI;
float ScanlineSine = sin(ScanlineCoord + ScanlineCoordJitter);
float ScanlineWide = ScanlineHeight + max(1.0f, ScanlineHeight) * (1.0f - ColorBrightness);
@@ -260,21 +254,15 @@ float4 ps_main(PS_INPUT Input) : COLOR
}
// Hum Bar Simulation (may not affect vector screen)
- if (!PrepareVector && HumBarAlpha > 0.0f)
+ if (!VectorScreen && HumBarAlpha > 0.0f)
{
float HumBarStep = frac(TimeMilliseconds * HumBarDesync);
- float HumBarBrightness = 1.0 - frac(BaseCoord.y / SourceRect.y + HumBarStep) * HumBarAlpha;
+ float HumBarBrightness = 1.0 - frac(SourceCoord.y / SourceRect.y + HumBarStep) * HumBarAlpha;
BaseColor.rgb *= HumBarBrightness;
}
}
- // Output
- float4 Output = PrepareVector
- ? BaseColor * (Input.Color + float4(1.0f, 1.0f, 1.0f, 0.0f))
- : BaseColor * Input.Color;
- Output.a = 1.0f;
-
- return Output;
+ return BaseColor;
}
//-----------------------------------------------------------------------------
diff --git a/hlsl/prescale.fx b/hlsl/prescale.fx
index 6faa659e6d0..1cbcaa0f753 100644
--- a/hlsl/prescale.fx
+++ b/hlsl/prescale.fx
@@ -1,7 +1,11 @@
// license:BSD-3-Clause
-// copyright-holders:Ryan Holtz
+// copyright-holders:Ryan Holtz,Themaister,ImJezze
//-----------------------------------------------------------------------------
-// Prescale Effect
+// Pre-scale Effect
+//
+// Uses the hardware bilinear interpolator to avoid having to sample 4 times manually.
+//
+// https://github.com/libretro/common-shaders/blob/master/retro/shaders/sharp-bilinear.cg
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@@ -13,9 +17,9 @@ texture Diffuse;
sampler DiffuseSampler = sampler_state
{
Texture = <Diffuse>;
- MipFilter = NONE;
- MinFilter = NONE;
- MagFilter = NONE;
+ MipFilter = LINEAR;
+ MinFilter = LINEAR;
+ MagFilter = LINEAR;
AddressU = CLAMP;
AddressV = CLAMP;
AddressW = CLAMP;
@@ -45,11 +49,12 @@ struct PS_INPUT
};
//-----------------------------------------------------------------------------
-// Prescale Vertex Shader
+// Pre-scale Vertex Shader
//-----------------------------------------------------------------------------
uniform float2 ScreenDims;
uniform float2 TargetDims;
+uniform float2 SourceDims;
VS_OUTPUT vs_main(VS_INPUT Input)
{
@@ -62,22 +67,35 @@ VS_OUTPUT vs_main(VS_INPUT Input)
Output.Position.xy *= 2.0f; // zoom
Output.TexCoord = Input.TexCoord;
- Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9)
+ // Output.TexCoord += 0.5f / targetDims; // half texel offset correction (DX9)
return Output;
}
//-----------------------------------------------------------------------------
-// Prescale Pixel Shader
+// Pre-scale Pixel Shader
//-----------------------------------------------------------------------------
float4 ps_main(PS_INPUT Input) : COLOR
{
- return tex2D(DiffuseSampler, Input.TexCoord);
+ float2 Scale = TargetDims / SourceDims;
+
+ float2 TexelDims = Input.TexCoord * SourceDims;
+ float2 i = floor(TexelDims);
+ float2 s = frac(TexelDims);
+
+ // Figure out where in the texel to sample to get the correct pre-scaled bilinear.
+ float2 CenterDistance = s - 0.5f;
+ float2 RegionRange = 0.5f - 0.5f / Scale;
+ float2 f = (CenterDistance - clamp(CenterDistance, -RegionRange, RegionRange)) * Scale + 0.5f;
+
+ float2 TexCoord = (i + f) / SourceDims;
+
+ return tex2D(DiffuseSampler, TexCoord);
}
//-----------------------------------------------------------------------------
-// Prescale Technique
+// Pre-scale Technique
//-----------------------------------------------------------------------------
technique DefaultTechnique
@@ -89,4 +107,4 @@ technique DefaultTechnique
VertexShader = compile vs_3_0 vs_main();
PixelShader = compile ps_3_0 ps_main();
}
-}
+} \ No newline at end of file
diff --git a/hlsl/primary.fx b/hlsl/primary.fx
index f0a1c1da0e7..3f08afd3dca 100644
--- a/hlsl/primary.fx
+++ b/hlsl/primary.fx
@@ -55,8 +55,7 @@ uniform float2 ScreenDims;
uniform float2 TargetDims;
uniform bool PostPass;
-
-uniform float Brighten;
+uniform bool VectorScreen;
VS_OUTPUT vs_main(VS_INPUT Input)
{
@@ -70,12 +69,16 @@ VS_OUTPUT vs_main(VS_INPUT Input)
float2 targetDims = TargetDims + Epsilon; // bug: with exact target dimensions the font disappears
- Output.TexCoord = PostPass
- ? Input.Position.xy / ScreenDims
- : Input.TexCoord;
- Output.TexCoord += PostPass
- ? 0.5f / targetDims // half texel offset correction (DX9)
- : 0.0f;
+ if (PostPass)
+ {
+ Output.TexCoord = Input.Position.xy / ScreenDims;
+ Output.TexCoord += 0.5f / targetDims; // half texel offset correction (DX9)
+ }
+ else
+ {
+ Output.TexCoord = Input.TexCoord;
+ // Output.TexCoord += 0.5f / targetDims; // half texel offset correction (DX9)
+ }
Output.Color = Input.Color;
@@ -89,7 +92,9 @@ VS_OUTPUT vs_main(VS_INPUT Input)
float4 ps_main(PS_INPUT Input) : COLOR
{
float4 BaseTexel = tex2D(DiffuseSampler, Input.TexCoord);
- BaseTexel *= Input.Color + float4(Brighten, Brighten, Brighten, 0.0f);
+ BaseTexel *= PostPass && VectorScreen
+ ? Input.Color + float4(1.0f, 1.0f, 1.0f, 0.0f)
+ : Input.Color;
return BaseTexel;
}
diff --git a/src/osd/modules/render/d3d/d3dcomm.h b/src/osd/modules/render/d3d/d3dcomm.h
index 58a51eaf1cf..5f5a3f6794c 100644
--- a/src/osd/modules/render/d3d/d3dcomm.h
+++ b/src/osd/modules/render/d3d/d3dcomm.h
@@ -78,6 +78,8 @@ public:
DWORD get_max_texture_width() { return m_texture_max_width; }
DWORD get_max_texture_height() { return m_texture_max_height; }
+ void compute_texture_size(int texwidth, int texheight, int* p_width, int* p_height);
+
texture_info * get_default_texture() { return m_default_texture; }
texture_info * get_vector_texture() { return m_vector_texture; }
@@ -149,7 +151,6 @@ public:
private:
void prescale();
void compute_size(int texwidth, int texheight);
- void compute_size_subroutine(int texwidth, int texheight, int* p_width, int* p_height);
texture_manager * m_texture_manager; // texture manager pointer
diff --git a/src/osd/modules/render/d3d/d3dhlsl.cpp b/src/osd/modules/render/d3d/d3dhlsl.cpp
index 6b70952889b..7284eaabaa6 100644
--- a/src/osd/modules/render/d3d/d3dhlsl.cpp
+++ b/src/osd/modules/render/d3d/d3dhlsl.cpp
@@ -72,7 +72,7 @@ static direct3dx9_loadeffect_ptr g_load_effect = NULL;
//============================================================
shaders::shaders() :
- d3dintf(NULL), machine(NULL), d3d(NULL), num_screens(0), curr_screen(0), curr_frame(0), write_ini(false), read_ini(false), hlsl_prescale_x(0), hlsl_prescale_y(0), bloom_count(0),
+ d3dintf(NULL), machine(NULL), d3d(NULL), num_screens(0), curr_screen(0), curr_frame(0), bloom_count(0),
vecbuf_type(), vecbuf_index(0), vecbuf_count(0), avi_output_file(NULL), avi_frame(0), avi_copy_surface(NULL), avi_copy_texture(NULL), avi_final_target(NULL), avi_final_texture(NULL),
black_surface(NULL), black_texture(NULL), render_snap(false), snap_rendered(false), snap_copy_target(NULL), snap_copy_texture(NULL), snap_target(NULL), snap_texture(NULL),
snap_width(0), snap_height(0), lines_pending(false), backbuffer(NULL), curr_effect(NULL), default_effect(NULL), prescale_effect(NULL), post_effect(NULL), distortion_effect(NULL),
@@ -81,9 +81,6 @@ shaders::shaders() :
{
master_enable = false;
vector_enable = true;
- hlsl_prescale_x = 1;
- hlsl_prescale_x = 1;
- preset = -1;
shadow_texture = NULL;
options = NULL;
paused = true;
@@ -675,8 +672,6 @@ void shaders::init(base *d3dintf, running_machine *machine, d3d::renderer *rende
windows_options &winoptions = downcast<windows_options &>(machine->options());
master_enable = winoptions.d3d_hlsl_enable();
- hlsl_prescale_x = winoptions.d3d_hlsl_prescale_x();
- hlsl_prescale_y = winoptions.d3d_hlsl_prescale_y();
snap_width = winoptions.d3d_snap_width();
snap_height = winoptions.d3d_snap_height();
@@ -964,6 +959,7 @@ int shaders::create_resources(bool reset)
effects[i]->add_uniform("ScreenDims", uniform::UT_VEC2, uniform::CU_SCREEN_DIMS);
effects[i]->add_uniform("QuadDims", uniform::UT_VEC2, uniform::CU_QUAD_DIMS);
effects[i]->add_uniform("SwapXY", uniform::UT_BOOL, uniform::CU_SWAP_XY);
+ effects[i]->add_uniform("VectorScreen", uniform::UT_BOOL, uniform::CU_VECTOR_SCREEN);
}
ntsc_effect->add_uniform("CCValue", uniform::UT_FLOAT, uniform::CU_NTSC_CCFREQ);
@@ -1243,9 +1239,9 @@ int shaders::ntsc_pass(render_target *rt, int source_index, poly_info *poly, int
curr_effect->set_float("SignalOffset", signal_offset);
next_index = rt->next_index(next_index);
- blit(rt->native_target[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->source_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
- color_effect->set_texture("Diffuse", rt->native_texture[next_index]);
+ color_effect->set_texture("Diffuse", rt->source_texture[next_index]);
return next_index;
}
@@ -1300,7 +1296,7 @@ int shaders::color_convolution_pass(render_target *rt, int source_index, poly_in
// initial "Diffuse" texture is set in shaders::set_texture() or the result of shaders::ntsc_pass()
next_index = rt->next_index(next_index);
- blit(rt->native_target[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->source_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
return next_index;
}
@@ -1311,10 +1307,11 @@ int shaders::prescale_pass(render_target *rt, int source_index, poly_info *poly,
curr_effect = prescale_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->native_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->source_texture[next_index]);
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1334,10 +1331,11 @@ int shaders::deconverge_pass(render_target *rt, int source_index, poly_info *pol
curr_effect = deconverge_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1354,10 +1352,11 @@ int shaders::defocus_pass(render_target *rt, int source_index, poly_info *poly,
curr_effect = focus_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1374,21 +1373,23 @@ int shaders::phosphor_pass(render_target *rt, cache_target *ct, int source_index
curr_effect = phosphor_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
curr_effect->set_texture("LastPass", ct->last_texture);
curr_effect->set_bool("Passthrough", false);
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
// Pass along our phosphor'd screen
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]);
- curr_effect->set_texture("LastPass", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
+ curr_effect->set_texture("LastPass", rt->target_texture[next_index]);
curr_effect->set_bool("Passthrough", true);
// Avoid changing targets due to page flipping
- blit(ct->last_target, true, D3DPT_TRIANGLELIST, 0, 2);
+ // blit(ct->last_target, true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(ct->last_target, true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1397,9 +1398,6 @@ int shaders::post_pass(render_target *rt, int source_index, poly_info *poly, int
{
int next_index = source_index;
- bool prepare_vector =
- machine->first_screen()->screen_type() == SCREEN_TYPE_VECTOR;
-
screen_device_iterator screen_iterator(machine->root_device());
screen_device *screen = screen_iterator.first();
for (int i = 0; i < curr_screen; i++)
@@ -1429,7 +1427,7 @@ int shaders::post_pass(render_target *rt, int source_index, poly_info *poly, int
curr_effect->update_uniforms();
curr_effect->set_texture("ShadowTexture", shadow_texture == NULL ? NULL : shadow_texture->get_finaltex());
curr_effect->set_int("ShadowTileMode", options->shadow_mask_tile_mode);
- curr_effect->set_texture("DiffuseTexture", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("DiffuseTexture", rt->target_texture[next_index]);
curr_effect->set_vector("BackColor", 3, back_color);
curr_effect->set_vector("ScreenScale", 2, screen_scale);
curr_effect->set_vector("ScreenOffset", 2, screen_offset);
@@ -1437,10 +1435,10 @@ int shaders::post_pass(render_target *rt, int source_index, poly_info *poly, int
curr_effect->set_float("TimeMilliseconds", (float)machine->time().as_double() * 1000.0f);
curr_effect->set_float("HumBarAlpha", options->hum_bar_alpha);
curr_effect->set_bool("PrepareBloom", prepare_bloom);
- curr_effect->set_bool("PrepareVector", prepare_vector);
next_index = rt->next_index(next_index);
- blit(prepare_bloom ? rt->native_target[next_index] : rt->prescale_target[next_index], true, poly->get_type(), vertnum, poly->get_count());
+ // blit(prepare_bloom ? rt->source_surface[next_index] : rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(prepare_bloom ? rt->source_surface[next_index] : rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1455,12 +1453,8 @@ int shaders::downsample_pass(render_target *rt, int source_index, poly_info *pol
return next_index;
}
- bool prepare_vector =
- machine->first_screen()->screen_type() == SCREEN_TYPE_VECTOR;
-
curr_effect = downsample_effect;
curr_effect->update_uniforms();
- curr_effect->set_bool("PrepareVector", prepare_vector);
int bloom_index = 0;
float bloom_size = (d3d->get_width() < d3d->get_height()) ? d3d->get_width() : d3d->get_height();
@@ -1474,9 +1468,10 @@ int shaders::downsample_pass(render_target *rt, int source_index, poly_info *pol
curr_effect->set_vector("TargetDims", 2, bloom_dims[bloom_index]);
curr_effect->set_texture("DiffuseTexture",
bloom_index == 0
- ? rt->native_texture[next_index]
+ ? rt->source_texture[next_index]
: rt->bloom_texture[bloom_index - 1]);
+ // blit(rt->bloom_target[bloom_index], true, D3DPT_TRIANGLELIST, 0, 2);
blit(rt->bloom_target[bloom_index], true, poly->get_type(), vertnum, poly->get_count());
bloom_width *= 0.5f;
@@ -1542,7 +1537,7 @@ int shaders::bloom_pass(render_target *rt, int source_index, poly_info *poly, in
curr_effect->set_float("BloomScale", options->bloom_scale);
curr_effect->set_vector("BloomOverdrive", 3, options->bloom_overdrive);
- curr_effect->set_texture("DiffuseA", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("DiffuseA", rt->target_texture[next_index]);
char name[9] = "Diffuse*";
for (int index = 1; index < bloom_count; index++)
@@ -1557,7 +1552,8 @@ int shaders::bloom_pass(render_target *rt, int source_index, poly_info *poly, in
}
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, poly->get_type(), vertnum, poly->get_count());
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1578,7 +1574,7 @@ int shaders::distortion_pass(render_target *rt, int source_index, poly_info *pol
int screen_count = d3d->window().target()->current_view()->screens().count();
- // only one screen is supported
+ // todo: only one screen is supported
if (screen_count > 1)
{
return next_index;
@@ -1586,22 +1582,26 @@ int shaders::distortion_pass(render_target *rt, int source_index, poly_info *pol
render_bounds bounds = d3d->window().target()->current_view()->bounds();
render_bounds screen_bounds = d3d->window().target()->current_view()->screen_bounds();
-
- // artworks are not supported
- if (bounds.x0 != screen_bounds.x0 ||
+ bool screen_bounds_zoomed = d3d->window().target()->zoom_to_screen();
+ bool screen_bounds_differ =
+ bounds.x0 != screen_bounds.x0 ||
bounds.y0 != screen_bounds.y0 ||
bounds.x1 != screen_bounds.x1 ||
- bounds.y1 != screen_bounds.y1)
+ bounds.y1 != screen_bounds.y1;
+
+ // todo: full artworks are not supported
+ if (screen_bounds_differ && !screen_bounds_zoomed)
{
return next_index;
}
curr_effect = distortion_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("DiffuseTexture", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("DiffuseTexture", rt->target_texture[next_index]);
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, poly->get_type(), vertnum, poly->get_count());
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1618,7 +1618,8 @@ int shaders::vector_pass(render_target *rt, int source_index, poly_info *poly, i
curr_effect->set_vector("TimeParams", 2, time_params);
curr_effect->set_vector("LengthParams", 3, length_params);
- blit(rt->prescale_target[next_index], true, poly->get_type(), vertnum, poly->get_count());
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1630,12 +1631,12 @@ int shaders::vector_buffer_pass(render_target *rt, int source_index, poly_info *
curr_effect = default_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
curr_effect->set_bool("PostPass", true);
- curr_effect->set_float("Brighten", 1.0f);
next_index = rt->next_index(next_index);
- blit(rt->prescale_target[next_index], true, poly->get_type(), vertnum, poly->get_count());
+ // blit(rt->target_surface[next_index], true, D3DPT_TRIANGLELIST, 0, 2);
+ blit(rt->target_surface[next_index], true, poly->get_type(), vertnum, poly->get_count());
return next_index;
}
@@ -1644,15 +1645,11 @@ int shaders::screen_pass(render_target *rt, int source_index, poly_info *poly, i
{
int next_index = source_index;
- bool prepare_vector =
- machine->first_screen()->screen_type() == SCREEN_TYPE_VECTOR;
-
curr_effect = default_effect;
curr_effect->update_uniforms();
- curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]);
+ curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
curr_effect->set_bool("PostPass", true);
- curr_effect->set_float("Brighten", prepare_vector ? 1.0f : 0.0f);
// we do not clear the backbuffe here because multiple screens might rendered into
blit(backbuffer, false, poly->get_type(), vertnum, poly->get_count());
@@ -1677,7 +1674,6 @@ void shaders::menu_pass(poly_info *poly, int vertnum)
curr_effect = default_effect;
curr_effect->update_uniforms();
curr_effect->set_bool("PostPass", false);
- curr_effect->set_float("Brighten", 0.0f);
blit(NULL, false, poly->get_type(), vertnum, poly->get_count());
}
@@ -1706,6 +1702,7 @@ void shaders::render_quad(poly_info *poly, int vertnum)
render_target *rt = curr_render_target;
if (rt == NULL)
{
+ osd_printf_verbose("Direct3D: No raster render target\n");
return;
}
@@ -1752,6 +1749,7 @@ void shaders::render_quad(poly_info *poly, int vertnum)
render_target *rt = curr_render_target;
if (rt == NULL)
{
+ osd_printf_verbose("Direct3D: No vector render target\n");
return;
}
@@ -1774,6 +1772,7 @@ void shaders::render_quad(poly_info *poly, int vertnum)
render_target *rt = curr_render_target;
if (rt == NULL)
{
+ osd_printf_verbose("Direct3D: No vector buffer render target\n");
return;
}
@@ -1837,23 +1836,13 @@ void shaders::end_draw()
//============================================================
-// shaders::register_prescaled_texture
-//============================================================
-
-bool shaders::register_prescaled_texture(texture_info *texture)
-{
- return register_texture(texture);
-}
-
-
-//============================================================
// shaders::add_cache_target - register a cache target
//============================================================
-bool shaders::add_cache_target(renderer* d3d, texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index)
+bool shaders::add_cache_target(renderer* d3d, texture_info* info, int width, int height, int screen_index)
{
cache_target* target = (cache_target*)global_alloc_clear<cache_target>();
- if (!target->init(d3d, d3dintf, width, height, xprescale, yprescale))
+ if (!target->init(d3d, d3dintf, width, height))
{
global_free(target);
return false;
@@ -1896,7 +1885,10 @@ render_target* shaders::get_vector_target()
void shaders::create_vector_target(render_primitive *prim)
{
- if (!add_render_target(d3d, NULL, d3d->get_width(), d3d->get_height(), 1, 1))
+ int width = d3d->get_width();
+ int height = d3d->get_height();
+
+ if (!add_render_target(d3d, NULL, width, height, width, height))
{
vector_enable = false;
}
@@ -1907,7 +1899,7 @@ void shaders::create_vector_target(render_primitive *prim)
// shaders::add_render_target - register a render target
//============================================================
-bool shaders::add_render_target(renderer* d3d, texture_info* info, int width, int height, int xprescale, int yprescale)
+bool shaders::add_render_target(renderer* d3d, texture_info* info, int width, int height, int target_width, int target_height)
{
UINT32 screen_index = 0;
UINT32 page_index = 0;
@@ -1934,7 +1926,7 @@ bool shaders::add_render_target(renderer* d3d, texture_info* info, int width, in
render_target* target = (render_target*)global_alloc_clear<render_target>();
- if (!target->init(d3d, d3dintf, width, height, xprescale, yprescale))
+ if (!target->init(d3d, d3dintf, width, height, target_width, target_height))
{
global_free(target);
return false;
@@ -1951,7 +1943,7 @@ bool shaders::add_render_target(renderer* d3d, texture_info* info, int width, in
target->height = d3d->get_height();
}
- HRESULT result = (*d3dintf->device.set_render_target)(d3d->get_device(), 0, target->prescale_target[0]);
+ HRESULT result = (*d3dintf->device.set_render_target)(d3d->get_device(), 0, target->target_surface[0]);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device set_render_target call\n", (int)result);
result = (*d3dintf->device.clear)(d3d->get_device(), 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0,0,0,0), 0, 0);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device clear call\n", (int)result);
@@ -1964,7 +1956,7 @@ bool shaders::add_render_target(renderer* d3d, texture_info* info, int width, in
cache_target* cache = find_cache_target(target->screen_index, target->width, target->height);
if (cache == NULL)
{
- if (!add_cache_target(d3d, info, width, height, xprescale, yprescale, target->screen_index))
+ if (!add_cache_target(d3d, info, target_width, target_height, target->screen_index))
{
global_free(target);
return false;
@@ -2000,11 +1992,6 @@ void shaders::enumerate_screens()
bool shaders::register_texture(texture_info *texture)
{
- int width = texture->get_width();
- int height = texture->get_height();
- int xscale = texture->get_xscale();
- int yscale = texture->get_yscale();
-
if (!master_enable || !d3dintf->post_fx_available)
{
return false;
@@ -2012,31 +1999,7 @@ bool shaders::register_texture(texture_info *texture)
enumerate_screens();
- // Find the nearest prescale factor that is over our screen size
- if (hlsl_prescale_x < 1)
- {
- hlsl_prescale_x = 1;
- while (width * xscale * hlsl_prescale_x <= d3d->get_width())
- {
- hlsl_prescale_x++;
- }
- hlsl_prescale_x--;
- }
-
- if (hlsl_prescale_y < 1)
- {
- hlsl_prescale_y = 1;
- while (height * yscale * hlsl_prescale_y <= d3d->get_height())
- {
- hlsl_prescale_y++;
- }
- hlsl_prescale_y--;
- }
-
- hlsl_prescale_x = hlsl_prescale_x < 1 ? 1 : hlsl_prescale_x;
- hlsl_prescale_y = hlsl_prescale_y < 1 ? 1 : hlsl_prescale_y;
-
- if (!add_render_target(d3d, texture, width, height, xscale * hlsl_prescale_x, yscale * hlsl_prescale_y))
+ if (!add_render_target(d3d, texture, texture->get_width(), texture->get_height(), d3d->get_width(), d3d->get_height()))
{
return false;
}
@@ -3062,28 +3025,25 @@ void uniform::update()
vec2f sourcedims = shadersys->curr_texture->get_rawdims();
m_shader->set_vector("SourceDims", 2, &sourcedims.c.x);
}
-
+ else
+ {
+ vec2f sourcedims = d3d->get_dims();
+ m_shader->set_vector("SourceDims", 2, &sourcedims.c.x);
+ }
break;
}
case CU_SOURCE_RECT:
{
- bool prepare_vector =
- d3d->window().machine().first_screen()->screen_type() == SCREEN_TYPE_VECTOR;
-
- if (prepare_vector)
- {
- float delta[2] = { 1.0f, 1.0f };
- m_shader->set_vector("SourceRect", 2, delta);
- break;
- }
-
if (shadersys->curr_texture != NULL)
{
vec2f delta = shadersys->curr_texture->get_uvstop() - shadersys->curr_texture->get_uvstart();
m_shader->set_vector("SourceRect", 2, &delta.c.x);
- break;
}
-
+ else
+ {
+ float delta[2] = { 1.0f, 1.0f };
+ m_shader->set_vector("SourceRect", 2, delta);
+ }
break;
}
case CU_TARGET_DIMS:
@@ -3117,12 +3077,14 @@ void uniform::update()
(d3d->window().target()->orientation() & ROT90) == ROT90 ||
(d3d->window().target()->orientation() & ROT270) == ROT270;
m_shader->set_bool("SwapXY", orientation_swap_xy ^ rotation_swap_xy);
+ break;
}
case CU_ORIENTATION_SWAP:
{
bool orientation_swap_xy =
(d3d->window().machine().system().flags & ORIENTATION_SWAP_XY) == ORIENTATION_SWAP_XY;
m_shader->set_bool("OrientationSwapXY", orientation_swap_xy);
+ break;
}
case CU_ROTATION_SWAP:
@@ -3131,6 +3093,7 @@ void uniform::update()
(d3d->window().target()->orientation() & ROT90) == ROT90 ||
(d3d->window().target()->orientation() & ROT270) == ROT270;
m_shader->set_bool("RotationSwapXY", rotation_swap_xy);
+ break;
}
case CU_ROTATION_TYPE:
{
@@ -3143,6 +3106,14 @@ void uniform::update()
? 3
: 0;
m_shader->set_int("RotationType", rotation_type);
+ break;
+ }
+ case CU_VECTOR_SCREEN:
+ {
+ bool vector_screen =
+ d3d->window().machine().first_screen()->screen_type() == SCREEN_TYPE_VECTOR;
+ m_shader->set_bool("VectorScreen", vector_screen);
+ break;
}
case CU_NTSC_CCFREQ:
diff --git a/src/osd/modules/render/d3d/d3dhlsl.h b/src/osd/modules/render/d3d/d3dhlsl.h
index d949c1417c8..b0e502a761f 100644
--- a/src/osd/modules/render/d3d/d3dhlsl.h
+++ b/src/osd/modules/render/d3d/d3dhlsl.h
@@ -54,6 +54,7 @@ public:
CU_ORIENTATION_SWAP,
CU_ROTATION_SWAP,
CU_ROTATION_TYPE,
+ CU_VECTOR_SCREEN,
CU_NTSC_CCFREQ,
CU_NTSC_A,
@@ -292,9 +293,8 @@ public:
void render_quad(poly_info *poly, int vertnum);
bool register_texture(texture_info *texture);
- bool register_prescaled_texture(texture_info *texture);
- bool add_render_target(renderer* d3d, texture_info* info, int width, int height, int xprescale, int yprescale);
- bool add_cache_target(renderer* d3d, texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index);
+ bool add_render_target(renderer* d3d, texture_info* info, int width, int height, int target_width, int target_height);
+ bool add_cache_target(renderer* d3d, texture_info* info, int width, int height, int screen_index);
void window_save();
void window_record();
@@ -379,13 +379,8 @@ private:
int curr_screen; // current screen for render target operations
int curr_frame; // current frame (0/1) of a screen for render target operations
int lastidx; // index of the last-encountered target
- bool write_ini; // enable external ini saving
- bool read_ini; // enable external ini loading
- int hlsl_prescale_x; // hlsl prescale x
- int hlsl_prescale_y; // hlsl prescale y
float bloom_dims[11][2]; // bloom texture dimensions
int bloom_count; // count of used bloom textures
- int preset; // preset, if relevant
bitmap_argb32 shadow_bitmap; // shadow mask bitmap for post-processing shader
texture_info * shadow_texture; // shadow mask texture for post-processing shader
hlsl_options * options; // current options
diff --git a/src/osd/modules/render/drawd3d.cpp b/src/osd/modules/render/drawd3d.cpp
index b8730696a54..c4ceb30fef4 100644
--- a/src/osd/modules/render/drawd3d.cpp
+++ b/src/osd/modules/render/drawd3d.cpp
@@ -247,6 +247,7 @@ render_primitive_list *d3d::renderer::get_primitives()
}
if (m_shaders != NULL)
{
+ // do not transform primitives (scale, offset) if shaders are enabled, the shaders will handle the transformation
window().target()->set_transform_primitives(!m_shaders->enabled());
}
return &window().target()->get_primitives();
@@ -470,6 +471,63 @@ texture_manager::~texture_manager()
{
}
+
+//============================================================
+// texture_manager::compute_texture_size
+//============================================================
+
+void texture_manager::compute_texture_size(int texwidth, int texheight, int* p_width, int* p_height)
+{
+ int finalheight = texheight;
+ int finalwidth = texwidth;
+
+ // round width/height up to nearest power of 2 if we need to
+ if (!(get_texture_caps() & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
+ {
+ // first the width
+ if (finalwidth & (finalwidth - 1))
+ {
+ finalwidth |= finalwidth >> 1;
+ finalwidth |= finalwidth >> 2;
+ finalwidth |= finalwidth >> 4;
+ finalwidth |= finalwidth >> 8;
+ finalwidth++;
+ }
+
+ // then the height
+ if (finalheight & (finalheight - 1))
+ {
+ finalheight |= finalheight >> 1;
+ finalheight |= finalheight >> 2;
+ finalheight |= finalheight >> 4;
+ finalheight |= finalheight >> 8;
+ finalheight++;
+ }
+ }
+
+ // round up to square if we need to
+ if (get_texture_caps() & D3DPTEXTURECAPS_SQUAREONLY)
+ {
+ if (finalwidth < finalheight)
+ finalwidth = finalheight;
+ else
+ finalheight = finalwidth;
+ }
+
+ // adjust the aspect ratio if we need to
+ while (finalwidth < finalheight && finalheight / finalwidth > get_max_texture_aspect())
+ {
+ finalwidth *= 2;
+ }
+ while (finalheight < finalwidth && finalwidth / finalheight > get_max_texture_aspect())
+ {
+ finalheight *= 2;
+ }
+
+ *p_width = finalwidth;
+ *p_height = finalheight;
+}
+
void texture_manager::create_resources()
{
// experimental: load a PNG to use for vector rendering; it is treated
@@ -1925,18 +1983,20 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
m_d3dsurface = NULL;
m_d3dfinaltex = NULL;
- // compute the size
- compute_size(texsource->width, texsource->height);
-
// non-screen textures are easy
if (!PRIMFLAG_GET_SCREENTEX(flags))
{
+ // required to compute the size
+ m_type = TEXTURE_TYPE_PLAIN;
+
+ // compute the size
+ compute_size(texsource->width, texsource->height);
+
assert(PRIMFLAG_TEXFORMAT(flags) != TEXFORMAT_YUY16);
result = (*d3dintf->device.create_texture)(m_renderer->get_device(), m_rawdims.c.x, m_rawdims.c.y, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &m_d3dtex);
if (result != D3D_OK)
goto error;
m_d3dfinaltex = m_d3dtex;
- m_type = TEXTURE_TYPE_PLAIN;
}
// screen textures are allocated differently
@@ -1994,14 +2054,19 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
m_xprescale = m_yprescale = 1;
}
- // screen textures with no prescaling are pretty easy
- if (m_xprescale == 1 && m_yprescale == 1)
+ // screen textures with no prescaling are pretty easy and shaders handle prescale itself
+ if ((m_xprescale == 1 && m_yprescale == 1) || m_renderer->get_shaders()->enabled())
{
+ // required to compute the size
+ m_type = m_texture_manager->is_dynamic_supported() ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
+
+ // compute the size
+ compute_size(texsource->width, texsource->height);
+
result = (*d3dintf->device.create_texture)(m_renderer->get_device(), m_rawdims.c.x, m_rawdims.c.y, 1, usage, format, pool, &m_d3dtex);
if (result == D3D_OK)
{
m_d3dfinaltex = m_d3dtex;
- m_type = m_texture_manager->is_dynamic_supported() ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
if (m_renderer->get_shaders()->enabled() && !m_renderer->get_shaders()->register_texture(this))
{
goto error;
@@ -2010,7 +2075,6 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
break;
}
}
-
// screen textures with prescaling require two allocations
else
{
@@ -2018,23 +2082,32 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
// (won't work for YUY textures)
if (m_texture_manager->is_stretch_supported() && PRIMFLAG_GET_TEXFORMAT(flags) != TEXFORMAT_YUY16)
{
+ // required to compute the size
+ m_type = TEXTURE_TYPE_SURFACE;
+
+ // compute the size
+ compute_size(texsource->width, texsource->height);
+
result = (*d3dintf->device.create_offscreen_plain_surface)(m_renderer->get_device(), m_rawdims.c.x, m_rawdims.c.y, format, D3DPOOL_DEFAULT, &m_d3dsurface);
if (result != D3D_OK)
{
continue;
}
- m_type = TEXTURE_TYPE_SURFACE;
}
-
// otherwise, we allocate a dynamic texture for the source
else
{
+ // required to compute the size
+ m_type = m_texture_manager->is_dynamic_supported() ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
+
+ // compute the size
+ compute_size(texsource->width, texsource->height);
+
result = (*d3dintf->device.create_texture)(m_renderer->get_device(), m_rawdims.c.x, m_rawdims.c.y, 1, usage, format, pool, &m_d3dtex);
if (result != D3D_OK)
{
continue;
}
- m_type = m_texture_manager->is_dynamic_supported() ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
}
// for the target surface, we allocate a render target texture
@@ -2043,15 +2116,13 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
// target surfaces typically cannot be YCbCr, so we always pick RGB in that case
D3DFORMAT finalfmt = (format != m_texture_manager->get_yuv_format()) ? format : D3DFMT_A8R8G8B8;
+
result = (*d3dintf->device.create_texture)(m_renderer->get_device(), scwidth, scheight, 1, D3DUSAGE_RENDERTARGET, finalfmt, D3DPOOL_DEFAULT, &m_d3dfinaltex);
if (result == D3D_OK)
{
- if (m_renderer->get_shaders()->enabled() && !m_renderer->get_shaders()->register_prescaled_texture(this))
- {
- goto error;
- }
break;
}
+
(*d3dintf->texture.release)(m_d3dtex);
m_d3dtex = NULL;
}
@@ -2061,7 +2132,6 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
// copy the data to the texture
set_data(texsource, flags);
- //texsource->osdhandle = (void*)this;
// add us to the texture list
if(m_texture_manager->get_texlist() != NULL)
m_texture_manager->get_texlist()->m_prev = this;
@@ -2081,63 +2151,6 @@ error:
//============================================================
-// texture_info::compute_size_subroutine
-//============================================================
-
-void texture_info::compute_size_subroutine(int texwidth, int texheight, int* p_width, int* p_height)
-{
- int finalheight = texheight;
- int finalwidth = texwidth;
-
- // round width/height up to nearest power of 2 if we need to
- if (!(m_texture_manager->get_texture_caps() & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
- {
- // first the width
- if (finalwidth & (finalwidth - 1))
- {
- finalwidth |= finalwidth >> 1;
- finalwidth |= finalwidth >> 2;
- finalwidth |= finalwidth >> 4;
- finalwidth |= finalwidth >> 8;
- finalwidth++;
- }
-
- // then the height
- if (finalheight & (finalheight - 1))
- {
- finalheight |= finalheight >> 1;
- finalheight |= finalheight >> 2;
- finalheight |= finalheight >> 4;
- finalheight |= finalheight >> 8;
- finalheight++;
- }
- }
-
- // round up to square if we need to
- if (m_texture_manager->get_texture_caps() & D3DPTEXTURECAPS_SQUAREONLY)
- {
- if (finalwidth < finalheight)
- finalwidth = finalheight;
- else
- finalheight = finalwidth;
- }
-
- // adjust the aspect ratio if we need to
- while (finalwidth < finalheight && finalheight / finalwidth > m_texture_manager->get_max_texture_aspect())
- {
- finalwidth *= 2;
- }
- while (finalheight < finalwidth && finalwidth / finalheight > m_texture_manager->get_max_texture_aspect())
- {
- finalheight *= 2;
- }
-
- *p_width = finalwidth;
- *p_height = finalheight;
-}
-
-
-//============================================================
// texture_info::compute_size
//============================================================
@@ -2149,30 +2162,42 @@ void texture_info::compute_size(int texwidth, int texheight)
m_xborderpix = 0;
m_yborderpix = 0;
- // if we're not wrapping, add a 1-2 pixel border on all sides
- if (ENABLE_BORDER_PIX && !(m_flags & PRIMFLAG_TEXWRAP_MASK))
+ bool shaders_enabled = m_renderer->get_shaders()->enabled();
+ bool wrap_texture = (m_flags & PRIMFLAG_TEXWRAP_MASK) == PRIMFLAG_TEXWRAP_MASK;
+ bool border_texture = ENABLE_BORDER_PIX && !wrap_texture;
+ bool surface_texture = m_type == TEXTURE_TYPE_SURFACE;
+
+ // skip border when shaders are enabled and we're not creating a surface (UI) texture
+ if (!shaders_enabled || surface_texture)
{
- // note we need 2 pixels in X for YUY textures
- m_xborderpix = (PRIMFLAG_GET_TEXFORMAT(m_flags) == TEXFORMAT_YUY16) ? 2 : 1;
- m_yborderpix = 1;
+ // if we're not wrapping, add a 1-2 pixel border on all sides
+ if (border_texture)
+ {
+ // note we need 2 pixels in X for YUY textures
+ m_xborderpix = (PRIMFLAG_GET_TEXFORMAT(m_flags) == TEXFORMAT_YUY16) ? 2 : 1;
+ m_yborderpix = 1;
+ }
}
- // compute final texture size
finalwidth += 2 * m_xborderpix;
finalheight += 2 * m_yborderpix;
- compute_size_subroutine(finalwidth, finalheight, &finalwidth, &finalheight);
-
- // if we added pixels for the border, and that just barely pushed us over, take it back
- if (finalwidth > m_texture_manager->get_max_texture_width() || finalheight > m_texture_manager->get_max_texture_height())
+ // take texture size as given when shaders are enabled and we're not creating a surface (UI) texture, still update wrapped textures
+ if (!shaders_enabled || surface_texture || wrap_texture)
{
- finalheight = texheight;
- finalwidth = texwidth;
+ m_texture_manager->compute_texture_size(finalwidth, finalheight, &finalwidth, &finalheight);
- m_xborderpix = 0;
- m_yborderpix = 0;
+ // if we added pixels for the border, and that just barely pushed us over, take it back
+ if (finalwidth > m_texture_manager->get_max_texture_width() || finalheight > m_texture_manager->get_max_texture_height())
+ {
+ finalheight = texheight;
+ finalwidth = texwidth;
- compute_size_subroutine(finalwidth, finalheight, &finalwidth, &finalheight);
+ m_xborderpix = 0;
+ m_yborderpix = 0;
+
+ m_texture_manager->compute_texture_size(finalwidth, finalheight, &finalwidth, &finalheight);
+ }
}
// if we're above the max width/height, do what?
@@ -2751,18 +2776,20 @@ cache_target::~cache_target()
// cache_target::init - initializes a target cache
//============================================================
-bool cache_target::init(renderer *d3d, base *d3dintf, int width, int height, int prescale_x, int prescale_y)
+bool cache_target::init(renderer *d3d, base *d3dintf, int target_width, int target_height)
{
- HRESULT result = (*d3dintf->device.create_texture)(d3d->get_device(), width * prescale_x, height * prescale_y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &last_texture);
+ // d3d->get_texture_manager()->compute_texture_size(target_width, target_height, &target_width, &target_height);
+
+ this->target_width = target_width;
+ this->target_height = target_height;
+
+ HRESULT result = (*d3dintf->device.create_texture)(d3d->get_device(), target_width, target_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &last_texture);
if (result != D3D_OK)
{
return false;
}
(*d3dintf->texture.get_surface_level)(last_texture, 0, &last_target);
- target_width = width * prescale_x;
- target_height = height * prescale_y;
-
return true;
}
@@ -2789,25 +2816,25 @@ render_target::~render_target()
for (int index = 0; index < 2; index++)
{
- if (native_texture[index] != NULL)
+ if (source_texture[index] != NULL)
{
- (*d3dintf->texture.release)(native_texture[index]);
- native_texture[index] = NULL;
+ (*d3dintf->texture.release)(source_texture[index]);
+ source_texture[index] = NULL;
}
- if (native_target[index] != NULL)
+ if (source_surface[index] != NULL)
{
- (*d3dintf->surface.release)(native_target[index]);
- native_target[index] = NULL;
+ (*d3dintf->surface.release)(source_surface[index]);
+ source_surface[index] = NULL;
}
- if (prescale_texture[index] != NULL)
+ if (target_texture[index] != NULL)
{
- (*d3dintf->texture.release)(prescale_texture[index]);
- prescale_texture[index] = NULL;
+ (*d3dintf->texture.release)(target_texture[index]);
+ target_texture[index] = NULL;
}
- if (prescale_target[index] != NULL)
+ if (target_surface[index] != NULL)
{
- (*d3dintf->surface.release)(prescale_target[index]);
- prescale_target[index] = NULL;
+ (*d3dintf->surface.release)(target_surface[index]);
+ target_surface[index] = NULL;
}
}
}
@@ -2817,31 +2844,39 @@ render_target::~render_target()
// render_target::init - initializes a render target
//============================================================
-bool render_target::init(renderer *d3d, base *d3dintf, int width, int height, int prescale_x, int prescale_y)
+bool render_target::init(renderer *d3d, base *d3dintf, int width, int height, int target_width, int target_height)
{
HRESULT result;
+ // d3d->get_texture_manager()->compute_texture_size(target_width, target_height, &target_width, &target_height);
+
+ this->width = width;
+ this->height = height;
+
+ this->target_width = target_width;
+ this->target_height = target_height;
+
for (int index = 0; index < 2; index++)
{
- result = (*d3dintf->device.create_texture)(d3d->get_device(), width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &native_texture[index]);
+ result = (*d3dintf->device.create_texture)(d3d->get_device(), width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &source_texture[index]);
if (result != D3D_OK)
{
return false;
}
- (*d3dintf->texture.get_surface_level)(native_texture[index], 0, &native_target[index]);
+ (*d3dintf->texture.get_surface_level)(source_texture[index], 0, &source_surface[index]);
- result = (*d3dintf->device.create_texture)(d3d->get_device(), width * prescale_x, height * prescale_y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &prescale_texture[index]);
+ result = (*d3dintf->device.create_texture)(d3d->get_device(), target_width, target_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &target_texture[index]);
if (result != D3D_OK)
{
return false;
}
- (*d3dintf->texture.get_surface_level)(prescale_texture[index], 0, &prescale_target[index]);
+ (*d3dintf->texture.get_surface_level)(target_texture[index], 0, &target_surface[index]);
}
int bloom_index = 0;
- float bloom_size = (d3d->get_width() < d3d->get_height()) ? d3d->get_width() : d3d->get_height();
- float bloom_width = d3d->get_width();
- float bloom_height = d3d->get_height();
+ float bloom_width = target_width;
+ float bloom_height = target_height;
+ float bloom_size = bloom_width < bloom_height ? bloom_width : bloom_height;
for (; bloom_size >= 2.0f && bloom_index < 11; bloom_size *= 0.5f)
{
bloom_width *= 0.5f;
@@ -2857,12 +2892,6 @@ bool render_target::init(renderer *d3d, base *d3dintf, int width, int height, in
bloom_index++;
}
- this->width = width;
- this->height = height;
-
- target_width = width * prescale_x;
- target_height = height * prescale_y;
-
return true;
}
diff --git a/src/osd/modules/render/drawd3d.h b/src/osd/modules/render/drawd3d.h
index b5672be91ee..9c2014ead39 100644
--- a/src/osd/modules/render/drawd3d.h
+++ b/src/osd/modules/render/drawd3d.h
@@ -38,7 +38,7 @@ public:
cache_target() { }
~cache_target();
- bool init(renderer *d3d, base *d3dintf, int width, int height, int prescale_x, int prescale_y);
+ bool init(renderer *d3d, base *d3dintf, int target_width, int target_height);
surface *last_target;
texture *last_texture;
@@ -65,16 +65,13 @@ public:
render_target() { }
~render_target();
- bool init(renderer *d3d, base *d3dintf, int width, int height, int prescale_x, int prescale_y);
+ bool init(renderer *d3d, base *d3dintf, int width, int height, int target_width, int target_height);
int next_index(int index) { return ++index > 1 ? 0 : index; }
// real target dimension
int target_width;
int target_height;
- int prescale_x;
- int prescale_y;
-
// only used to identify/find the render target
int width;
int height;
@@ -82,10 +79,10 @@ public:
int screen_index;
int page_index;
- surface *prescale_target[2];
- texture *prescale_texture[2];
- surface *native_target[2];
- texture *native_texture[2];
+ surface *target_surface[2];
+ texture *target_texture[2];
+ surface *source_surface[2];
+ texture *source_texture[2];
render_target *next;
render_target *prev;
diff --git a/src/osd/windows/winmain.cpp b/src/osd/windows/winmain.cpp
index 2a14281f7fc..08c988e2311 100644
--- a/src/osd/windows/winmain.cpp
+++ b/src/osd/windows/winmain.cpp
@@ -283,8 +283,6 @@ const options_entry windows_options::s_option_entries[] =
{ NULL, NULL, OPTION_HEADER, "DIRECT3D POST-PROCESSING OPTIONS" },
{ WINOPTION_HLSL_ENABLE";hlsl", "0", OPTION_BOOLEAN, "enables HLSL post-processing (PS3.0 required)" },
{ WINOPTION_HLSLPATH, "hlsl", OPTION_STRING, "path to hlsl files" },
- { WINOPTION_HLSL_PRESCALE_X, "0", OPTION_INTEGER, "HLSL pre-scale override factor for X (0 for auto)" },
- { WINOPTION_HLSL_PRESCALE_Y, "0", OPTION_INTEGER, "HLSL pre-scale override factor for Y (0 for auto)" },
{ WINOPTION_HLSL_WRITE, NULL, OPTION_STRING, "enables 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" },
diff --git a/src/osd/windows/winmain.h b/src/osd/windows/winmain.h
index 7656ab4ee31..63dd907d3b3 100644
--- a/src/osd/windows/winmain.h
+++ b/src/osd/windows/winmain.h
@@ -31,8 +31,6 @@
// core post-processing options
#define WINOPTION_HLSL_ENABLE "hlsl_enable"
#define WINOPTION_HLSLPATH "hlslpath"
-#define WINOPTION_HLSL_PRESCALE_X "hlsl_prescale_x"
-#define WINOPTION_HLSL_PRESCALE_Y "hlsl_prescale_y"
#define WINOPTION_HLSL_WRITE "hlsl_write"
#define WINOPTION_HLSL_SNAP_WIDTH "hlsl_snap_width"
#define WINOPTION_HLSL_SNAP_HEIGHT "hlsl_snap_height"
@@ -138,8 +136,6 @@ public:
const char *screen_post_fx_dir() const { return value(WINOPTION_HLSLPATH); }
bool d3d_hlsl_enable() const { return bool_value(WINOPTION_HLSL_ENABLE); }
const char *d3d_hlsl_write() const { return value(WINOPTION_HLSL_WRITE); }
- int d3d_hlsl_prescale_x() const { return int_value(WINOPTION_HLSL_PRESCALE_X); }
- int d3d_hlsl_prescale_y() const { return int_value(WINOPTION_HLSL_PRESCALE_Y); }
int d3d_snap_width() const { return int_value(WINOPTION_HLSL_SNAP_WIDTH); }
int d3d_snap_height() const { return int_value(WINOPTION_HLSL_SNAP_HEIGHT); }
int screen_shadow_mask_tile_mode() const { return int_value(WINOPTION_SHADOW_MASK_TILE_MODE); }