private ShaderResourceView NormalizeMax(ShaderResourceView view, Size size) { var max = Math.Max(size.Width, size.Height); if (max == 1) { using (var temporary = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { temporary.Resize(DeviceContextHolder, 1, 1, null); UseEffect(e => { e.FxInputMap.SetResource(view); e.FxOverlayMap.SetResource(view); e.TechNormalizeMaxLimits.DrawAllPasses(DeviceContext, 6); }, temporary); temporary.KeepView = true; return(temporary.View); } } using (var maxColor = GetLimits(view, size)) using (var temporary = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { temporary.Resize(DeviceContextHolder, size.Width, size.Height, null); UseEffect(e => { e.FxInputMap.SetResource(view); e.FxOverlayMap.SetResource(maxColor.View); e.TechNormalizeMaxLimits.DrawAllPasses(DeviceContext, 6); }, temporary); temporary.KeepView = true; return(temporary.View); } }
private ShaderResourceView NormalizeMax(ShaderResourceView view, Size size) { var max = Math.Max(size.Width, size.Height); if (max == 1) { using (var temporary = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { temporary.Resize(DeviceContextHolder, 1, 1, null); UseEffect(e => { e.FxInputMap.SetResource(view); e.FxOverlayMap.SetResource(view); e.TechMaximumApply.DrawAllPasses(DeviceContext, 6); }, temporary); temporary.KeepView = true; return(temporary.View); } } var originalView = view; for (var i = max / 4; i > 1 || ReferenceEquals(view, originalView); i /= 4) { if (i < 1) { i = 1; } using (var temporary = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { temporary.Resize(DeviceContextHolder, i, i, null); UseEffect(e => { e.FxInputMap.SetResource(view); e.TechMaximum.DrawAllPasses(DeviceContext, 6); }, temporary); if (!ReferenceEquals(view, originalView)) { view.Dispose(); } view = temporary.View; temporary.KeepView = true; } } using (var temporary = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { temporary.Resize(DeviceContextHolder, size.Width, size.Height, null); UseEffect(e => { e.FxInputMap.SetResource(originalView); e.FxOverlayMap.SetResource(view); e.TechMaximumApply.DrawAllPasses(DeviceContext, 6); }, temporary); view.Dispose(); temporary.KeepView = true; return(temporary.View); } }
private void UpdateBlurredFlatMirror() { var use = FlatMirror && FlatMirrorBlurred; if (use == (_mirrorBuffer != null)) { return; } if (use) { _mirrorBuffer = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _mirrorBlurBuffer = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _temporaryBuffer = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _mirrorDepthBuffer = TargetResourceDepthTexture.Create(); if (!InitiallyResized) { return; } ResizeMirrorBuffers(); } else { DisposeHelper.Dispose(ref _mirrorBuffer); DisposeHelper.Dispose(ref _mirrorBlurBuffer); DisposeHelper.Dispose(ref _temporaryBuffer); DisposeHelper.Dispose(ref _mirrorDepthBuffer); } }
private TargetResourceTexture GetTexture([CanBeNull] string textureName, Action <EffectSpecialPaintShop> update, Size size) { if (_paintShopTextures == null) { _paintShopTextures = new Dictionary <string, TargetResourceTexture>(10); } TargetResourceTexture tex; if (textureName == null) { textureName = ""; } if (!_paintShopTextures.TryGetValue(textureName, out tex)) { tex = _paintShopTextures[textureName] = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); } if (size.Height < 0) { size.Height = size.Width; } tex.Resize(DeviceContextHolder, size.Width, size.Height, null); UseEffect(update, tex); return(tex); }
protected override void InitializeInner() { DeviceContextHolder.Set <IMaterialsFactory>(new TrackMapMaterialsFactory()); if (_aiLane != null) { RootNode = new RenderableList("_root", Matrix.Identity, new [] { AiLaneObject.Create(_aiLane, AiLaneActualWidth ? (float?)null : AiLaneWidth) }); _aiLaneDirty = false; } else if (_kn5 != null) { RootNode = ToRenderableList(Convert(_kn5.RootNode)); } else if (_description != null) { RootNode = new RenderableList("_root", Matrix.Identity, _description.GetEntries().Select(x => { var node = ToRenderableList(Convert(x.Kn5.RootNode)); node.LocalMatrix = x.Matrix; return(node); })); } else { RootNode = new RenderableList(); } _buffer0 = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _buffer1 = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); }
private TargetResourceTexture GetLimits(ShaderResourceView view, Size size, Format?format = null) { TargetResourceTexture result = null; for (var i = Math.Max(size.Width, size.Height) / 4; i >= 1 || result == null; i /= 4) { if (i < 1) { i = 1; } var current = result; result = TargetResourceTexture.Create(format ?? Format.R8G8B8A8_UNorm); result.Resize(DeviceContextHolder, i, i, null); var j = i; var input = current?.View ?? view; UseEffect(e => { e.FxSize.Set(new Vector4(j, j, 1f / j, 1f / j)); e.FxInputMap.SetResource(input); (current == null ? e.TechFindLimitsFirstStep : e.TechFindLimits).DrawAllPasses(DeviceContext, 6); }, result); current?.Dispose(); } return(result); }
private void UpdateGBuffers() { var value = UseSslr || UseAo; if (_gBufferNormals != null == value) { return; } if (value) { _gBufferNormals = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _gBufferDepth = TargetResourceTexture.Create(Format.R32_Float); } else { DisposeHelper.Dispose(ref _gBufferNormals); DisposeHelper.Dispose(ref _gBufferDepth); } if (InitiallyResized) { ResizeGBuffers(); } }
private void RecreateAoBuffer() { if (!UseAo) { DisposeHelper.Dispose(ref _aoBuffer); return; } Format format; switch (AoType) { case AoType.Ssao: case AoType.SsaoAlt: format = Format.R8_UNorm; break; default: format = Format.R8G8B8A8_UNorm; break; } _aoHelper = null; if (_aoBuffer == null || _aoBuffer.Format != format) { DisposeHelper.Dispose(ref _aoBuffer); _aoBuffer = TargetResourceTexture.Create(format); } if (InitiallyResized) { ResizeSsaoBuffers(); } }
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 ShaderResourceView DesaturateMax(ShaderResourceView view, Size size) { using (var temporary = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) { temporary.Resize(DeviceContextHolder, size.Width, size.Height, null); UseEffect(e => { e.FxInputMap.SetResource(view); e.TechDesaturateMax.DrawAllPasses(DeviceContext, 6); }, temporary); temporary.KeepView = true; return(temporary.View); } }
private void UpdateSsaaFxaaBuffer() { if (!UseSsaa || !UseFxaa) { DisposeHelper.Dispose(ref _bufferFSsaaFxaa); } else if (_bufferFSsaaFxaa == null) { _bufferFSsaaFxaa = TargetResourceTexture.Create(Format.R16G16B16A16_Float); ResizeBuffers(); } }
private void InitializeBuffers() { _shadowBuffer = TargetResourceDepthTexture.Create(); _bufferFSumm = TargetResourceTexture.Create(Format.R32G32B32A32_Float); _bufferF1 = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _bufferF2 = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _bufferA = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _summBlendState = Device.CreateBlendState(new RenderTargetBlendDescription { BlendEnable = true, SourceBlend = BlendOption.One, DestinationBlend = BlendOption.One, BlendOperation = BlendOperation.Add, SourceBlendAlpha = BlendOption.One, DestinationBlendAlpha = BlendOption.One, BlendOperationAlpha = BlendOperation.Add, RenderTargetWriteMask = ColorWriteMaskFlags.All, }); _bakedBlendState = Device.CreateBlendState(new RenderTargetBlendDescription { BlendEnable = true, SourceBlend = BlendOption.One, DestinationBlend = BlendOption.One, BlendOperation = BlendOperation.Maximum, SourceBlendAlpha = BlendOption.One, DestinationBlendAlpha = BlendOption.One, BlendOperationAlpha = BlendOperation.Maximum, RenderTargetWriteMask = ColorWriteMaskFlags.All, }); _effect = DeviceContextHolder.GetEffect <EffectSpecialShadow>(); _rasterizerStateFrontCull = RasterizerState.FromDescription(Device, new RasterizerStateDescription { CullMode = CullMode.Front, FillMode = FillMode.Solid, IsAntialiasedLineEnabled = false, IsDepthClipEnabled = true, DepthBias = (int)(100 * ShadowBiasCullFront), DepthBiasClamp = 0.0f, SlopeScaledDepthBias = ShadowBiasCullFront }); _rasterizerStateBackCull = RasterizerState.FromDescription(Device, new RasterizerStateDescription { CullMode = CullMode.Back, FillMode = FillMode.Solid, IsAntialiasedLineEnabled = false, IsDepthClipEnabled = true, DepthBias = (int)(100 * ShadowBiasCullBack), DepthBiasClamp = 0.0f, SlopeScaledDepthBias = ShadowBiasCullBack }); }
public static byte[] ToPng(DeviceContextHolder holder, byte[] bytes, bool ignoreAlpha, Size?downsize, out Format format) { Viewport[] viewports = null; try { using (var stream = new System.IO.MemoryStream()) using (var effect = new EffectPpBasic()) using (var output = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm)) using (var resource = ShaderResourceView.FromMemory(holder.Device, bytes)) { var texture = (Texture2D)resource.Resource; var loaded = texture.Description; var width = downsize?.Width ?? loaded.Width; var height = downsize?.Height ?? loaded.Height; effect.Initialize(holder.Device); format = loaded.Format; output.Resize(holder, width, height, null); holder.DeviceContext.ClearRenderTargetView(output.TargetView, Color.Transparent); holder.DeviceContext.OutputMerger.SetTargets(output.TargetView); viewports = holder.DeviceContext.Rasterizer.GetViewports(); holder.DeviceContext.Rasterizer.SetViewports(new Viewport(0, 0, width, height, 0f, 1f)); holder.DeviceContext.OutputMerger.BlendState = null; holder.QuadBuffers.Prepare(holder.DeviceContext, effect.LayoutPT); effect.FxInputMap.SetResource(resource); holder.PrepareQuad(effect.LayoutPT); if (ignoreAlpha) { effect.TechCopyNoAlpha.DrawAllPasses(holder.DeviceContext, 6); } else { effect.TechCopy.DrawAllPasses(holder.DeviceContext, 6); } Texture2D.ToStream(holder.DeviceContext, output.Texture, ImageFileFormat.Png, stream); stream.Position = 0; return(stream.GetBuffer()); } } finally { if (viewports != null) { holder.DeviceContext.Rasterizer.SetViewports(viewports); } } }
public override void OnInitialize(DeviceContextHolder holder) { base.OnInitialize(holder); // textures _depths = new[] { TargetResourceTexture.Create(Format.R16_Float), TargetResourceTexture.Create(Format.R16_Float), TargetResourceTexture.Create(Format.R16_Float), TargetResourceTexture.Create(Format.R16_Float), }; _pingPong = new[] { TargetResourceTexture.Create(Format.R8G8_UNorm), TargetResourceTexture.Create(Format.R8G8_UNorm), }; _finalResults = TargetResourceTextureArray.Create(Format.R8G8_UNorm, 4); // effect _effect = holder.GetEffect <EffectPpAssao>(); _effect.FxNoiseMap.SetResource(holder.GetRandomTexture(4, 4)); var samplesKernel = new Vector4[EffectPpSsao.SampleCount]; for (var i = 0; i < samplesKernel.Length; i++) { samplesKernel[i].X = MathUtils.Random(-1f, 1f); samplesKernel[i].Y = MathUtils.Random(-1f, 1f); //samplesKernel[i].Y = MathUtils.Random(0f, 1f); samplesKernel[i].Normalize(); //samplesKernel[i] *= 0.01f; //var scale = (float)i / samplesKernel.Length; //scale = MathUtils.Lerp(0.1f, 1f, scale * scale); //samplesKernel[i] *= scale; } // _effect.FxSampleDirections.Set(samplesKernel); _dither = holder.CreateTexture(4, 4, (x, y) => { var angle = (float)(2f * Math.PI * MathUtils.Random()); var r = MathF.Cos(angle); var g = -MathF.Sin(angle); var b = (float)MathUtils.Random() * 0.01f; return(new Color4(r, g, b)); }); _effect.FxDitherMap.SetResource(_dither); }
protected override void InitializeInner() { _effect = DeviceContextHolder.GetEffect <EffectSpecialTrackOutline>(); _maps = _mapFilenames.Select((x, i) => { var data = new MapViewData(DeviceContextHolder, x, UseAiLanes); if (i == 0) { Scale *= (data.MapSize.X / data.MapSize.Y).Clamp(1f, 2f); } return(data); }).ToArray(); if (LoadPreview) { if (File.Exists(_previewFilename)) { using (var preview = Texture2D.FromFile(Device, _previewFilename)) { _previewSize = new Vector2(preview.Description.Width, preview.Description.Height); _previewView = new ShaderResourceView(Device, preview); } } else { AcToolsLogging.Write("Not found: " + _previewFilename); } } _f0Buffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _f1Buffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _fBlendBuffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _fSummBuffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _a0Buffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _a1Buffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _aSummBuffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _combineBlendState = Device.CreateBlendState(new RenderTargetBlendDescription { BlendEnable = true, SourceBlend = BlendOption.SourceAlpha, DestinationBlend = BlendOption.InverseSourceAlpha, BlendOperation = BlendOperation.Add, SourceBlendAlpha = BlendOption.One, DestinationBlendAlpha = BlendOption.One, BlendOperationAlpha = BlendOperation.Maximum, RenderTargetWriteMask = ColorWriteMaskFlags.All }); }
private void PrepareOutlineBuffer() { if (_outlineBuffer != null) { return; } _outlineBuffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _outlineDepthBuffer = TargetResourceDepthTexture.Create(); if (!InitiallyResized) { return; } _outlineBuffer.Resize(DeviceContextHolder, Width, Height, null); _outlineDepthBuffer.Resize(DeviceContextHolder, Width, Height, null); }
private void InitializeBuffers() { _shadowBuffer = TargetResourceDepthTexture.Create(); _summBuffer = TargetResourceTexture.Create(Format.R32_Float); _tempBuffer = TargetResourceTexture.Create(Format.R32_Float); _blendState = Device.CreateBlendState(new RenderTargetBlendDescription { BlendEnable = true, SourceBlend = BlendOption.One, DestinationBlend = BlendOption.One, BlendOperation = BlendOperation.Add, SourceBlendAlpha = BlendOption.SourceAlpha, DestinationBlendAlpha = BlendOption.InverseSourceAlpha, BlendOperationAlpha = BlendOperation.Add, RenderTargetWriteMask = ColorWriteMaskFlags.All, }); _effect = DeviceContextHolder.GetEffect <EffectSpecialShadow>(); }
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); }
protected override void InitializeInner() { _deferredLighting = DeviceContextHolder.GetEffect <EffectDeferredLight>(); _deferredResult = DeviceContextHolder.GetEffect <EffectDeferredResult>(); _ppBasic = DeviceContextHolder.GetEffect <EffectPpBasic>(); _gDepthBuffer = TargetResourceDepthTexture.Create(); _gBufferBase = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _gBufferNormal = TargetResourceTexture.Create(Format.R32G32B32A32_Float); _gBufferMaps = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _temporaryDepthBuffer = TargetResourceDepthTexture.Create(); _temporaryBuffer0 = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _temporaryBuffer1 = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _temporaryBuffer2 = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _temporaryBuffer3 = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _outputBuffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); _reflectionCubemap = new ReflectionCubemap(1024); _reflectionCubemap.Initialize(DeviceContextHolder); _sunShadows = new ShadowsDirectional(2048); _sunShadows.Initialize(DeviceContextHolder); }
public virtual void Shot(double multiplier, double downscale, Stream outputStream, bool lossless) { var resolutionMultiplier = ResolutionMultiplier; var format = lossless ? ImageFileFormat.Png : ImageFileFormat.Jpg; ResolutionMultiplier = multiplier; if (Equals(downscale, 1d) && !UseMsaa) { // Simplest case: existing buffer will do just great, so let’s use it Draw(); Texture2D.ToStream(DeviceContext, _renderBuffer, format, outputStream); } else { // More complicated situation: we need to temporary replace existing _renderBuffer // with a custom one // Preparing temporary replacement for _renderBuffer… if (_shotRenderBuffer == null) { // Let’s keep all those buffers in memory between shots to make series shooting faster _shotRenderBuffer = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); } _shotRenderBuffer.Resize(DeviceContextHolder, Width, Height, SampleDescription); // If we won’t call Resize() here, it will be called in Draw(), and then swap chain will // be recreated in a wrong time if (_resized) { Resize(); _resized = false; } // Destroying current swap chain if needed var swapChainMode = _swapChain != null; if (swapChainMode) { DisposeHelper.Dispose(ref _swapChain); } // Replacing _renderBuffer… var renderView = _renderView; _renderView = _shotRenderBuffer.TargetView; // Calculating output width and height and, if needed, preparing downscaled buffer… var outputWidth = (Width * downscale).RoundToInt(); var outputHeight = (Height * downscale).RoundToInt(); if (!Equals(downscale, 1d)) { if (_shotDownsampleTexture == null) { _shotDownsampleTexture = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); } _shotDownsampleTexture.Resize(DeviceContextHolder, outputWidth, outputHeight, null); } // Ready to draw! Draw(); // For MSAA, we need to copy the result into a texture without MSAA enabled to save it later TargetResourceTexture result; if (UseMsaa) { if (_shotMsaaTemporaryTexture == null) { _shotMsaaTemporaryTexture = TargetResourceTexture.Create(Format.R8G8B8A8_UNorm); } _shotMsaaTemporaryTexture.Resize(DeviceContextHolder, Width, Height, null); DeviceContextHolder.GetHelper <CopyHelper>() .Draw(DeviceContextHolder, _shotRenderBuffer.View, _shotMsaaTemporaryTexture.TargetView); result = _shotMsaaTemporaryTexture; } else { result = _shotRenderBuffer; } if (Equals(downscale, 1d)) { Texture2D.ToStream(DeviceContext, result.Texture, format, outputStream); } else { DeviceContextHolder.GetHelper <DownsampleHelper>() .Draw(DeviceContextHolder, result, _shotDownsampleTexture, false); Texture2D.ToStream(DeviceContext, _shotDownsampleTexture.Texture, format, outputStream); } // Restoring old stuff _renderView = renderView; if (swapChainMode) { RecreateSwapChain(); } } ResolutionMultiplier = resolutionMultiplier; }
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 override void InitializeInner() { _bufferF = TargetResourceTexture.Create(Format.R16G16B16A16_Float); _bufferA = TargetResourceTexture.Create(Format.R16G16B16A16_Float); UseBloom = true; }
public DarkDof() { BufferScene = TargetResourceTexture.Create(Format.R16G16B16A16_Float); BufferDownsampleColor = TargetResourceTexture.Create(Format.R16G16B16A16_Float); BufferScatterBokeh = TargetResourceTexture.Create(Format.R16G16B16A16_Float); }
public DarkSslr() { BufferScene = TargetResourceTexture.Create(Format.R16G16B16A16_Float); BufferResult = TargetResourceTexture.Create(Format.R16G16B16A16_Float); BufferBaseReflection = TargetResourceTexture.Create(Format.R16G16B16A16_Float); }