protected override void DrawOverride() { using (var rasterizerState = RasterizerState.FromDescription(Device, new RasterizerStateDescription { FillMode = FillMode.Wireframe, CullMode = CullMode.None, IsAntialiasedLineEnabled = UseAntialiazing, IsFrontCounterclockwise = false, IsDepthClipEnabled = true })) { DeviceContext.OutputMerger.BlendState = null; DeviceContext.Rasterizer.State = rasterizerState; DeviceContext.ClearRenderTargetView(RenderTargetView, Color.Transparent); using (var buffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { buffer.Resize(DeviceContextHolder, Width, Height, null); DeviceContext.ClearRenderTargetView(buffer.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(buffer.TargetView); RenderUv(); DeviceContext.Rasterizer.State = null; PrepareForFinalPass(); if (UseFxaa) { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, buffer.View, RenderTargetView); } else { DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, buffer.View, RenderTargetView); } } } }
private void AddShadow() { DeviceContext.OutputMerger.BlendState = _bakedBlendState; DeviceContext.OutputMerger.DepthStencilState = null; DeviceContext.Rasterizer.State = null; DeviceContext.Rasterizer.SetViewports(Viewport); DeviceContext.OutputMerger.SetTargets(_bufferF1.TargetView); DeviceContext.ClearRenderTargetView(_bufferF1.TargetView, new Color4(0f, 0f, 0f, 0f)); _effect.FxDepthMap.SetResource(_shadowBuffer.View); _effect.FxShadowViewProj.SetMatrix(_shadowCamera.ViewProj * new Matrix { M11 = 0.5f, M22 = -0.5f, M33 = 1.0f, M41 = 0.5f, M42 = 0.5f, M44 = 1.0f }); RenderPieces(); // DeviceContext.Rasterizer.State = null; // copy to summary buffer DeviceContext.OutputMerger.BlendState = _summBlendState; DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, _bufferF1.View, _bufferFSumm.TargetView); }
private bool AaPass(ShaderResourceView input, RenderTargetView output) { if (IsSmaaAvailable && UseSmaa) { throw new NotImplementedException(); } if (UseSsaa) { if (UseFxaa) { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, input, _bufferFSsaaFxaa.TargetView, new Vector2(Width, Height)); input = _bufferFSsaaFxaa.View; } DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, input, new Vector2(Width, Height), output, new Vector2(ActualWidth, ActualHeight), TemporaryFlag); return(true); } if (UseFxaa) { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, input, output); return(true); } return(false); }
// slower, but more accurate private void CustomBlending(TargetResourceTexture result, TargetResourceTexture foreground, TargetResourceTexture temporary, Color4 color) { // ssaa if needed ShaderResourceView view; if (UseSsaa) { DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, foreground, _a0Buffer); view = _a0Buffer.View; } else { view = foreground.View; } DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, result.View, temporary.TargetView); DeviceContextHolder.PrepareQuad(_effect.LayoutPT); DeviceContext.OutputMerger.SetTargets(result.TargetView); _effect.FxInputMap.SetResource(view); _effect.FxBgMap.SetResource(temporary.View); _effect.FxBlendColor.Set(color); _effect.TechBlend.DrawAllPasses(DeviceContext, 6); }
public static AoHelperBase GetHelper(this AoType type, DeviceContextHolder holder) { switch (type) { case AoType.Ssao: return(holder.GetHelper <SsaoHelper>()); case AoType.SsaoAlt: return(holder.GetHelper <SsaoAltHelper>()); case AoType.Hbao: return(holder.GetHelper <HbaoHelper>()); default: throw new ArgumentOutOfRangeException(); } }
private void Draw(float multipler, [CanBeNull] IProgress <double> progress, CancellationToken cancellation) { _effect.FxAmbient.Set(Ambient); DeviceContext.ClearRenderTargetView(_bufferFSumm.TargetView, Color.Transparent); DeviceContext.ClearRenderTargetView(_bufferA.TargetView, Color.Transparent); // draw var t = DrawLights(progress, cancellation); if (cancellation.IsCancellationRequested) { return; } DeviceContextHolder.PrepareQuad(_effect.LayoutPT); DeviceContext.Rasterizer.State = null; DeviceContext.OutputMerger.BlendState = null; DeviceContext.OutputMerger.DepthStencilState = null; DeviceContext.Rasterizer.SetViewports(Viewport); _effect.FxSize.Set(new Vector4(Width, Height, 1f / Width, 1f / Height)); DeviceContext.ClearRenderTargetView(_bufferF1.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(_bufferF1.TargetView); _effect.FxInputMap.SetResource(_bufferFSumm.View); _effect.FxCount.Set(t / SkyBrightnessLevel); _effect.FxMultipler.Set(multipler); _effect.FxGamma.Set(Gamma); _effect.FxScreenSize.Set(new Vector2(Width, Height)); _effect.TechAoResult.DrawAllPasses(DeviceContext, 6); for (var i = 0; i < Padding; i++) { DeviceContext.ClearRenderTargetView(_bufferF2.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(_bufferF2.TargetView); _effect.FxInputMap.SetResource(_bufferF1.View); _effect.TechAoGrow.DrawAllPasses(DeviceContext, 6); DeviceContext.ClearRenderTargetView(_bufferF1.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(_bufferF1.TargetView); _effect.FxInputMap.SetResource(_bufferF2.View); _effect.TechAoGrow.DrawAllPasses(DeviceContext, 6); } if (UseFxaa) { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, _bufferF1.View, _bufferF2.TargetView); PrepareForFinalPass(); DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, _bufferF2, _bufferA); } else { PrepareForFinalPass(); DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, _bufferF1, _bufferA); } DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, _bufferA.View, RenderTargetView); }
private void BloomThenAa() { var bloomView = HdrPass(_bufferF.View, _bufferA.TargetView, OutputViewport) ? _bufferA.View : _bufferF.View; var aa = AaPass(bloomView, RenderTargetView); if (!aa) { // AA stage didn’t move bloomed buffer to RTV DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, bloomView, RenderTargetView); } }
private void ProcessHdr(TargetResourceTexture target, TargetResourceTexture source, TargetResourceTexture temporary) { switch (Mode) { case RenderingMode.DebugGBuffer: case RenderingMode.DebugPostEffects: case RenderingMode.DebugLocalReflections: return; } DeviceContext.OutputMerger.SetTargets(target.TargetView); DeviceContext.ClearRenderTargetView(target.TargetView, ColorTransparent); DeviceContext.OutputMerger.BlendState = null; DeviceContextHolder.GetHelper <HdrHelper>().Draw(DeviceContextHolder, source.View, temporary); }
private void DrawReflections(TargetResourceTexture target, TargetResourceTexture temporary = null, TargetResourceTexture light = null, DepthStencilView limitedBy = null) { var sslr = DeviceContextHolder.GetHelper <SslrHelper>(); DeviceContextHolder.QuadBuffers.Prepare(DeviceContext, sslr.Effect.LayoutPT); DeviceContext.OutputMerger.BlendState = null; if (limitedBy == null) { DeviceContext.OutputMerger.SetTargets(target.TargetView); } else { DeviceContext.OutputMerger.SetTargets(limitedBy, target.TargetView); DeviceContext.OutputMerger.DepthStencilState = DeviceContextHolder.States.GreaterReadOnlyDepthState; } // camera position & matrix sslr.Effect.FxWorldViewProj.SetMatrix(Camera.ViewProj); sslr.Effect.FxWorldViewProjInv.SetMatrix(Camera.ViewProjInvert); sslr.Effect.FxEyePosW.Set(Camera.Position); // g-buffer sslr.Effect.FxBaseMap.SetResource(_gBufferBase.View); sslr.Effect.FxNormalMap.SetResource(_gBufferNormal.View); sslr.Effect.FxDepthMap.SetResource(_gDepthBuffer.View); sslr.Effect.FxLightMap.SetResource(light?.View); sslr.Effect.TechHabrahabrVersion.DrawAllPasses(DeviceContext, 6); if (temporary != null) { DeviceContext.OutputMerger.SetTargets(temporary.TargetView); DeviceContextHolder.GetHelper <BlurHelper>().BlurReflectionVertically(DeviceContextHolder, target.View, _gBufferMaps.View); DeviceContext.OutputMerger.SetTargets(target.TargetView); DeviceContextHolder.GetHelper <BlurHelper>().BlurReflectionHorizontally(DeviceContextHolder, temporary.View, _gBufferMaps.View); } if (limitedBy != null) { DeviceContext.OutputMerger.DepthStencilState = null; } }
public void OnInitialize(DeviceContextHolder holder) { _effect = holder.GetEffect<EffectPpHdr>(); _blurHelper = holder.GetHelper<BlurHelper>(); _textures = Enumerable.Range(0, DownsamplerAdaptationCycles) .Select(x => TargetResourceTexture.Create(Format.R16G16B16A16_Float)) .ToArray(); _averateColor = Enumerable.Range(0, 2).Select(x => { var t = TargetResourceTexture.Create(Format.R16G16B16A16_Float); t.Resize(holder, 1, 1); return t; }).ToArray(); _newAverageColor = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _newAverageColor.Resize(holder, 1, 1); _bloomTexture = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _tempTexture = TargetResourceTexture.Create(Format.R16G16B16A16_Float); }
private AoHelperBase GetAoHelper() { switch (AoType) { case AoType.Ssao: return(DeviceContextHolder.GetHelper <SsaoHelper>()); case AoType.SsaoAlt: return(DeviceContextHolder.GetHelper <SsaoAltHelper>()); case AoType.Hbao: return(DeviceContextHolder.GetHelper <HbaoHelper>()); case AoType.Assao: return(DeviceContextHolder.GetHelper <AssaoHelper>()); default: throw new ArgumentOutOfRangeException(); } }
protected sealed override void DrawSprites() { var sprite = Sprite; if (sprite == null) { throw new NotSupportedException(); } // drawing GUI sprite.HandleBlendState = false; sprite.HandleDepthStencilState = false; DeviceContext.OutputMerger.SetTargets(_temporaryBuffer0.TargetView); DeviceContext.ClearRenderTargetView(_temporaryBuffer0.TargetView, Color.Transparent); DrawSpritesInner(); sprite.Flush(); // blurring DeviceContext.OutputMerger.BlendState = null; DeviceContextHolder.GetHelper <BlurHelper>().Blur(DeviceContextHolder, _temporaryBuffer0, _temporaryBuffer1, target: _temporaryBuffer2, iterations: 2); // as a shadow _ppBasic.FxScreenSize.Set(new Vector4(Width, Height, 1f / Width, 1f / Height)); DeviceContext.OutputMerger.SetTargets(_temporaryBuffer1.TargetView); DeviceContextHolder.QuadBuffers.Prepare(DeviceContext, _ppBasic.LayoutPT); _ppBasic.FxInputMap.SetResource(_temporaryBuffer2.View); _ppBasic.FxOverlayMap.SetResource(_temporaryBuffer0.View); _ppBasic.TechShadow.DrawAllPasses(DeviceContext, 6); // combining with _outputBuffer ResetTargets(); DeviceContextHolder.PrepareQuad(_ppBasic.LayoutPT); _ppBasic.FxInputMap.SetResource(_outputBuffer.View); _ppBasic.FxOverlayMap.SetResource(_temporaryBuffer1.View); _ppBasic.TechOverlay.DrawAllPasses(DeviceContext, 6); }
public void OnInitialize(DeviceContextHolder holder) { _effect = holder.GetEffect <EffectPpHdr>(); _blurHelper = holder.GetHelper <BlurHelper>(); _textures = Enumerable.Range(0, DownsamplerAdaptationCycles) .Select(x => TargetResourceTexture.Create(Format.R16G16B16A16_Float)) .ToArray(); _averateColor = Enumerable.Range(0, 2).Select(x => { var t = TargetResourceTexture.Create(Format.R16G16B16A16_Float); t.Resize(holder, 1, 1, null); return(t); }).ToArray(); _newAverageColor = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _newAverageColor.Resize(holder, 1, 1, null); _bloomTexture = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _tempTexture = TargetResourceTexture.Create(Format.R16G16B16A16_Float); }
private void AaThenBloom() { var aaView = AaPass(_bufferF.View, _bufferA.TargetView) ? _bufferA.View : _bufferF.View; if (UseColorGrading) { var hdrView = HdrPass(aaView, _bufferAColorGrading.TargetView, _bufferAColorGrading.Viewport) ? _bufferAColorGrading.View : aaView; if (!ColorGradingPass(hdrView, RenderTargetView, OutputViewport)) { // nothing happened in color grading stage DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, hdrView, RenderTargetView); } } else { if (!HdrPass(aaView, RenderTargetView, OutputViewport)) { // HDR stage didn’t move AA buffer to RTV DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, aaView, RenderTargetView); } } }
protected void FinalStep(TargetResourceTexture source) { DeviceContext.ClearRenderTargetView(_outputBuffer.TargetView, ColorTransparent); if (!UseFxaa) { DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, source.View, _outputBuffer.TargetView); return; } if (UseExperimentalSmaa) { DeviceContextHolder.GetHelper <SmaaHelper>().Draw(DeviceContextHolder, source.View, _outputBuffer.TargetView, _gBufferBase, _temporaryBuffer3); } else if (UseExperimentalFxaa) { DeviceContextHolder.GetHelper <Fxaa311Helper>().Draw(DeviceContextHolder, source.View, _outputBuffer.TargetView, _gBufferMaps); } else { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, source.View, _outputBuffer.TargetView); } }
protected override void DrawOverride() { EnsureAiLaneAllRight(); Camera.UpdateViewMatrix(); // just in case DeviceContext.ClearRenderTargetView(_buffer0.TargetView, Color.Black); DeviceContext.ClearRenderTargetView(_buffer1.TargetView, Color.Black); DeviceContext.ClearRenderTargetView(RenderTargetView, Color.Transparent); // render to buffer-0 DeviceContext.OutputMerger.SetTargets(_buffer0.TargetView); DeviceContext.OutputMerger.BlendState = null; DeviceContext.Rasterizer.State = DeviceContextHolder.States.DoubleSidedState; FilteredNode.Draw(DeviceContextHolder, Camera, SpecialRenderMode.Simple); DeviceContext.Rasterizer.State = null; // blur to buffer-0 using buffer-1 as temporary DeviceContextHolder.GetHelper <TrackMapBlurRenderHelper>().Blur(DeviceContextHolder, _buffer0, _buffer1); // outline map and add inset shadow to buffer-1 (alpha is in green channel for optional FXAA) DeviceContextHolder.GetHelper <TrackMapRenderHelper>().Draw(DeviceContextHolder, _buffer0.View, _buffer1.TargetView); // move alpha from green channel to alpha-channel if (UseFxaa) { // applying FXAA first DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, _buffer1.View, _buffer0.TargetView); DeviceContextHolder.GetHelper <TrackMapRenderHelper>().Final(DeviceContextHolder, _buffer0.View, RenderTargetView, !ShotMode); } else { // directly DeviceContextHolder.GetHelper <TrackMapRenderHelper>().Final(DeviceContextHolder, _buffer1.View, RenderTargetView, !ShotMode); } }
protected override void DrawSceneToBuffer() { if (!UseSslr && !UseAo) { base.DrawSceneToBuffer(); return; } DrawPrepare(); if (_sslrHelper == null) { _sslrHelper = DeviceContextHolder.GetHelper <DarkSslrHelper>(); } if (_blurHelper == null) { _blurHelper = DeviceContextHolder.GetHelper <BlurHelper>(); } // Draw scene to G-buffer to get normals, depth and base reflection DeviceContext.Rasterizer.SetViewports(Viewport); DeviceContext.OutputMerger.SetTargets(DepthStencilView, _sslrBufferBaseReflection?.TargetView, _gBufferNormals.TargetView, _gBufferDepth.TargetView); DeviceContext.ClearDepthStencilView(DepthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0); DeviceContext.ClearRenderTargetView(_gBufferNormals.TargetView, (Color4) new Vector4(0.5f)); if (_sslrBufferBaseReflection != null) { DeviceContext.ClearRenderTargetView(_sslrBufferBaseReflection.TargetView, (Color4) new Vector4(0)); } DeviceContext.ClearRenderTargetView(_gBufferDepth.TargetView, (Color4) new Vector4(1f)); DeviceContext.OutputMerger.DepthStencilState = null; DeviceContext.OutputMerger.BlendState = null; DeviceContext.Rasterizer.State = null; if (ShowroomNode != null) { ShowroomNode.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.GBuffer); } else { if (_mirror != null) { if (FlatMirror && !FlatMirrorBlurred) { _mirror.DrawReflection(DeviceContextHolder, ActualCamera, SpecialRenderMode.GBuffer); } else { _mirror.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.GBuffer); } } } CarNode?.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.GBuffer); // AO? if (UseAo) { var aoHelper = _aoHelper; if (aoHelper == null) { aoHelper = _aoHelper = GetAoHelper(); } if (AoType == AoType.Hbao) { UseSslr = true; SetInnerBuffer(_sslrBufferScene); DrawPreparedSceneToBuffer(); (aoHelper as HbaoHelper)?.Prepare(DeviceContextHolder, _sslrBufferScene.View); SetInnerBuffer(null); } aoHelper.Draw(DeviceContextHolder, _gBufferDepth.View, _gBufferNormals.View, ActualCamera, _aoBuffer.TargetView); aoHelper.Blur(DeviceContextHolder, _aoBuffer, InnerBuffer, Camera); var effect = Effect; effect.FxAoMap.SetResource(_aoBuffer.View); Effect.FxAoPower.Set(AoOpacity); effect.FxScreenSize.Set(new Vector4(Width, Height, 1f / Width, 1f / Height)); if (AoDebug) { DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, _aoBuffer.View, InnerBuffer.TargetView); return; } } if (UseSslr && _sslrBufferBaseReflection != null) { // Draw actual scene to _sslrBufferScene SetInnerBuffer(_sslrBufferScene); DrawPreparedSceneToBuffer(); SetInnerBuffer(null); // Prepare SSLR and combine buffers #if SSLR_PARAMETRIZED if (_sslrParamsChanged) { _sslrParamsChanged = false; var effect = DeviceContextHolder.GetEffect <EffectPpDarkSslr>(); effect.FxStartFrom.Set(_sslrStartFrom); effect.FxFixMultiplier.Set(_sslrFixMultiplier); effect.FxOffset.Set(_sslrOffset); effect.FxGlowFix.Set(_sslrGrowFix); effect.FxDistanceThreshold.Set(_sslrDistanceThreshold); } #endif _sslrHelper.Draw(DeviceContextHolder, _gBufferDepth.View, _sslrBufferBaseReflection.View, _gBufferNormals.View, ActualCamera, _sslrBufferResult.TargetView); _blurHelper.BlurDarkSslr(DeviceContextHolder, _sslrBufferResult, InnerBuffer, (float)(2f * ResolutionMultiplier)); _sslrHelper.FinalStep(DeviceContextHolder, _sslrBufferScene.View, _sslrBufferResult.View, _sslrBufferBaseReflection.View, _gBufferNormals.View, ActualCamera, InnerBuffer.TargetView); } else { DrawPreparedSceneToBuffer(); } }
private SourceReady GetOriginal(ref Dictionary <int, ShaderResourceView> storage, [NotNull] PaintShopSource source, int maxSize, Func <ShaderResourceView, ShaderResourceView> preparation = null) { if (MainSlot.Kn5 == null) { return(null); } try { if (storage == null) { storage = new Dictionary <int, ShaderResourceView>(2); if (_sizes == null) { _sizes = new Dictionary <int, Size>(); } } ShaderResourceView original; var sourceHashCode = source.GetHashCode(); var hashCode = (sourceHashCode * 397) ^ maxSize.GetHashCode(); if (!storage.TryGetValue(hashCode, out original)) { Size size; if (source.ByChannels) { var red = source.RedChannelSource == null ? null : GetOriginal(ref storage, source.RedChannelSource, maxSize); var green = source.GreenChannelSource == null ? null : GetOriginal(ref storage, source.GreenChannelSource, maxSize); var blue = source.BlueChannelSource == null ? null : GetOriginal(ref storage, source.BlueChannelSource, maxSize); var alpha = source.AlphaChannelSource == null ? null : GetOriginal(ref storage, source.AlphaChannelSource, maxSize); var redSize = source.RedChannelSource == null ? null : GetSize(source.RedChannelSource); var greenSize = source.GreenChannelSource == null ? null : GetSize(source.GreenChannelSource); var blueSize = source.BlueChannelSource == null ? null : GetSize(source.BlueChannelSource); var alphaSize = source.AlphaChannelSource == null ? null : GetSize(source.AlphaChannelSource); size = Max(redSize, Max(greenSize, Max(blueSize, alphaSize))) ?? new Size(16, 16); _sizes[sourceHashCode] = size; if (size.Width > maxSize || size.Height > maxSize) { size = new Size(maxSize, maxSize); } using (var combined = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { combined.Resize(DeviceContextHolder, size.Width, size.Height, null); UseEffect(e => { red.Set(e.FxAoMap, e.FxAoMapChannels); green.Set(e.FxInputMap, e.FxInputMapChannels); blue.Set(e.FxMaskMap, e.FxMaskMapChannels); alpha.Set(e.FxOverlayMap, e.FxOverlayMapChannels); e.TechCombineChannels.DrawAllPasses(DeviceContext, 6); }, combined); combined.KeepView = true; original = combined.View; } } else { var decoded = GetBytes(source); if (decoded == null) { return(null); } using (var texture = Texture2D.FromMemory(Device, decoded)) { original = new ShaderResourceView(Device, texture); size = new Size(texture.Description.Width, texture.Description.Height); _sizes[sourceHashCode] = size; if (size.Width > maxSize || size.Height > maxSize) { size = new Size(maxSize, maxSize); using (var resized = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { resized.Resize(DeviceContextHolder, maxSize, maxSize, null); DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, original, new Vector2(texture.Description.Width, texture.Description.Height), resized.TargetView, new Vector2(maxSize, maxSize)); original.Dispose(); resized.KeepView = true; original = resized.View; } } } } if (source.Desaturate) { original = Prepare(original, view => Desaturate(view, size)); } if (source.NormalizeMax) { original = Prepare(original, view => NormalizeMax(view, size)); } storage[hashCode] = Prepare(original, preparation); } return(new SourceReady { View = original, ChannelsAssignments = GetChannelAssignments(source) }); } catch (Exception e) { AcToolsLogging.NonFatalErrorNotify("Can’t load texture", null, e); return(null); } }
protected bool HdrPass(ShaderResourceView input, RenderTargetView output, Viewport viewport) { if (UseLensFlares) { // prepare effects if (_lensFlares == null) { _lensFlares = DeviceContextHolder.GetEffect <EffectPpLensFlares>(); } if (_hdr == null) { _hdr = DeviceContextHolder.GetEffect <EffectPpHdr>(); } if (_blur == null) { _blur = DeviceContextHolder.GetHelper <BlurHelper>(); } // filter bright areas by high threshold to downscaled buffer #1 DeviceContext.Rasterizer.SetViewports(_bufferH1.Viewport); DeviceContext.OutputMerger.SetTargets(_bufferH1.TargetView); DeviceContext.ClearRenderTargetView(_bufferH1.TargetView, ColorTransparent); DeviceContextHolder.PrepareQuad(_hdr.LayoutPT); _hdr.FxInputMap.SetResource(input); _hdr.TechBloomHighThreshold.DrawAllPasses(DeviceContext, 6); DeviceContext.Rasterizer.SetViewports(_bufferH2.Viewport); DeviceContext.OutputMerger.SetTargets(_bufferH2.TargetView); DeviceContext.ClearRenderTargetView(_bufferH2.TargetView, ColorTransparent); DeviceContextHolder.PrepareQuad(_lensFlares.LayoutPT); _lensFlares.FxInputMap.SetResource(_bufferH1.View); _lensFlares.TechGhosts.DrawAllPasses(DeviceContext, 6); // blur bright areas from buffer #1 to itself using downscaled buffer #3 as a temporary one _blur.Blur(DeviceContextHolder, _bufferH2, _bufferH1, 2f, 2); // combine original buffer and buffer #1 with blurred bright areas to buffer #2 DeviceContext.Rasterizer.SetViewports(viewport); DeviceContext.OutputMerger.SetTargets(output); _hdr.FxInputMap.SetResource(input); _hdr.FxBloomMap.SetResource(_bufferH2.View); GetHdrTechnique().DrawAllPasses(DeviceContext, 6); return(true); } if (UseBloom) { // prepare effects if (_hdr == null) { _hdr = DeviceContextHolder.GetEffect <EffectPpHdr>(); } if (_blur == null) { _blur = DeviceContextHolder.GetHelper <BlurHelper>(); } // filter bright areas by high threshold to downscaled buffer #1 DeviceContext.Rasterizer.SetViewports(_bufferH1.Viewport); DeviceContext.OutputMerger.SetTargets(_bufferH1.TargetView); DeviceContext.ClearRenderTargetView(_bufferH1.TargetView, ColorTransparent); DeviceContextHolder.PrepareQuad(_hdr.LayoutPT); _hdr.FxInputMap.SetResource(input); _hdr.TechBloomHighThreshold.DrawAllPasses(DeviceContext, 6); // blur bright areas from buffer #1 to itself using downscaled buffer #3 as a temporary one _blur.Blur(DeviceContextHolder, _bufferH1, _bufferH2, 0.5f * BloomRadiusMultiplier, 2); // combine original buffer and buffer #1 with blurred bright areas to buffer #2 DeviceContext.Rasterizer.SetViewports(viewport); DeviceContext.OutputMerger.SetTargets(output); _hdr.FxInputMap.SetResource(input); _hdr.FxBloomMap.SetResource(_bufferH1.View); GetHdrTechnique().DrawAllPasses(DeviceContext, 6); return(true); } if (ToneMapping != ToneMappingFn.None) { if (_hdr == null) { _hdr = DeviceContextHolder.GetEffect <EffectPpHdr>(); } DeviceContext.Rasterizer.SetViewports(viewport); DeviceContext.OutputMerger.SetTargets(output); DeviceContextHolder.PrepareQuad(_hdr.LayoutPT); _hdr.FxInputMap.SetResource(input); _hdr.FxBloomMap.SetResource(null); GetHdrTechnique().DrawAllPasses(DeviceContext, 6); return(true); } return(false); }
public void OnInitialize(DeviceContextHolder holder) { _effect = holder.GetEffect <EffectPpDarkSslr>(); _effect.FxNoiseMap.SetResource(holder.GetRandomTexture(16, 16)); _blurHelper = holder.GetHelper <BlurHelper>(); }
private void Draw(float multipler, [CanBeNull] IProgress <double> progress, CancellationToken cancellation) { _effect.FxAmbient.Set(Ambient); DeviceContext.ClearRenderTargetView(_bufferFSumm.TargetView, Color.Transparent); DeviceContext.ClearRenderTargetView(_bufferA.TargetView, Color.Transparent); var t = Iterations; // draw var iter = 0f; var sw = Stopwatch.StartNew(); for (var k = 0; k < t; k++) { if (sw.ElapsedMilliseconds > 20) { if (cancellation.IsCancellationRequested) { return; } progress?.Report(0.2 + 0.8 * k / t); sw.Restart(); } if (DebugMode) { DrawShadow(Vector3.UnitY, Vector3.UnitZ); } else { var v3 = default(Vector3); var vn = default(Vector3); var length = 0f; var yFrom = (90f - ΘFrom).ToRadians().Cos(); var yTo = (90f - ΘTo).ToRadians().Cos(); if (yTo < yFrom) { throw new Exception("yTo < yFrom"); } do { var x = MathF.Random(-1f, 1f); var y = MathF.Random(yFrom <0f ? -1f : 0f, yTo> 0f ? 1f : 0f); var z = MathF.Random(-1f, 1f); if (x.Abs() < 0.01 && z.Abs() < 0.01) { continue; } v3 = new Vector3(x, y, z); length = v3.Length(); vn = v3 / length; } while (length > 1f || vn.Y < yFrom || vn.Y > yTo); DrawShadow(v3); } AddShadow(); iter++; } DeviceContextHolder.PrepareQuad(_effect.LayoutPT); DeviceContext.Rasterizer.State = null; DeviceContext.OutputMerger.BlendState = null; DeviceContext.OutputMerger.DepthStencilState = null; DeviceContext.Rasterizer.SetViewports(Viewport); _effect.FxSize.Set(new Vector4(Width, Height, 1f / Width, 1f / Height)); DeviceContext.ClearRenderTargetView(_bufferF1.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(_bufferF1.TargetView); _effect.FxInputMap.SetResource(_bufferFSumm.View); _effect.FxCount.Set(iter / SkyBrightnessLevel); _effect.FxMultipler.Set(multipler); _effect.FxGamma.Set(Gamma); _effect.TechAoResult.DrawAllPasses(DeviceContext, 6); for (var i = 0; i < 2; i++) { DeviceContext.ClearRenderTargetView(_bufferF2.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(_bufferF2.TargetView); _effect.FxInputMap.SetResource(_bufferF1.View); _effect.TechAoGrow.DrawAllPasses(DeviceContext, 6); DeviceContext.ClearRenderTargetView(_bufferF1.TargetView, Color.Transparent); DeviceContext.OutputMerger.SetTargets(_bufferF1.TargetView); _effect.FxInputMap.SetResource(_bufferF2.View); _effect.TechAoGrow.DrawAllPasses(DeviceContext, 6); } if (UseFxaa) { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, _bufferF1.View, _bufferF2.TargetView); PrepareForFinalPass(); DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, _bufferF2, _bufferA); } else { PrepareForFinalPass(); DeviceContextHolder.GetHelper <DownsampleHelper>().Draw(DeviceContextHolder, _bufferF1, _bufferA); } DeviceContextHolder.GetHelper <CopyHelper>().Draw(DeviceContextHolder, _bufferA.View, RenderTargetView); /*DeviceContext.OutputMerger.SetTargets(RenderTargetView); * _effect.FxInputMap.SetResource(_bufferA.View); * _effect.TechAoFinalCopy.DrawAllPasses(DeviceContext, 6);*/ }
private void DrawMap(MapViewData map, MapViewData max, Matrix global) { // is the main map? var isMain = FileUtils.ArePathsEqual(map.Filename, CurrentMapFilename); // reset states DeviceContext.OutputMerger.BlendState = null; DeviceContext.Rasterizer.SetViewports(Viewport); // clear buffers just in case DeviceContext.ClearRenderTargetView(_f0Buffer.TargetView, new Color4(0f, 0f, 0f, 0f)); DeviceContext.ClearRenderTargetView(_f1Buffer.TargetView, new Color4(0f, 0f, 0f, 0f)); DeviceContext.ClearRenderTargetView(_a0Buffer.TargetView, new Color4(0f, 0f, 0f, 0f)); DeviceContext.ClearRenderTargetView(_a1Buffer.TargetView, new Color4(0f, 0f, 0f, 0f)); // set width to ai lanes if (UseAiLanes) { map.AiLaneWidth = 25f * ((isMain ? ExtraWidth : ExtraWidth * DimmedWidthMultipler) * 0.7f + 0.15f); } // draw map DeviceContext.OutputMerger.SetTargets(_f0Buffer.TargetView); map.Draw(DeviceContextHolder, _effect, global, max); // pp var current = _f0Buffer; // expand its width if needed if (!UseAiLanes) { var extraWidth = isMain ? ExtraWidth : ExtraWidth * DimmedWidthMultipler; for (var i = 0; i < extraWidth; i++) { var next = current == _f0Buffer ? _f1Buffer : _f0Buffer; DeviceContext.OutputMerger.SetTargets(next.TargetView); _effect.FxInputMap.SetResource(current.View); if (i < extraWidth - 1) { _effect.FxExtraWidth.Set(3f); } else { var last = extraWidth % 1f; _effect.FxExtraWidth.Set(last < 0.0001f ? 3f : last * 3f); } _effect.TechExtraWidth.DrawAllPasses(DeviceContext, 6); current = next; } } // fxaa if needed if (UseFxaa) { var next = current == _f0Buffer ? _f1Buffer : _f0Buffer; DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, current.View, next.TargetView); current = next; } // shadow if needed if (ShadowDistance > 0f && ShadowOpacity > 0f) { var next = current == _f0Buffer ? _f1Buffer : _f0Buffer; DeviceContext.OutputMerger.SetTargets(next.TargetView); _effect.FxInputMap.SetResource(current.View); _effect.TechShadow.DrawAllPasses(DeviceContext, 6); CustomBlending(_aSummBuffer, next, _a1Buffer, new Color4((isMain ? 1f : DimmedOpacity) * ShadowOpacity, 0f, 0f, 0f)); } CustomBlending(_aSummBuffer, current, _a1Buffer, new Color4(isMain ? 1f : DimmedOpacity, 1f, 1f, 1f)); }
public void OnInitialize(DeviceContextHolder holder) { _effect = holder.GetEffect <EffectPpDof>(); _copyHelper = holder.GetHelper <CopyHelper>(); _bokehBaseView = ShaderResourceView.FromMemory(holder.Device, Resources.Bokeh); }
protected override void DrawScene() { // TODO: support more than one car? var effect = Effect; DeviceContext.OutputMerger.DepthStencilState = null; DeviceContext.OutputMerger.BlendState = null; DeviceContext.Rasterizer.State = GetRasterizerState(); var carNode = CarNode; // draw reflection if needed if (ShowroomNode == null && FlatMirror && _mirror != null) { effect.FxLightDir.Set(new Vector3(_light.X, -_light.Y, _light.Z)); if (FlatMirrorBlurred) { DeviceContext.ClearDepthStencilView(_mirrorDepthBuffer.DepthView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0); DeviceContext.ClearRenderTargetView(_mirrorBuffer.TargetView, (Color4)BackgroundColor * BackgroundBrightness); DeviceContext.OutputMerger.SetTargets(_mirrorDepthBuffer.DepthView, _mirrorBuffer.TargetView); DrawMirror(); DeviceContext.Rasterizer.SetViewports(OutputViewport); if (UseFxaa) { DeviceContextHolder.GetHelper <FxaaHelper>().Draw(DeviceContextHolder, _mirrorBuffer.View, _mirrorBlurBuffer.TargetView); DeviceContextHolder.GetHelper <BlurHelper>() .BlurFlatMirror(DeviceContextHolder, _mirrorBlurBuffer, _temporaryBuffer, ActualCamera.ViewProjInvert, _mirrorDepthBuffer.View, 60f); } else { DeviceContextHolder.GetHelper <BlurHelper>() .BlurFlatMirror(DeviceContextHolder, _mirrorBuffer, _temporaryBuffer, ActualCamera.ViewProjInvert, _mirrorDepthBuffer.View, 60f, target: _mirrorBlurBuffer); } DeviceContextHolder.GetHelper <BlurHelper>() .BlurFlatMirror(DeviceContextHolder, _mirrorBlurBuffer, _temporaryBuffer, ActualCamera.ViewProjInvert, _mirrorDepthBuffer.View, 12f); DeviceContext.Rasterizer.SetViewports(Viewport); DeviceContext.OutputMerger.SetTargets(DepthStencilView, InnerBuffer.TargetView); } else { DrawMirror(); } effect.FxLightDir.Set(_light); } // draw a scene, apart from car if (ShowroomNode != null) { if (CubemapAmbient != 0f) { effect.FxCubemapAmbient.Set(0f); } DeviceContext.OutputMerger.DepthStencilState = DeviceContextHolder.States.LessEqualDepthState; ShowroomNode.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.Simple); DeviceContext.OutputMerger.DepthStencilState = DeviceContextHolder.States.ReadOnlyDepthState; ShowroomNode.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.SimpleTransparent); if (CubemapAmbient != 0f) { effect.FxCubemapAmbient.Set(FxCubemapAmbientValue); } } else { // draw a mirror if (_mirror != null) { if (!FlatMirror) { _mirror.SetMode(DeviceContextHolder, FlatMirrorMode.BackgroundGround); _mirror.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.Simple); } else if (FlatMirrorBlurred && _mirrorBuffer != null) { effect.FxScreenSize.Set(new Vector4(Width, Height, 1f / Width, 1f / Height)); // _effect.FxWorldViewProjInv.SetMatrix(ActualCamera.ViewProjInvert); _mirror.SetMode(DeviceContextHolder, FlatMirrorMode.TextureMirror); _mirror.Draw(DeviceContextHolder, ActualCamera, _mirrorBlurBuffer.View, null, null); } else { _mirror.SetMode(DeviceContextHolder, FlatMirrorMode.TransparentMirror); _mirror.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.SimpleTransparent); } } } // draw car if (carNode == null) { return; } // shadows carNode.DrawAmbientShadows(DeviceContextHolder, ActualCamera); // car itself DeviceContext.OutputMerger.DepthStencilState = DeviceContextHolder.States.LessEqualDepthState; carNode.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.Simple); DeviceContext.OutputMerger.DepthStencilState = DeviceContextHolder.States.ReadOnlyDepthState; carNode.Draw(DeviceContextHolder, ActualCamera, SpecialRenderMode.SimpleTransparent); // debug stuff if (SuspensionDebug) { carNode.DrawSuspensionDebugStuff(DeviceContextHolder, ActualCamera); } if (carNode.IsColliderVisible) { carNode.DrawCollidersDebugStuff(DeviceContextHolder, ActualCamera); } }