diff options
-rw-r--r-- | artwork/monochrome-matrix.png | bin | 33194 -> 33047 bytes | |||
-rw-r--r-- | docs/hlsl.txt | 2 | ||||
-rw-r--r-- | hlsl/artwork_support/distortion.fx | 101 | ||||
-rw-r--r-- | hlsl/artwork_support/post.fx | 535 | ||||
-rw-r--r-- | hlsl/bloom.fx | 22 | ||||
-rw-r--r-- | hlsl/deconverge.fx | 43 | ||||
-rw-r--r-- | hlsl/distortion.fx | 52 | ||||
-rw-r--r-- | hlsl/downsample.fx | 27 | ||||
-rw-r--r-- | hlsl/focus.fx | 33 | ||||
-rw-r--r-- | hlsl/ntsc.fx | 2 | ||||
-rw-r--r-- | hlsl/phosphor.fx | 2 | ||||
-rw-r--r-- | hlsl/post.fx | 110 | ||||
-rw-r--r-- | hlsl/prescale.fx | 42 | ||||
-rw-r--r-- | hlsl/primary.fx | 101 | ||||
-rw-r--r-- | ini/gameboy.ini | 55 | ||||
-rw-r--r-- | ini/gba.ini | 55 | ||||
-rw-r--r-- | ini/raster.ini | 60 | ||||
-rw-r--r-- | ini/vector.ini | 75 | ||||
-rw-r--r-- | src/osd/modules/render/d3d/d3dcomm.h | 26 | ||||
-rw-r--r-- | src/osd/modules/render/d3d/d3dhlsl.cpp | 274 | ||||
-rw-r--r-- | src/osd/modules/render/d3d/d3dhlsl.h | 19 | ||||
-rw-r--r-- | src/osd/modules/render/drawd3d.cpp | 315 | ||||
-rw-r--r-- | src/osd/windows/winmain.cpp | 2 | ||||
-rw-r--r-- | src/osd/windows/winmain.h | 4 |
24 files changed, 825 insertions, 1132 deletions
diff --git a/artwork/monochrome-matrix.png b/artwork/monochrome-matrix.png Binary files differindex c1180363087..f68ac273519 100644 --- a/artwork/monochrome-matrix.png +++ b/artwork/monochrome-matrix.png 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 9a3b693cd61..00000000000 --- a/hlsl/artwork_support/post.fx +++ /dev/null @@ -1,535 +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 HumBarHertzRate = 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 ScanCoord = BaseCoord.y * SourceDims.y * ScanlineScale * PI; - float ScanCoordJitter = ScanlineOffset * PHI; - float ScanSine = sin(ScanCoord + ScanCoordJitter); - float ScanSineScaled = pow(ScanSine * ScanSine, ScanlineHeight); - float ScanBrightness = ScanSineScaled * ScanlineBrightScale + 1.0f + ScanlineBrightOffset; - - BaseColor.rgb *= lerp(1.0f, ScanBrightness * 0.5f, ScanlineAlpha); - } - - // Hum Bar Simulation (may not affect vector screen) - if (!PrepareVector && HumBarAlpha > 0.0f) - { - float HumTimeStep = frac(TimeMilliseconds * HumBarHertzRate); - float HumBrightness = 1.0 - frac(BaseCoord.y / SourceRect.y + HumTimeStep) * HumBarAlpha; - BaseColor.rgb *= HumBrightness; - } - } - - // 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/bloom.fx b/hlsl/bloom.fx index 1ee152adfec..47cc04c47ed 100644 --- a/hlsl/bloom.fx +++ b/hlsl/bloom.fx @@ -202,8 +202,9 @@ float random(float2 seed) uniform float2 ScreenDims; uniform float2 TargetDims; -uniform float2 SourceRect; +uniform float2 SourceDims; +// level dimensions not necessary anymore? uniform float2 Level0Size; uniform float4 Level12Size; uniform float4 Level34Size; @@ -211,6 +212,8 @@ uniform float4 Level56Size; uniform float4 Level78Size; uniform float4 Level9ASize; +uniform bool VectorScreen = false; + VS_OUTPUT vs_main(VS_INPUT Input) { VS_OUTPUT Output = (VS_OUTPUT)0; @@ -226,12 +229,17 @@ VS_OUTPUT vs_main(VS_INPUT Input) float2 TexCoord = Input.Position.xy / ScreenDims; TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9) - Output.TexCoord0 = TexCoord; - Output.TexCoord12 = TexCoord.xyxy + (0.5f / Level12Size); - Output.TexCoord34 = TexCoord.xyxy + (0.5f / Level34Size); - Output.TexCoord56 = TexCoord.xyxy + (0.5f / Level56Size); - Output.TexCoord78 = TexCoord.xyxy + (0.5f / Level78Size); - Output.TexCoord9A = TexCoord.xyxy + (0.5f / Level9ASize); + Output.TexCoord0 = TexCoord.xy; // + (0.5f / Level0Size); + + TexCoord += VectorScreen + ? 0.5f / TargetDims.xy + : 0.5f / SourceDims.xy; + + Output.TexCoord12 = TexCoord.xyxy; // + (0.5f / Level12Size); + Output.TexCoord34 = TexCoord.xyxy; // + (0.5f / Level34Size); + Output.TexCoord56 = TexCoord.xyxy; // + (0.5f / Level56Size); + Output.TexCoord78 = TexCoord.xyxy; // + (0.5f / Level78Size); + Output.TexCoord9A = TexCoord.xyxy; // + (0.5f / Level9ASize); return Output; } 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 122172350f9..fad2ef8341f 100644 --- a/hlsl/downsample.fx +++ b/hlsl/downsample.fx @@ -53,15 +53,24 @@ struct PS_INPUT uniform float2 ScreenDims; uniform float2 TargetDims; +uniform float2 SourceDims; uniform float2 SourceRect; +uniform float2 QuadDims; -uniform bool PrepareVector; +uniform int BloomLevel; + +uniform bool VectorScreen; + +static const float2 Coord0Offset = float2(-0.5f, -0.5f); +static const float2 Coord1Offset = float2( 0.5f, -0.5f); +static const float2 Coord2Offset = float2(-0.5f, 0.5f); +static const float2 Coord3Offset = float2( 0.5f, 0.5f); VS_OUTPUT vs_main(VS_INPUT Input) { VS_OUTPUT Output = (VS_OUTPUT)0; - float2 TargetTexelDims = 1.0f / TargetDims; + float2 HalfTargetTexelDims = 0.5f / TargetDims; Output.Position = float4(Input.Position.xyz, 1.0f); Output.Position.xy /= ScreenDims; @@ -72,14 +81,12 @@ VS_OUTPUT vs_main(VS_INPUT Input) Output.Color = Input.Color; float2 TexCoord = Input.Position.xy / ScreenDims; - TexCoord += PrepareVector - ? 0.5f / TargetDims // half texel offset correction (DX9) - only for vector grpahics - : 0.0f; - - Output.TexCoord01.xy = TexCoord + float2(-0.5f, -0.5f) * TargetTexelDims; - Output.TexCoord01.zw = TexCoord + float2( 0.5f, -0.5f) * TargetTexelDims; - Output.TexCoord23.xy = TexCoord + float2(-0.5f, 0.5f) * TargetTexelDims; - Output.TexCoord23.zw = TexCoord + float2( 0.5f, 0.5f) * TargetTexelDims; + TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9) + + Output.TexCoord01.xy = TexCoord + Coord0Offset * HalfTargetTexelDims; + Output.TexCoord01.zw = TexCoord + Coord1Offset * HalfTargetTexelDims; + Output.TexCoord23.xy = TexCoord + Coord2Offset * HalfTargetTexelDims; + Output.TexCoord23.zw = TexCoord + Coord3Offset * HalfTargetTexelDims; return Output; } diff --git a/hlsl/focus.fx b/hlsl/focus.fx index c5e5262fedd..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; @@ -78,30 +77,28 @@ VS_OUTPUT vs_main(VS_INPUT Input) // Defocus Pixel Shader //----------------------------------------------------------------------------- -float2 Coord1Offset = float2( 0.75f, 0.50f); -float2 Coord2Offset = float2( 0.25f, 1.00f); -float2 Coord3Offset = float2(-0.50f, 0.75f); -float2 Coord4Offset = float2(-1.00f, 0.25f); -float2 Coord5Offset = float2(-0.75f, -0.50f); -float2 Coord6Offset = float2(-0.25f, -1.00f); -float2 Coord7Offset = float2( 0.50f, -0.75f); -float2 Coord8Offset = float2( 1.00f, -0.25f); - uniform float2 Defocus = float2(0.0f, 0.0f); uniform bool SwapXY = false; +static const float2 Coord1Offset = float2( 0.75f, 0.50f); +static const float2 Coord2Offset = float2( 0.25f, 1.00f); +static const float2 Coord3Offset = float2(-0.50f, 0.75f); +static const float2 Coord4Offset = float2(-1.00f, 0.25f); +static const float2 Coord5Offset = float2(-0.75f, -0.50f); +static const float2 Coord6Offset = float2(-0.25f, -1.00f); +static const float2 Coord7Offset = float2( 0.50f, -0.75f); +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 deec349e2fc..01d83d435ff 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,33 +84,27 @@ 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 += 0.5f / TargetDims; // half texel offset correction (DX9) + Output.TexCoord = Input.Position.xy / ScreenDims; + + Output.TexCoord += PrepareBloom + ? 0.0f / TargetDims // use half texel offset (DX9) to do the blur for first bloom layer + : 0.5f / TargetDims; // fix half texel offset correction (DX9) + + Output.SourceCoord = Input.TexCoord; + + Output.ScreenCoord = Input.Position.xy / ScreenDims; Output.Color = Input.Color; @@ -119,7 +115,7 @@ VS_OUTPUT vs_main(VS_INPUT Input) // Scanline & Shadowmask Pixel Shader //----------------------------------------------------------------------------- -uniform float HumBarHertzRate = 60.0f / 59.94f - 1.0f; // difference between the 59.94 Hz field rate and 60 Hz line frequency (NTSC) +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; @@ -165,36 +161,40 @@ 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) + // keep border + if (!PrepareBloom) { - BaseColor.rgb = 0.0f; + // clip border + clip(TexCoord < 0.0f || TexCoord > 1.0f ? -1 : 1); } // Mask Simulation (may not affect bloom) if (!PrepareBloom && ShadowAlpha > 0.0f) { + float2 shadowUVOffset = ShadowUVOffset; + shadowUVOffset = SwapXY + ? ShadowUVOffset.yx + : ShadowUVOffset.xy; + float2 shadowDims = ShadowDims; shadowDims = SwapXY ? shadowDims.yx : shadowDims.xy; float2 shadowUV = ShadowUV; - // shadowUV = SwapXY - // ? shadowUV.yx - // : shadowUV.xy; - float2 screenCoord = ShadowTileMode == 0 ? ScreenCoord : BaseCoord; + float2 screenCoord = ShadowTileMode == 0 + ? ScreenCoord + shadowUVOffset / ScreenDims + : SourceCoord + shadowUVOffset / SourceDims; screenCoord = SwapXY ? screenCoord.yx : screenCoord.xy; @@ -204,17 +204,17 @@ float4 ps_main(PS_INPUT Input) : COLOR ? shadowCount.yx : shadowCount.xy; - float2 shadowTile = ((ShadowTileMode == 0 ? ScreenTexelDims : SourceTexelDims) * shadowCount); + float2 shadowTile = ShadowTileMode == 0 + ? ScreenTexelDims * shadowCount + : 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); @@ -242,33 +242,33 @@ 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 ScanCoord = BaseCoord.y * SourceDims.y * ScanlineScale * PI; - float ScanCoordJitter = ScanlineOffset * PHI; - float ScanSine = sin(ScanCoord + ScanCoordJitter); - float ScanSineScaled = pow(ScanSine * ScanSine, ScanlineHeight); - float ScanBrightness = ScanSineScaled * ScanlineBrightScale + 1.0f + ScanlineBrightOffset; + float BrightnessOffset = (ScanlineBrightOffset * ScanlineAlpha); + float BrightnessScale = (ScanlineBrightScale * ScanlineAlpha) + (1.0f - ScanlineAlpha); - BaseColor.rgb *= lerp(1.0f, ScanBrightness * 0.5f, ScanlineAlpha); + float ColorBrightness = 0.299f * BaseColor.r + 0.587f * BaseColor.g + 0.114 * BaseColor.b; + + 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); + 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) + if (!VectorScreen && HumBarAlpha > 0.0f) { - float HumTimeStep = frac(TimeMilliseconds * HumBarHertzRate); - float HumBrightness = 1.0 - frac(BaseCoord.y / SourceRect.y + HumTimeStep) * HumBarAlpha; - BaseColor.rgb *= HumBrightness; + float HumBarStep = frac(TimeMilliseconds * HumBarDesync); + 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 846c02577ce..419254acd07 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,39 +49,53 @@ 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) { 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.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 diff --git a/hlsl/primary.fx b/hlsl/primary.fx index f0a1c1da0e7..2086132a0e7 100644 --- a/hlsl/primary.fx +++ b/hlsl/primary.fx @@ -46,19 +46,36 @@ struct PS_INPUT }; //----------------------------------------------------------------------------- -// Primary Vertex Shader +// Primary Vertex Shaders //----------------------------------------------------------------------------- static const float Epsilon = 1.0e-7f; uniform float2 ScreenDims; uniform float2 TargetDims; +uniform float2 QuadDims; -uniform bool PostPass; +uniform bool VectorScreen; -uniform float Brighten; +VS_OUTPUT vs_screen_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.TexCoord = Input.Position.xy / ScreenDims; + Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9) + + Output.Color = Input.Color; + + return Output; +} -VS_OUTPUT vs_main(VS_INPUT Input) +VS_OUTPUT vs_vector_buffer_main(VS_INPUT Input) { VS_OUTPUT Output = (VS_OUTPUT)0; @@ -68,14 +85,25 @@ VS_OUTPUT vs_main(VS_INPUT Input) Output.Position.xy -= 0.5f; // center Output.Position.xy *= 2.0f; // zoom - float2 targetDims = TargetDims + Epsilon; // bug: with exact target dimensions the font disappears + Output.TexCoord = Input.Position.xy / ScreenDims; + Output.TexCoord += 0.5f / TargetDims; // half texel offset correction (DX9) + + Output.Color = Input.Color; + + return Output; +} + +VS_OUTPUT vs_ui_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.TexCoord = PostPass - ? Input.Position.xy / ScreenDims - : Input.TexCoord; - Output.TexCoord += PostPass - ? 0.5f / targetDims // half texel offset correction (DX9) - : 0.0f; + Output.TexCoord = Input.TexCoord; Output.Color = Input.Color; @@ -83,28 +111,65 @@ VS_OUTPUT vs_main(VS_INPUT Input) } //----------------------------------------------------------------------------- -// Primary Pixel Shader +// Primary Pixel Shaders //----------------------------------------------------------------------------- -float4 ps_main(PS_INPUT Input) : COLOR +float4 ps_screen_main(PS_INPUT Input) : COLOR { float4 BaseTexel = tex2D(DiffuseSampler, Input.TexCoord); - BaseTexel *= Input.Color + float4(Brighten, Brighten, Brighten, 0.0f); + + return BaseTexel; +} + +float4 ps_vector_buffer_main(PS_INPUT Input) : COLOR +{ + float4 BaseTexel = tex2D(DiffuseSampler, Input.TexCoord); + BaseTexel *= Input.Color + float4(1.0f, 1.0f, 1.0f, 0.0f); + + return BaseTexel; +} + +float4 ps_ui_main(PS_INPUT Input) : COLOR +{ + float4 BaseTexel = tex2D(DiffuseSampler, Input.TexCoord); + BaseTexel *= Input.Color; return BaseTexel; } //----------------------------------------------------------------------------- -// Primary Technique +// Primary Techniques //----------------------------------------------------------------------------- -technique DefaultTechnique +technique ScreenTechnique +{ + pass Pass0 + { + Lighting = FALSE; + + VertexShader = compile vs_2_0 vs_screen_main(); + PixelShader = compile ps_2_0 ps_screen_main(); + } +} + +technique VectorBufferTechnique +{ + pass Pass0 + { + Lighting = FALSE; + + VertexShader = compile vs_2_0 vs_vector_buffer_main(); + PixelShader = compile ps_2_0 ps_vector_buffer_main(); + } +} + +technique UiTechnique { pass Pass0 { Lighting = FALSE; - VertexShader = compile vs_2_0 vs_main(); - PixelShader = compile ps_2_0 ps_main(); + VertexShader = compile vs_2_0 vs_ui_main(); + PixelShader = compile ps_2_0 ps_ui_main(); } } diff --git a/ini/gameboy.ini b/ini/gameboy.ini new file mode 100644 index 00000000000..2b2465da85b --- /dev/null +++ b/ini/gameboy.ini @@ -0,0 +1,55 @@ +# +# DIRECT3D POST-PROCESSING OPTIONS +# +shadow_mask_tile_mode 1 +shadow_mask_alpha 0.25 +shadow_mask_texture monochrome-matrix.png +shadow_mask_x_count 2 +shadow_mask_y_count 2 +shadow_mask_usize 0.5 +shadow_mask_vsize 0.5 +shadow_mask_uoffset 0.0 +shadow_mask_voffset 0.0 +curvature 0.0 +round_corner 0.0 +smooth_border 0.0 +reflection 0.0 +vignetting 0.0 +scanline_alpha 0.0 +defocus 0.0,0.0 +converge_x 0.0,0.0,0.0 +converge_y 0.0,0.0,0.0 +radial_converge_x 0.0,0.0,0.0 +radial_converge_y 0.0,0.0,0.0 +red_ratio 1.0,0.0,0.0 +grn_ratio 0.0,1.0,0.0 +blu_ratio 0.0,0.0,1.0 +saturation 1.0 +offset 0.0,0.0,0.0 +scale 1.0,1.0,1.0 +power 1.0,1.0,1.0 +floor 0.0,0.0,0.0 +phosphor_life 0.5,0.5,0.5 + +# +# NTSC POST-PROCESSING OPTIONS +# +yiq_enable 0 + +# +# BLOOM POST-PROCESSING OPTIONS +# +bloom_blend_mode 1 +bloom_scale 1.0 +bloom_overdrive 0.0,0.0,0.0 +bloom_lvl0_weight 1.0 +bloom_lvl1_weight 0.64 +bloom_lvl2_weight 0.32 +bloom_lvl3_weight 0.16 +bloom_lvl4_weight 0.08 +bloom_lvl5_weight 0.04 +bloom_lvl6_weight 0.04 +bloom_lvl7_weight 0.02 +bloom_lvl8_weight 0.02 +bloom_lvl9_weight 0.01 +bloom_lvl10_weight 0.01
\ No newline at end of file diff --git a/ini/gba.ini b/ini/gba.ini new file mode 100644 index 00000000000..009cc255176 --- /dev/null +++ b/ini/gba.ini @@ -0,0 +1,55 @@ +# +# DIRECT3D POST-PROCESSING OPTIONS +# +shadow_mask_tile_mode 1 +shadow_mask_alpha 0.75 +shadow_mask_texture slot-mask-aligned.png +shadow_mask_x_count 2 +shadow_mask_y_count 2 +shadow_mask_usize 0.1875 +shadow_mask_vsize 0.1875 +shadow_mask_uoffset 0.0 +shadow_mask_voffset 0.0 +curvature 0.0 +round_corner 0.0 +smooth_border 0.0 +reflection 0.0 +vignetting 0.0 +scanline_alpha 0.0 +defocus 0.0,0.0 +converge_x 0.0,0.0,0.0 +converge_y 0.0,0.0,0.0 +radial_converge_x 0.0,0.0,0.0 +radial_converge_y 0.0,0.0,0.0 +red_ratio 1.0,0.0,0.0 +grn_ratio 0.0,1.0,0.0 +blu_ratio 0.0,0.0,1.0 +saturation 1.0 +offset 0.0,0.0,0.0 +scale 1.0,1.0,1.0 +power 1.0,1.0,1.0 +floor 0.0,0.0,0.0 +phosphor_life 0.5,0.5,0.5 + +# +# NTSC POST-PROCESSING OPTIONS +# +yiq_enable 0 + +# +# BLOOM POST-PROCESSING OPTIONS +# +bloom_blend_mode 0 +bloom_scale 0.25 +bloom_overdrive 0.0,0.0,0.0 +bloom_lvl0_weight 1.0 +bloom_lvl1_weight 0.64 +bloom_lvl2_weight 0.32 +bloom_lvl3_weight 0.16 +bloom_lvl4_weight 0.08 +bloom_lvl5_weight 0.04 +bloom_lvl6_weight 0.04 +bloom_lvl7_weight 0.02 +bloom_lvl8_weight 0.02 +bloom_lvl9_weight 0.01 +bloom_lvl10_weight 0.01
\ No newline at end of file diff --git a/ini/raster.ini b/ini/raster.ini new file mode 100644 index 00000000000..cc0b1cfb514 --- /dev/null +++ b/ini/raster.ini @@ -0,0 +1,60 @@ +# +# DIRECT3D POST-PROCESSING OPTIONS +# +shadow_mask_tile_mode 0 +shadow_mask_alpha 0.35 +shadow_mask_texture shadow-mask.png +shadow_mask_x_count 6 +shadow_mask_y_count 4 +shadow_mask_usize 0.1875 +shadow_mask_vsize 0.25 +shadow_mask_uoffset 0.0 +shadow_mask_voffset 0.0 +curvature 0.0 +round_corner 0.0 +smooth_border 0.0 +reflection 0.0 +vignetting 0.0 +scanline_alpha 0.50 +scanline_size 1.0 +scanline_height 1.0 +scanline_bright_scale 2.0 +scanline_bright_offset 0.0 +scanline_jitter 0.0 +defocus 1.0,0.0 +converge_x 0.0,0.0,0.0 +converge_y 0.0,0.0,0.0 +radial_converge_x 0.0,0.0,0.0 +radial_converge_y 0.0,0.0,0.0 +red_ratio 1.05,0.00,0.10 +grn_ratio -0.10,1.00,0.25 +blu_ratio -0.25,0.25,1.25 +saturation 1.25 +offset -0.30,-0.20,-0.05 +scale 1.15,1.05,0.90 +power 0.90,0.90,1.15 +floor 0.05,0.05,0.05 +phosphor_life 0.5,0.5,0.5 + +# +# NTSC POST-PROCESSING OPTIONS +# +yiq_enable 0 + +# +# BLOOM POST-PROCESSING OPTIONS +# +bloom_blend_mode 0 +bloom_scale 0.35 +bloom_overdrive 1.00,1.00,1.00 +bloom_lvl0_weight 1.00 +bloom_lvl1_weight 0.64 +bloom_lvl2_weight 0.32 +bloom_lvl3_weight 0.16 +bloom_lvl4_weight 0.08 +bloom_lvl5_weight 0.04 +bloom_lvl6_weight 0.04 +bloom_lvl7_weight 0.02 +bloom_lvl8_weight 0.02 +bloom_lvl9_weight 0.01 +bloom_lvl10_weight 0.01
\ No newline at end of file diff --git a/ini/vector.ini b/ini/vector.ini new file mode 100644 index 00000000000..3f1145d5676 --- /dev/null +++ b/ini/vector.ini @@ -0,0 +1,75 @@ +# +# CORE VECTOR OPTIONS +# +antialias 1 +beam_width_min 0.50 +beam_width_max 4.00 +beam_intensity_weight 0.75 +flicker 0.15 + +# +# DIRECT3D POST-PROCESSING OPTIONS +# +shadow_mask_tile_mode 0 +shadow_mask_alpha 0.5 +shadow_mask_texture shadow-mask.png +shadow_mask_x_count 6 +shadow_mask_y_count 4 +shadow_mask_usize 0.1875 +shadow_mask_vsize 0.25 +shadow_mask_uoffset 0.0 +shadow_mask_voffset 0.0 +curvature 0.0 +round_corner 0.0 +smooth_border 0.0 +reflection 0.0 +vignetting 0.0 +scanline_alpha 0.0 +scanline_size 0.0 +scanline_height 0.0 +scanline_bright_scale 0.0 +scanline_bright_offset 0.0 +scanline_jitter 0.0 +defocus 0.0,0.0 +converge_x 0.0,0.0,0.0 +converge_y 0.0,0.0,0.0 +radial_converge_x 0.0,0.0,0.0 +radial_converge_y 0.0,0.0,0.0 +red_ratio 1.0,0.0,0.1 +grn_ratio 0.0,1.0,0.0 +blu_ratio 0.0,0.0,1.0 +saturation 1.0 +offset 0.0,0.0,0.0 +scale 1.0,1.0,1.0 +power 1.0,1.0,1.0 +floor 0.0,0.0,0.0 +phosphor_life 0.5,0.5,0.5 + +# +# NTSC POST-PROCESSING OPTIONS +# +yiq_enable 0 + +# +# VECTOR POST-PROCESSING OPTIONS +# +vector_length_scale 0.8 +vector_length_ratio 500.0 + +# +# BLOOM POST-PROCESSING OPTIONS +# +bloom_blend_mode 0 +bloom_scale 1.50 +bloom_overdrive 1.50,1.50,1.50 +bloom_lvl0_weight 1.00 +bloom_lvl1_weight 0.64 +bloom_lvl2_weight 0.32 +bloom_lvl3_weight 0.16 +bloom_lvl4_weight 0.24 +bloom_lvl5_weight 0.32 +bloom_lvl6_weight 0.48 +bloom_lvl7_weight 0.32 +bloom_lvl8_weight 0.24 +bloom_lvl9_weight 0.16 +bloom_lvl10_weight 0.08
\ No newline at end of file diff --git a/src/osd/modules/render/d3d/d3dcomm.h b/src/osd/modules/render/d3d/d3dcomm.h index 4894cd7f491..6240deb3011 100644 --- a/src/osd/modules/render/d3d/d3dcomm.h +++ b/src/osd/modules/render/d3d/d3dcomm.h @@ -77,6 +77,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; } @@ -148,7 +150,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); d3d_texture_manager * m_texture_manager; // texture manager pointer @@ -244,7 +245,7 @@ public: cache_target() { } ~cache_target(); - bool init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height, int prescale_x, int prescale_y); + bool init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height); surface *last_target; texture *last_texture; @@ -269,31 +270,34 @@ public: d3d_render_target() { } ~d3d_render_target(); - bool init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height, int prescale_x, int prescale_y); + bool init(renderer_d3d9 *d3d, 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; 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]; d3d_render_target *next; d3d_render_target *prev; - surface *bloom_target[11]; + surface *bloom_surface[11]; texture *bloom_texture[11]; + + float bloom_dims[11][2]; + + int bloom_count; }; #endif diff --git a/src/osd/modules/render/d3d/d3dhlsl.cpp b/src/osd/modules/render/d3d/d3dhlsl.cpp index 17b2f411336..c55c679be54 100644 --- a/src/osd/modules/render/d3d/d3dhlsl.cpp +++ b/src/osd/modules/render/d3d/d3dhlsl.cpp @@ -60,7 +60,7 @@ static direct3dx9_loadeffect_ptr g_load_effect = nullptr; //============================================================ shaders::shaders() : - d3dintf(nullptr), machine(nullptr), d3d(nullptr), 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(nullptr), machine(nullptr), d3d(nullptr), num_screens(0), curr_screen(0), curr_frame(0), vecbuf_type(), vecbuf_index(0), vecbuf_count(0), avi_output_file(nullptr), avi_frame(0), avi_copy_surface(nullptr), avi_copy_texture(nullptr), avi_final_target(nullptr), avi_final_texture(nullptr), black_surface(nullptr), black_texture(nullptr), render_snap(false), snap_rendered(false), snap_copy_target(nullptr), snap_copy_texture(nullptr), snap_target(nullptr), snap_texture(nullptr), snap_width(0), snap_height(0), lines_pending(false), backbuffer(nullptr), curr_effect(nullptr), default_effect(nullptr), prescale_effect(nullptr), post_effect(nullptr), distortion_effect(nullptr), @@ -69,11 +69,8 @@ shaders::shaders() : { master_enable = false; vector_enable = true; - hlsl_prescale_x = 1; - hlsl_prescale_x = 1; - preset = -1; - shadow_texture = nullptr; - options = nullptr; + shadow_texture = NULL; + options = NULL; paused = true; lastidx = -1; targethead = nullptr; @@ -668,8 +665,6 @@ void shaders::init(d3d_base *d3dintf, running_machine *machine, renderer_d3d9 *r 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(); @@ -957,6 +952,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); @@ -986,18 +982,11 @@ int shaders::create_resources(bool reset) phosphor_effect->add_uniform("Phosphor", uniform::UT_VEC3, uniform::CU_PHOSPHOR_LIFE); - post_effect->add_uniform("VignettingAmount", uniform::UT_FLOAT, uniform::CU_POST_VIGNETTING); // backward compatibility - post_effect->add_uniform("CurvatureAmount", uniform::UT_FLOAT, uniform::CU_POST_CURVATURE); // backward compatibility - post_effect->add_uniform("RoundCornerAmount", uniform::UT_FLOAT, uniform::CU_POST_ROUND_CORNER); // backward compatibility - post_effect->add_uniform("SmoothBorderAmount", uniform::UT_FLOAT, uniform::CU_POST_SMOOTH_BORDER); // backward compatibility - post_effect->add_uniform("ReflectionAmount", uniform::UT_FLOAT, uniform::CU_POST_REFLECTION); // backward compatibility - post_effect->add_uniform("ShadowAlpha", uniform::UT_FLOAT, uniform::CU_POST_SHADOW_ALPHA); post_effect->add_uniform("ShadowCount", uniform::UT_VEC2, uniform::CU_POST_SHADOW_COUNT); post_effect->add_uniform("ShadowUV", uniform::UT_VEC2, uniform::CU_POST_SHADOW_UV); post_effect->add_uniform("ShadowUVOffset", uniform::UT_VEC2, uniform::CU_POST_SHADOW_UV_OFFSET); post_effect->add_uniform("ShadowDims", uniform::UT_VEC2, uniform::CU_POST_SHADOW_DIMS); - post_effect->add_uniform("ScanlineAlpha", uniform::UT_FLOAT, uniform::CU_POST_SCANLINE_ALPHA); post_effect->add_uniform("ScanlineScale", uniform::UT_FLOAT, uniform::CU_POST_SCANLINE_SCALE); post_effect->add_uniform("ScanlineHeight", uniform::UT_FLOAT, uniform::CU_POST_SCANLINE_HEIGHT); @@ -1005,7 +994,6 @@ int shaders::create_resources(bool reset) post_effect->add_uniform("ScanlineBrightOffset", uniform::UT_FLOAT, uniform::CU_POST_SCANLINE_BRIGHT_OFFSET); post_effect->add_uniform("Power", uniform::UT_VEC3, uniform::CU_POST_POWER); post_effect->add_uniform("Floor", uniform::UT_VEC3, uniform::CU_POST_FLOOR); - post_effect->add_uniform("RotationType", uniform::UT_INT, uniform::CU_ROTATION_TYPE); distortion_effect->add_uniform("VignettingAmount", uniform::UT_FLOAT, uniform::CU_POST_VIGNETTING); @@ -1013,7 +1001,6 @@ int shaders::create_resources(bool reset) distortion_effect->add_uniform("RoundCornerAmount", uniform::UT_FLOAT, uniform::CU_POST_ROUND_CORNER); distortion_effect->add_uniform("SmoothBorderAmount", uniform::UT_FLOAT, uniform::CU_POST_SMOOTH_BORDER); distortion_effect->add_uniform("ReflectionAmount", uniform::UT_FLOAT, uniform::CU_POST_REFLECTION); - distortion_effect->add_uniform("RotationType", uniform::UT_INT, uniform::CU_ROTATION_TYPE); initialized = true; @@ -1035,7 +1022,7 @@ void shaders::begin_draw() curr_effect = default_effect; - default_effect->set_technique("DefaultTechnique"); + default_effect->set_technique("ScreenTechnique"); post_effect->set_technique("DefaultTechnique"); distortion_effect->set_technique("DefaultTechnique"); prescale_effect->set_technique("DefaultTechnique"); @@ -1236,9 +1223,9 @@ int shaders::ntsc_pass(d3d_render_target *rt, int source_index, poly_info *poly, 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; } @@ -1293,7 +1280,7 @@ int shaders::color_convolution_pass(d3d_render_target *rt, int source_index, pol // 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; } @@ -1304,10 +1291,11 @@ int shaders::prescale_pass(d3d_render_target *rt, int source_index, poly_info *p 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; } @@ -1327,10 +1315,11 @@ int shaders::deconverge_pass(d3d_render_target *rt, int source_index, poly_info 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; } @@ -1347,10 +1336,11 @@ int shaders::defocus_pass(d3d_render_target *rt, int source_index, poly_info *po 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; } @@ -1367,21 +1357,23 @@ int shaders::phosphor_pass(d3d_render_target *rt, cache_target *ct, int source_i 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; } @@ -1390,9 +1382,6 @@ int shaders::post_pass(d3d_render_target *rt, int source_index, poly_info *poly, { 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++) @@ -1409,15 +1398,20 @@ int shaders::post_pass(d3d_render_target *rt, int source_index, poly_info *poly, float screen_scale[2] = { xscale, yscale }; float screen_offset[2] = { xoffset, yoffset }; - rgb_t back_color_rgb = !machine->first_screen()->has_palette() ? rgb_t(0, 0, 0) : machine->first_screen()->palette().palette()->entry_color(0); + rgb_t back_color_rgb = !machine->first_screen()->has_palette() + ? rgb_t(0, 0, 0) + : machine->first_screen()->palette().palette()->entry_color(0); back_color_rgb = apply_color_convolution(back_color_rgb); - float back_color[3] = { static_cast<float>(back_color_rgb.r()) / 255.0f, static_cast<float>(back_color_rgb.g()) / 255.0f, static_cast<float>(back_color_rgb.b()) / 255.0f }; + float back_color[3] = { + static_cast<float>(back_color_rgb.r()) / 255.0f, + static_cast<float>(back_color_rgb.g()) / 255.0f, + static_cast<float>(back_color_rgb.b()) / 255.0f }; curr_effect = post_effect; curr_effect->update_uniforms(); curr_effect->set_texture("ShadowTexture", shadow_texture == nullptr ? nullptr : 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); @@ -1425,10 +1419,10 @@ int shaders::post_pass(d3d_render_target *rt, int source_index, poly_info *poly, 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; } @@ -1443,38 +1437,22 @@ int shaders::downsample_pass(d3d_render_target *rt, int source_index, poly_info 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_width = prepare_vector ? rt->target_width : rt->target_width / hlsl_prescale_x; - float bloom_height = prepare_vector ? rt->target_height : rt->target_height / hlsl_prescale_y; - float bloom_size = (bloom_width < bloom_height) ? bloom_width : bloom_height; - for (; bloom_size >= 2.0f && bloom_index < 11; bloom_size *= 0.5f) + for (int bloom_index = 0; bloom_index < rt->bloom_count; bloom_index++) { - bloom_dims[bloom_index][0] = (float)(int)bloom_width; - bloom_dims[bloom_index][1] = (float)(int)bloom_height; - - curr_effect->set_vector("TargetDims", 2, bloom_dims[bloom_index]); + curr_effect->set_vector("TargetDims", 2, rt->bloom_dims[bloom_index]); + curr_effect->set_int("BloomLevel", bloom_index + 1); 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, poly->get_type(), vertnum, poly->get_count()); - - bloom_width *= 0.5f; - bloom_height *= 0.5f; - - bloom_index++; + // blit(rt->bloom_surface[bloom_index], true, D3DPT_TRIANGLELIST, 0, 2); + blit(rt->bloom_surface[bloom_index], true, poly->get_type(), vertnum, poly->get_count()); } - bloom_count = bloom_index; - return next_index; } @@ -1519,33 +1497,34 @@ int shaders::bloom_pass(d3d_render_target *rt, int source_index, poly_info *poly curr_effect->set_vector("Level78Weight", 2, weight78); curr_effect->set_vector("Level9AWeight", 2, weight9A); - curr_effect->set_vector("Level0Size", 2, bloom_dims[0]); - curr_effect->set_vector("Level12Size", 4, bloom_dims[1]); - curr_effect->set_vector("Level34Size", 4, bloom_dims[3]); - curr_effect->set_vector("Level56Size", 4, bloom_dims[5]); - curr_effect->set_vector("Level78Size", 4, bloom_dims[7]); - curr_effect->set_vector("Level9ASize", 4, bloom_dims[9]); + curr_effect->set_vector("Level0Size", 2, rt->bloom_dims[0]); + curr_effect->set_vector("Level12Size", 4, rt->bloom_dims[1]); + curr_effect->set_vector("Level34Size", 4, rt->bloom_dims[3]); + curr_effect->set_vector("Level56Size", 4, rt->bloom_dims[5]); + curr_effect->set_vector("Level78Size", 4, rt->bloom_dims[7]); + curr_effect->set_vector("Level9ASize", 4, rt->bloom_dims[9]); curr_effect->set_int("BloomBlendMode", options->bloom_blend_mode); 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++) + for (int index = 1; index < rt->bloom_count; index++) { name[7] = 'A' + index; curr_effect->set_texture(name, rt->bloom_texture[index - 1]); } - for (int index = bloom_count; index < 11; index++) + for (int index = rt->bloom_count; index < 11; index++) { name[7] = 'A' + index; curr_effect->set_texture(name, black_texture); } 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; } @@ -1566,7 +1545,7 @@ int shaders::distortion_pass(d3d_render_target *rt, int source_index, poly_info 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; @@ -1574,22 +1553,26 @@ int shaders::distortion_pass(d3d_render_target *rt, int source_index, poly_info 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; } @@ -1606,7 +1589,8 @@ int shaders::vector_pass(d3d_render_target *rt, int source_index, poly_info *pol 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; } @@ -1617,13 +1601,13 @@ int shaders::vector_buffer_pass(d3d_render_target *rt, int source_index, poly_in curr_effect = default_effect; curr_effect->update_uniforms(); + curr_effect->set_technique("VectorBufferTechnique"); - curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]); - curr_effect->set_bool("PostPass", true); - curr_effect->set_float("Brighten", 1.0f); + curr_effect->set_texture("Diffuse", 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; } @@ -1632,17 +1616,13 @@ int shaders::screen_pass(d3d_render_target *rt, int source_index, poly_info *pol { 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_technique("ScreenTechnique"); - curr_effect->set_texture("Diffuse", rt->prescale_texture[next_index]); - curr_effect->set_bool("PostPass", true); - curr_effect->set_float("Brighten", prepare_vector ? 1.0f : 0.0f); + curr_effect->set_texture("Diffuse", rt->target_texture[next_index]); - // we do not clear the backbuffe here because multiple screens might rendered into + // we do not clear the backbuffe here because multiple screens might be rendered into blit(backbuffer, false, poly->get_type(), vertnum, poly->get_count()); if (avi_output_file != nullptr) @@ -1660,12 +1640,11 @@ int shaders::screen_pass(d3d_render_target *rt, int source_index, poly_info *pol return next_index; } -void shaders::menu_pass(poly_info *poly, int vertnum) +void shaders::ui_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); + curr_effect->set_technique("UiTechnique"); blit(nullptr, false, poly->get_type(), vertnum, poly->get_count()); } @@ -1694,6 +1673,7 @@ void shaders::render_quad(poly_info *poly, int vertnum) d3d_render_target *rt = curr_render_target; if (rt == nullptr) { + osd_printf_verbose("Direct3D: No raster render target\n"); return; } @@ -1740,6 +1720,7 @@ void shaders::render_quad(poly_info *poly, int vertnum) d3d_render_target *rt = curr_render_target; if (rt == nullptr) { + osd_printf_verbose("Direct3D: No vector render target\n"); return; } @@ -1762,6 +1743,7 @@ void shaders::render_quad(poly_info *poly, int vertnum) d3d_render_target *rt = curr_render_target; if (rt == nullptr) { + osd_printf_verbose("Direct3D: No vector buffer render target\n"); return; } @@ -1800,7 +1782,7 @@ void shaders::render_quad(poly_info *poly, int vertnum) } else { - menu_pass(poly, vertnum); + ui_pass(poly, vertnum); } curr_render_target = nullptr; @@ -1825,23 +1807,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_d3d9* d3d, texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index) +bool shaders::add_cache_target(renderer_d3d9* 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; @@ -1884,7 +1856,10 @@ d3d_render_target* shaders::get_vector_target() void shaders::create_vector_target(render_primitive *prim) { - if (!add_render_target(d3d, nullptr, d3d->get_width(), d3d->get_height(), 1, 1)) + int width = d3d->get_width(); + int height = d3d->get_height(); + + if (!add_render_target(d3d, nullptr, width, height, width, height)) { vector_enable = false; } @@ -1895,7 +1870,7 @@ void shaders::create_vector_target(render_primitive *prim) // shaders::add_render_target - register a render target //============================================================ -bool shaders::add_render_target(renderer_d3d9* d3d, texture_info* info, int width, int height, int xprescale, int yprescale) +bool shaders::add_render_target(renderer_d3d9* d3d, texture_info* info, int width, int height, int target_width, int target_height) { UINT32 screen_index = 0; UINT32 page_index = 0; @@ -1922,7 +1897,7 @@ bool shaders::add_render_target(renderer_d3d9* d3d, texture_info* info, int widt d3d_render_target* target = (d3d_render_target*)global_alloc_clear<d3d_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; @@ -1939,7 +1914,7 @@ bool shaders::add_render_target(renderer_d3d9* d3d, texture_info* info, int widt 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, nullptr, 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); @@ -1952,7 +1927,7 @@ bool shaders::add_render_target(renderer_d3d9* d3d, texture_info* info, int widt cache_target* cache = find_cache_target(target->screen_index, target->width, target->height); if (cache == nullptr) { - 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; @@ -1986,13 +1961,8 @@ void shaders::enumerate_screens() // shaders::register_texture(texture::info) //============================================================ -bool shaders::register_texture(texture_info *texture) +bool shaders::register_texture(render_primitive *prim, 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; @@ -2000,31 +1970,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 == 0) - { - hlsl_prescale_x = 1; - while (width * xscale * hlsl_prescale_x <= d3d->get_width()) - { - hlsl_prescale_x++; - } - hlsl_prescale_x--; - } - - if (hlsl_prescale_y == 0) - { - 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 == 0) ? 1 : hlsl_prescale_x); - hlsl_prescale_y = ((hlsl_prescale_y == 0) ? 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; } @@ -2400,10 +2346,10 @@ slider_desc shaders::s_sliders[] = { "Screen Reflection", 0, 0, 100, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_ANY, SLIDER_REFLECTION, 0.01f, "%1.2f", {} }, { "Image Vignetting", 0, 0, 100, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_ANY, SLIDER_VIGNETTING, 0.01f, "%1.2f", {} }, { "Scanline Darkness", 0, 0, 100, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_ALPHA, 0.01f, "%1.2f", {} }, - { "Scanline Screen Height", 1, 20, 80, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_SCALE, 0.05f, "%1.2f", {} }, - { "Scanline Indiv. Height", 1, 20, 80, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_HEIGHT, 0.05f, "%1.2f", {} }, - { "Scanline Brightness", 0, 20, 40, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_BRIGHT_SCALE, 0.05f, "%1.2f", {} }, - { "Scanline Brightness Overdrive", 0, 0, 20, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_BRIGHT_OFFSET, 0.05f, "%1.2f", {} }, + { "Scanline Screen Scale", 0, 100, 400, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_SCALE, 0.01f, "%1.2f", {} }, + { "Scanline Height", 0, 100, 400, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_HEIGHT, 0.01f, "%1.2f", {} }, + { "Scanline Brightness", 0, 100, 400, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_BRIGHT_SCALE, 0.01f, "%1.2f", {} }, + { "Scanline Brightness Overdrive", 0, 0, 100, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_BRIGHT_OFFSET, 0.01f, "%1.2f", {} }, { "Scanline Jitter", 0, 0, 100, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_SCANLINE_JITTER, 0.01f, "%1.2f", {} }, { "Hum Bar Darkness", 0, 0, 100, 1, SLIDER_FLOAT, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, SLIDER_HUM_BAR_ALPHA, 0.01f, "%2.2f", {} }, { "Defocus", 0, 0, 100, 1, SLIDER_VEC2, SLIDER_SCREEN_TYPE_ANY, SLIDER_DEFOCUS, 0.1f, "%2.1f", {} }, @@ -2661,28 +2607,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 != nullptr) { 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: @@ -2716,12 +2659,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: @@ -2730,6 +2675,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: { @@ -2742,6 +2688,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 4ff8b1ac88c..0c3bc095d4c 100644 --- a/src/osd/modules/render/d3d/d3dhlsl.h +++ b/src/osd/modules/render/d3d/d3dhlsl.h @@ -53,6 +53,7 @@ public: CU_ORIENTATION_SWAP, CU_ROTATION_SWAP, CU_ROTATION_TYPE, + CU_VECTOR_SCREEN, CU_NTSC_CCFREQ, CU_NTSC_A, @@ -318,10 +319,9 @@ public: void init_effect_info(poly_info *poly); 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_d3d9* d3d, texture_info* info, int width, int height, int xprescale, int yprescale); - bool add_cache_target(renderer_d3d9* d3d, texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index); + bool register_texture(render_primitive *prim, texture_info *texture); + bool add_render_target(renderer_d3d9* d3d, texture_info* info, int width, int height, int target_width, int target_height); + bool add_cache_target(renderer_d3d9* d3d, texture_info* info, int width, int height, int screen_index); void window_save(); void window_record(); @@ -352,8 +352,6 @@ private: void end_avi_recording(); void begin_avi_recording(const char *name); - bool register_texture(texture_info *texture, int width, int height, int xscale, int yscale); - d3d_render_target* find_render_target(int width, int height, UINT32 screen_index, UINT32 page_index); cache_target * find_cache_target(UINT32 screen_index, int width, int height); void remove_cache_target(cache_target *cache); @@ -374,7 +372,7 @@ private: int vector_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum); int vector_buffer_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum); int screen_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum); - void menu_pass(poly_info *poly, int vertnum); + void ui_pass(poly_info *poly, int vertnum); d3d_base * d3dintf; // D3D interface @@ -388,13 +386,6 @@ 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 0f50cae8d55..4037c9c0bbe 100644 --- a/src/osd/modules/render/drawd3d.cpp +++ b/src/osd/modules/render/drawd3d.cpp @@ -209,6 +209,7 @@ render_primitive_list *renderer_d3d9::get_primitives() } if (m_shaders != nullptr) { + // 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(); @@ -419,6 +420,63 @@ d3d_texture_manager::~d3d_texture_manager() { } + +//============================================================ +// d3d_texture_manager::compute_texture_size +//============================================================ + +void d3d_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 d3d_texture_manager::create_resources() { // experimental: load a PNG to use for vector rendering; it is treated @@ -636,8 +694,20 @@ void d3d_texture_manager::update_textures() texture_info *texture = find_texinfo(&prim->texture, prim->flags); if (texture == nullptr) { - // if there isn't one, create a new texture - global_alloc(texture_info(this, &prim->texture, m_renderer->window().prescale(), prim->flags)); + if (m_renderer->get_shaders()->enabled()) + { + // create a new texture without prescale, shaders will handle the prescale + texture = global_alloc(texture_info(this, &prim->texture, 1, prim->flags)); + if (texture != nullptr) + { + m_renderer->get_shaders()->register_texture(prim, texture); + } + } + else + { + // create a new texture + texture = global_alloc(texture_info(this, &prim->texture, m_renderer->window().prescale(), prim->flags)); + } } else { @@ -1631,11 +1701,12 @@ void renderer_d3d9::draw_quad(const render_primitive *prim) float height = prim->bounds.y1 - prim->bounds.y0; // set the texture coordinates - if(texture != nullptr) + if (texture != nullptr) { vec2f& start = texture->get_uvstart(); vec2f& stop = texture->get_uvstop(); vec2f delta = stop - start; + vertex[0].u0 = start.c.x + delta.c.x * prim->texcoords.tl.u; vertex[0].v0 = start.c.y + delta.c.y * prim->texcoords.tl.v; vertex[1].u0 = start.c.x + delta.c.x * prim->texcoords.tr.u; @@ -1888,18 +1959,20 @@ texture_info::texture_info(d3d_texture_manager *manager, const render_texinfo* t m_d3dsurface = nullptr; m_d3dfinaltex = nullptr; - // 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 @@ -1957,23 +2030,22 @@ texture_info::texture_info(d3d_texture_manager *manager, const render_texinfo* t m_xprescale = m_yprescale = 1; } - // screen textures with no prescaling are pretty easy + // screen textures with no prescaling are pretty easy and shaders handle prescale itself if (m_xprescale == 1 && m_yprescale == 1) { + // 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; - } - break; } } - // screen textures with prescaling require two allocations else { @@ -1981,23 +2053,32 @@ texture_info::texture_info(d3d_texture_manager *manager, const render_texinfo* t // (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 @@ -2006,15 +2087,13 @@ texture_info::texture_info(d3d_texture_manager *manager, const render_texinfo* t // 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 = nullptr; } @@ -2024,7 +2103,6 @@ texture_info::texture_info(d3d_texture_manager *manager, const render_texinfo* t // 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() != nullptr) m_texture_manager->get_texlist()->m_prev = this; @@ -2044,63 +2122,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 //============================================================ @@ -2112,30 +2133,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; + + m_xborderpix = 0; + m_yborderpix = 0; - compute_size_subroutine(finalwidth, finalheight, &finalwidth, &finalheight); + m_texture_manager->compute_texture_size(finalwidth, finalheight, &finalwidth, &finalheight); + } } // if we're above the max width/height, do what? @@ -2714,18 +2747,20 @@ cache_target::~cache_target() // cache_target::init - initializes a target cache //============================================================ -bool cache_target::init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height, int prescale_x, int prescale_y) +bool cache_target::init(renderer_d3d9 *d3d, 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; } @@ -2743,34 +2778,34 @@ d3d_render_target::~d3d_render_target() (*d3dintf->texture.release)(bloom_texture[index]); bloom_texture[index] = nullptr; } - if (bloom_target[index] != nullptr) + if (bloom_surface[index] != nullptr) { - (*d3dintf->surface.release)(bloom_target[index]); - bloom_target[index] = nullptr; + (*d3dintf->surface.release)(bloom_surface[index]); + bloom_surface[index] = nullptr; } } for (int index = 0; index < 2; index++) { - if (native_texture[index] != nullptr) + if (source_texture[index] != nullptr) { - (*d3dintf->texture.release)(native_texture[index]); - native_texture[index] = nullptr; + (*d3dintf->texture.release)(source_texture[index]); + source_texture[index] = nullptr; } - if (native_target[index] != nullptr) + if (source_surface[index] != nullptr) { - (*d3dintf->surface.release)(native_target[index]); - native_target[index] = nullptr; + (*d3dintf->surface.release)(source_surface[index]); + source_surface[index] = nullptr; } - if (prescale_texture[index] != nullptr) + if (target_texture[index] != nullptr) { - (*d3dintf->texture.release)(prescale_texture[index]); - prescale_texture[index] = nullptr; + (*d3dintf->texture.release)(target_texture[index]); + target_texture[index] = nullptr; } - if (prescale_target[index] != nullptr) + if (target_surface[index] != nullptr) { - (*d3dintf->surface.release)(prescale_target[index]); - prescale_target[index] = nullptr; + (*d3dintf->surface.release)(target_surface[index]); + target_surface[index] = nullptr; } } } @@ -2780,51 +2815,63 @@ d3d_render_target::~d3d_render_target() // d3d_render_target::init - initializes a render target //============================================================ -bool d3d_render_target::init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height, int prescale_x, int prescale_y) +bool d3d_render_target::init(renderer_d3d9 *d3d, 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(); - for (; bloom_size >= 2.0f && bloom_index < 11; bloom_size *= 0.5f) + bool vector_screen = + d3d->window().machine().first_screen()->screen_type() == SCREEN_TYPE_VECTOR; + + // larger blur width for vector screens than raster screens + float scale_factor = vector_screen ? 0.5f : 0.75f; + + float bloom_width = (float)width; + float bloom_height = (float)height; + float bloom_size = bloom_width < bloom_height ? bloom_width : bloom_height; + for (int bloom_index = 0; bloom_index < 11 && bloom_size >= 2.0f; bloom_size *= scale_factor) { - bloom_width *= 0.5f; - bloom_height *= 0.5f; + this->bloom_dims[bloom_index][0] = (int)bloom_width; + this->bloom_dims[bloom_index][1] = (int)bloom_height; result = (*d3dintf->device.create_texture)(d3d->get_device(), (int)bloom_width, (int)bloom_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &bloom_texture[bloom_index]); if (result != D3D_OK) { return false; } - (*d3dintf->texture.get_surface_level)(bloom_texture[bloom_index], 0, &bloom_target[bloom_index]); + (*d3dintf->texture.get_surface_level)(bloom_texture[bloom_index], 0, &bloom_surface[bloom_index]); - bloom_index++; - } + bloom_width *= scale_factor; + bloom_height *= scale_factor; - this->width = width; - this->height = height; + bloom_index++; - target_width = width * prescale_x; - target_height = height * prescale_y; + this->bloom_count = bloom_index; + } return true; } diff --git a/src/osd/windows/winmain.cpp b/src/osd/windows/winmain.cpp index 1171775d042..bd611c470e4 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[] = { nullptr, nullptr, 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, nullptr, 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 9869f3bfecf..b7d87525f81 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" @@ -136,8 +134,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); } |