public void Evaluate(int SpreadMax)
        {
            if (this.FInPreset.IsChanged ||
                this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.PluginIO.IsConnected)
                    {
                        rs = this.FInState[i];
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    this.AssignPreset(this.FInPreset[i].Name, rs);

                    this.FOutState[i] = rs;
                }
            }
        }
Пример #2
0
        public void Evaluate(int SpreadMax)
        {
            if (this.enabled.IsChanged ||
                this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    BlendStateDescription bs = rs.Blend;
                    bs.AlphaToCoverageEnable = this.enabled[i];
                    rs.Blend = bs;

                    this.FOutState[i] = rs;
                }
            }
        }
Пример #3
0
        public void Evaluate(int SpreadMax)
        {
            if (this.enabled.IsChanged ||
                this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    RasterizerStateDescription bs = rs.Rasterizer;
                    bs.IsDepthClipEnabled = this.enabled[i];
                    rs.Rasterizer         = bs;

                    this.FOutState[i] = rs;
                }
            }
        }
Пример #4
0
        public void Render(DX11RenderContext context)
        {
            if (this.lasthandle != this.Handle)
            {
                if (this.swapchain != null)
                {
                    if (this.swapchain.Contains(context))
                    {
                        this.swapchain.Dispose(context);
                    }
                }
                this.lasthandle = this.Handle;
            }

            if (!this.swapchain.Contains(context))
            {
                this.swapchain[context] = new DX11SwapChain(context, this.Handle,
                                                            SlimDX.DXGI.Format.R8G8B8A8_UNorm, new SampleDescription(1, 0), 60, 1);
            }

            if (this.resized)
            {
                this.swapchain[context].Resize();
            }

            if (this.FEnabled[0])
            {
                context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV, new SlimDX.Color4(0, 0, 0, 0));
            }

            if (this.FIn.PluginIO.IsConnected && this.FEnabled[0])
            {
                int id = this.FIndex[0];
                if (this.FIn[id].Contains(context))
                {
                    context.RenderTargetStack.Push(this.swapchain[context]);
                    var rs = new DX11RenderState();

                    if (FAlpha[0])
                    {
                        rs.Blend = DX11BlendStates.Instance.GetState("Blend");
                        context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV, FInBgColor[0].Color);
                    }
                    context.RenderStateStack.Push(rs);
                    context.CleanShaderStages();

                    context.Primitives.FullTriVS.GetVariableBySemantic("TEXTURE").AsResource().SetResource(this.FIn[id][context].SRV);
                    context.Primitives.FullScreenTriangle.Bind(null);
                    context.Primitives.ApplyFullTri();
                    context.Primitives.FullScreenTriangle.Draw();

                    context.RenderStateStack.Pop();
                    context.RenderTargetStack.Pop();
                    context.CleanUpPS();
                }
            }
        }
Пример #5
0
        public void Begin(SlimDX.Matrix vp, DX11RenderState shapes, DX11RenderState aabb)
        {
            this.shapesRenderState = shapes != null ? shapes : this.defaultRenderState;
            this.aabbRenderState   = aabb != null ? aabb : this.shapesRenderState;

            this.solidColorShader.ApplyCamera(vp);
            context.RenderStateStack.Push(shapesRenderState);
            context.CleanShaderStages();
        }
Пример #6
0
        public void Evaluate(int SpreadMax)
        {
            if (this.red.IsChanged ||
                this.green.IsChanged ||
                this.blue.IsChanged ||
                this.alpha.IsChanged ||
                this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    ColorWriteMaskFlags flag = ColorWriteMaskFlags.None;
                    if (red[i])
                    {
                        flag |= ColorWriteMaskFlags.Red;
                    }
                    if (green[i])
                    {
                        flag |= ColorWriteMaskFlags.Green;
                    }
                    if (blue[i])
                    {
                        flag |= ColorWriteMaskFlags.Blue;
                    }
                    if (alpha[i])
                    {
                        flag |= ColorWriteMaskFlags.Alpha;
                    }

                    BlendStateDescription bs = rs.Blend;
                    bs.RenderTargets[0].RenderTargetWriteMask = flag;


                    rs.Blend = bs;

                    this.FOutState[i] = rs;
                }
            }
        }
        public void Evaluate(int SpreadMax)
        {
            if (this.FInFillMode.IsChanged ||
                this.FInCullMode.IsChanged ||
                this.FInDepthBias.IsChanged ||
                this.FInDepthBiasClamp.IsChanged ||
                this.FInDepthClipEnable.IsChanged ||
                this.FInFrontCCW.IsChanged ||
                this.FInLineAAEnable.IsChanged ||
                this.FInEnableMS.IsChanged ||
                this.FInEnableScissor.IsChanged ||
                this.FInSlopeScaleDB.IsChanged ||
                this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    RasterizerStateDescription rsd = rs.Rasterizer;
                    rsd.FillMode                 = this.FInFillMode[i];
                    rsd.CullMode                 = this.FInCullMode[i];
                    rsd.DepthBias                = this.FInDepthBias[i];
                    rsd.DepthBiasClamp           = this.FInDepthBiasClamp[i];
                    rsd.IsDepthClipEnabled       = this.FInDepthClipEnable[i];
                    rsd.IsAntialiasedLineEnabled = this.FInLineAAEnable[i];
                    rsd.IsFrontCounterclockwise  = this.FInFrontCCW[i];
                    rsd.IsMultisampleEnabled     = this.FInEnableMS[i];
                    rsd.IsScissorEnabled         = this.FInEnableScissor[i];
                    rsd.SlopeScaledDepthBias     = this.FInSlopeScaleDB[i];

                    rs.Rasterizer = rsd;

                    this.FOutState[i] = rs;
                }
            }
        }
        public void Evaluate(int SpreadMax)
        {
            if (this.FInAlphaCover.IsChanged ||
                this.FInEnable.IsChanged ||
                this.FInBlendOp.IsChanged ||
                this.FInBlendOpAlpha.IsChanged ||
                this.FInWriteMask.IsChanged ||
                this.FInSrc.IsChanged ||
                this.FInSrcAlpha.IsChanged ||
                this.FInDest.IsChanged ||
                this.FInDestAlpha.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                DX11RenderState rs;
                if (this.FInState.PluginIO.IsConnected)
                {
                    rs = this.FInState[0].Clone();
                }
                else
                {
                    rs = new DX11RenderState();
                }

                BlendStateDescription bs = rs.Blend;

                for (int i = 0; i < 8; i++)
                {
                    bs.IndependentBlendEnable                 = true;
                    bs.AlphaToCoverageEnable                  = this.FInAlphaCover[0];
                    bs.RenderTargets[i].BlendEnable           = this.FInEnable[i];
                    bs.RenderTargets[i].BlendOperation        = this.FInBlendOp[i];
                    bs.RenderTargets[i].BlendOperationAlpha   = this.FInBlendOpAlpha[i];
                    bs.RenderTargets[i].RenderTargetWriteMask = this.FInWriteMask[i];
                    bs.RenderTargets[i].SourceBlend           = this.FInSrc[i];
                    bs.RenderTargets[i].SourceBlendAlpha      = this.FInSrcAlpha[i];
                    bs.RenderTargets[i].DestinationBlend      = this.FInDest[i];
                    bs.RenderTargets[i].DestinationBlendAlpha = this.FInDestAlpha[i];
                }

                rs.Blend = bs;

                this.FOutState[0] = rs;
            }
        }
Пример #9
0
        public void Evaluate(int SpreadMax)
        {
            if (this.enabled.IsChanged || this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    rs.Rasterizer.IsScissorEnabled = this.enabled[i];
                    this.FOutState[i] = rs;
                }
            }
        }
        public void Evaluate(int SpreadMax)
        {
            if (this.FInState.IsChanged || this.FInReference.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    rs.DepthStencilReference = this.FInReference[i];
                    this.FOutState[i]        = rs;
                }
            }
        }
Пример #11
0
        public void Evaluate(int SpreadMax)
        {
            if (this.FMode.IsChanged || this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    rs.Rasterizer     = DX11RasterizerStates.GetState(this.FMode[i]);
                    this.FOutState[i] = rs;
                }
            }
        }
Пример #12
0
        public void Evaluate(int SpreadMax)
        {
            if (this.FInFactor.IsChanged || this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.PluginIO.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    rs.BlendFactor    = this.FInFactor[i];
                    this.FOutState[i] = rs;
                }
            }
        }
Пример #13
0
 protected override DX11RenderState AssignPreset(string key, DX11RenderState statein)
 {
     statein.DepthStencil = DX11DepthStencilStates.Instance.GetState(key);
     return(statein);
 }
Пример #14
0
        public void Evaluate(int SpreadMax)
        {
            if (this.mode.IsChanged || this.FInState.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    BlendStateDescription        bs     = rs.Blend;
                    RenderTargetBlendDescription target = bs.RenderTargets[0];

                    //Note: to optimize a little, we do the following :
                    //In any case, if blend is disabled, we enable it as otherwise modes with do nothing
                    //Only exception is replace, if blend is disabled we leave as it is

                    switch (mode[i])
                    {
                    case AlphaOperationMode.Keep:
                        target.BlendEnable           = true;
                        target.BlendOperation        = BlendOperation.Add;
                        target.DestinationBlendAlpha = BlendOption.One;
                        target.SourceBlendAlpha      = BlendOption.Zero;
                        break;

                    case AlphaOperationMode.Replace:
                        if (target.BlendEnable)
                        {
                            target.BlendOperation        = BlendOperation.Add;
                            target.DestinationBlendAlpha = BlendOption.Zero;
                            target.SourceBlendAlpha      = BlendOption.One;
                        }
                        break;

                    case AlphaOperationMode.Multiply:
                        target.BlendEnable           = true;
                        target.BlendOperation        = BlendOperation.Add;
                        target.DestinationBlendAlpha = BlendOption.SourceAlpha;
                        target.SourceBlendAlpha      = BlendOption.Zero;
                        break;

                    case AlphaOperationMode.Interpolate:
                        target.BlendEnable           = true;
                        target.BlendOperation        = BlendOperation.Add;
                        target.DestinationBlendAlpha = BlendOption.InverseSourceAlpha;
                        target.SourceBlendAlpha      = BlendOption.SourceAlpha;
                        break;
                    }

                    bs.RenderTargets[0] = target;
                    rs.Blend            = bs;

                    this.FOutState[i] = rs;
                }
            }
        }
Пример #15
0
        public void Render(DX11RenderContext context)
        {
            if (this.lasthandle != this.Handle)
            {
                if (this.swapchain != null)
                {
                    if (this.swapchain.Contains(context))
                    {
                        this.swapchain.Dispose(context);
                    }
                }
                this.lasthandle = this.Handle;
            }

            if (!this.swapchain.Contains(context))
            {
                this.swapchain[context] = new DX11SwapChain(context, this.Handle,
                                                            SlimDX.DXGI.Format.R8G8B8A8_UNorm, new SampleDescription(1, 0), 60, 1);
            }

            if (this.resized)
            {
                this.swapchain[context].Resize();
            }

            if (this.FEnabled[0])
            {
                context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV, new SlimDX.Color4(0, 0, 0, 0));
            }

            if (this.FIn.IsConnected && this.spreadMax > 0 && this.FEnabled[0])
            {
                int id = this.FIndex[0];
                if (this.FIn[id].Contains(context) && this.FIn[id][context] != null)
                {
                    context.RenderTargetStack.Push(this.swapchain[context]);
                    var rs = new DX11RenderState();

                    if (FAlpha[0])
                    {
                        rs.Blend = DX11BlendStates.Instance.GetState("Blend");
                        context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV, FInBgColor[0].Color);
                    }
                    context.RenderStateStack.Push(rs);
                    context.CleanShaderStages();

                    context.Primitives.FullTriVS.GetVariableBySemantic("TEXTURE").AsResource().SetResource(this.FIn[id][context].SRV);

                    EffectSamplerVariable samplervariable = context.Primitives.FullTriVS.GetVariableByName("linSamp").AsSampler();
                    SamplerState          state           = null;
                    if (this.FInSamplerState.IsConnected)
                    {
                        state = SamplerState.FromDescription(context.Device, this.FInSamplerState[0]);
                        samplervariable.SetSamplerState(0, state);
                    }
                    else
                    {
                        samplervariable.UndoSetSamplerState(0);
                    }

                    context.Primitives.FullScreenTriangle.Bind(null);
                    context.Primitives.ApplyFullTri();
                    context.Primitives.FullScreenTriangle.Draw();

                    context.RenderStateStack.Pop();
                    context.RenderTargetStack.Pop();
                    context.CleanUpPS();
                    samplervariable.UndoSetSamplerState(0);  //undo as can be used in other places

                    if (state != null)
                    {
                        state.Dispose();
                    }
                }
            }
        }
        public void Evaluate(int SpreadMax)
        {
            if (this.FInComparison.IsChanged ||
                this.FInDepthWriteMask.IsChanged ||
                this.FInEnableDepth.IsChanged ||
                this.FInEnableStencil.IsChanged ||
                this.FInState.IsChanged ||
                this.FInBFComp.IsChanged ||
                this.FInBFDFOp.IsChanged ||
                this.FInBFFOp.IsChanged ||
                this.FInBFPOp.IsChanged ||
                this.FInFFComp.IsChanged ||
                this.FInFFDFOp.IsChanged ||
                this.FInFFFOp.IsChanged ||
                this.FInFFPOp.IsChanged ||
                this.FInStencilReadMask.IsChanged ||
                this.FInStencilWriteMask.IsChanged)
            {
                this.FOutState.SliceCount = SpreadMax;

                for (int i = 0; i < SpreadMax; i++)
                {
                    DX11RenderState rs;
                    if (this.FInState.PluginIO.IsConnected)
                    {
                        rs = this.FInState[i];
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    DepthStencilStateDescription ds = rs.DepthStencil;
                    ds.DepthComparison  = this.FInComparison[i];
                    ds.DepthWriteMask   = this.FInDepthWriteMask[i];
                    ds.IsDepthEnabled   = this.FInEnableDepth[i];
                    ds.IsStencilEnabled = this.FInEnableStencil[i];
                    int srm = Math.Min(255, Math.Max(this.FInStencilReadMask[i], 0));
                    int swm = Math.Min(255, Math.Max(this.FInStencilWriteMask[i], 0));
                    ds.StencilReadMask  = Convert.ToByte(srm);
                    ds.StencilWriteMask = Convert.ToByte(swm);

                    DepthStencilOperationDescription dbf = new DepthStencilOperationDescription();
                    dbf.Comparison         = this.FInBFComp[i];
                    dbf.DepthFailOperation = this.FInBFDFOp[i];
                    dbf.FailOperation      = this.FInBFFOp[i];
                    dbf.PassOperation      = this.FInBFPOp[i];

                    ds.BackFace = dbf;


                    DepthStencilOperationDescription dff = new DepthStencilOperationDescription();
                    dff.Comparison         = this.FInFFComp[i];
                    dff.DepthFailOperation = this.FInFFDFOp[i];
                    dff.FailOperation      = this.FInFFFOp[i];
                    dff.PassOperation      = this.FInFFPOp[i];

                    ds.FrontFace      = dff;
                    rs.DepthStencil   = ds;
                    this.FOutState[i] = rs;
                }
            }
        }
Пример #17
0
        public void Update(DX11RenderContext context)
        {
            Device        device = context.Device;
            DeviceContext ctx    = context.CurrentDeviceContext;

            if (!this.deviceshaderdata.Contains(context))
            {
                this.deviceshaderdata[context] = new DX11ShaderData(context, this.FShader);
            }
            if (!this.shaderVariableCache.Contains(context))
            {
                this.shaderVariableCache[context] = new DX11ShaderVariableCache(context, this.deviceshaderdata[context].ShaderInstance, this.varmanager);
            }
            if (!this.imageShaderInfo.Contains(context))
            {
                this.imageShaderInfo[context] = new ImageShaderInfo(this.deviceshaderdata[context].ShaderInstance);
            }

            DX11ShaderData  shaderdata = this.deviceshaderdata[context];
            ImageShaderInfo shaderInfo = this.imageShaderInfo[context];

            context.RenderStateStack.Push(new DX11RenderState());

            this.OnBeginQuery(context);


            //Clear shader stages
            shaderdata.ResetShaderStages(ctx);
            context.Primitives.ApplyFullTriVS();

            for (int i = 0; i < this.previousFrameResults.SliceCount; i++)
            {
                if (this.FInEnabled[i] || this.FInPreserveOnDisable[i] == false)
                {
                    this.previousFrameResults[i]?.UnLock();
                    this.previousFrameResults[i] = null;
                }
            }


            int wi, he;
            DX11ResourcePoolEntry <DX11RenderTarget2D> preservedtarget = null;

            renderSettings.CustomSemantics.Clear();
            renderSettings.ResourceSemantics.Clear();

            if (this.FInSemantics.IsConnected)
            {
                renderSettings.CustomSemantics.AddRange(this.FInSemantics.ToArray());
            }
            if (this.FInResSemantics.IsConnected)
            {
                renderSettings.ResourceSemantics.AddRange(this.FInResSemantics.ToArray());
            }

            for (int textureIndex = 0; textureIndex < this.spmax; textureIndex++)
            {
                int passcounter = 0;

                if (this.FInEnabled[textureIndex])
                {
                    List <DX11ResourcePoolEntry <DX11RenderTarget2D> > locktargets = new List <DX11ResourcePoolEntry <DX11RenderTarget2D> >();

                    #region Manage size
                    DX11Texture2D initial;
                    if (this.FIn.IsConnected)
                    {
                        if (this.FInUseDefaultSize[0])
                        {
                            if (this.FIn[textureIndex].Contains(context) && this.FIn[textureIndex][context] != null)
                            {
                                initial = this.FIn[textureIndex][context];
                            }
                            else
                            {
                                initial = context.DefaultTextures.WhiteTexture;
                            }
                            wi = (int)this.FInSize[0].X;
                            he = (int)this.FInSize[0].Y;
                        }
                        else
                        {
                            initial = this.FIn[textureIndex].Contains(context) ? this.FIn[textureIndex][context] : null;
                            if (initial != null)
                            {
                                wi = initial.Width;
                                he = initial.Height;
                            }
                            else
                            {
                                initial = context.DefaultTextures.WhiteTexture;
                                wi      = (int)this.FInSize[textureIndex].X;
                                he      = (int)this.FInSize[textureIndex].Y;
                            }
                        }
                    }
                    else
                    {
                        initial = context.DefaultTextures.WhiteTexture;
                        wi      = (int)this.FInSize[textureIndex].X;
                        he      = (int)this.FInSize[textureIndex].Y;
                    }
                    #endregion

                    renderSettings.RenderWidth  = wi;
                    renderSettings.RenderHeight = he;


                    this.varmanager.SetGlobalSettings(shaderdata.ShaderInstance, renderSettings);
                    var variableCache = this.shaderVariableCache[context];
                    variableCache.ApplyGlobals(renderSettings);


                    DX11ResourcePoolEntry <DX11RenderTarget2D> lasttmp = null;

                    List <DX11Texture2D> rtlist = new List <DX11Texture2D>();

                    //Go trough all passes
                    int tid = this.FInTechnique[textureIndex].Index;
                    ImageShaderTechniqueInfo techniqueInfo = shaderInfo.GetTechniqueInfo(tid);

                    //Now we need to add optional extra pass in case we want mip chain (only in case it's not needed, if texture has mips we just ignore)
                    if (techniqueInfo.WantMips)
                    {
                        //Single level and bigger than 1 should get a mip generation pass
                        if (initial.Width > 1 && initial.Height > 1 && initial.Resource.Description.MipLevels == 1)
                        {
                            //Texture might now be an allowed render target format, so we at least need to check that, and default to rgba8 unorm
                            //also check for auto mip map gen
                            var mipTargetFmt = initial.Format;
                            if (!context.IsSupported(FormatSupport.RenderTarget, mipTargetFmt) ||
                                !context.IsSupported(FormatSupport.MipMapAutoGeneration, mipTargetFmt) ||
                                !context.IsSupported(FormatSupport.UnorderedAccessView, mipTargetFmt))
                            {
                                mipTargetFmt = Format.R8G8B8A8_UNorm;
                            }



                            DX11ResourcePoolEntry <DX11RenderTarget2D> mipTarget = context.ResourcePool.LockRenderTarget(initial.Width, initial.Height, mipTargetFmt, new SampleDescription(1, 0), true, 0);
                            locktargets.Add(mipTarget);

                            context.RenderTargetStack.Push(mipTarget.Element);

                            context.BasicEffects.PointSamplerPixelPass.Apply(initial.SRV);

                            context.CurrentDeviceContext.Draw(3, 0);

                            context.RenderTargetStack.Pop();

                            context.CurrentDeviceContext.GenerateMips(mipTarget.Element.SRV);

                            //Replace initial by our new texture
                            initial = mipTarget.Element;
                        }
                    }

                    //Bind Initial (once only is ok) and mark for previous usage too
                    DX11Texture2D lastrt = initial;
                    shaderInfo.ApplyInitial(initial.SRV);

                    for (int passIndex = 0; passIndex < techniqueInfo.PassCount; passIndex++)
                    {
                        ImageShaderPassInfo passInfo = techniqueInfo.GetPassInfo(passIndex);
                        bool isLastPass = passIndex == techniqueInfo.PassCount - 1;


                        Format fmt = initial.Format;
                        if (passInfo.CustomFormat)
                        {
                            fmt = passInfo.Format;
                        }
                        bool mips = passInfo.Mips || (isLastPass && FInMipLastPass[textureIndex]);

                        int w, h;
                        if (passIndex == 0)
                        {
                            h = he;
                            w = wi;
                        }
                        else
                        {
                            h = passInfo.Reference == ImageShaderPassInfo.eImageScaleReference.Initial ? he : lastrt.Height;
                            w = passInfo.Reference == ImageShaderPassInfo.eImageScaleReference.Initial ? wi : lastrt.Width;
                        }

                        if (passInfo.DoScale)
                        {
                            if (passInfo.Absolute)
                            {
                                w = Convert.ToInt32(passInfo.ScaleVector.X);
                                h = Convert.ToInt32(passInfo.ScaleVector.Y);
                            }
                            else
                            {
                                w = Convert.ToInt32((float)w * passInfo.ScaleVector.X);
                                h = Convert.ToInt32((float)h * passInfo.ScaleVector.Y);
                            }

                            w = Math.Max(w, 1);
                            h = Math.Max(h, 1);
                        }

                        //Check format support for render target, and default to rgb8 if not
                        if (!context.IsSupported(FormatSupport.RenderTarget, fmt))
                        {
                            fmt = Format.R8G8B8A8_UNorm;
                        }

                        //To avoid uav issue
                        if (fmt == Format.B8G8R8A8_UNorm)
                        {
                            fmt = Format.R8G8B8A8_UNorm;
                        }

                        DX11ResourcePoolEntry <DX11RenderTarget2D> elem;
                        if (preservedtarget != null)
                        {
                            elem = preservedtarget;
                        }
                        else
                        {
                            elem = context.ResourcePool.LockRenderTarget(w, h, fmt, new SampleDescription(1, 0), mips, 0);
                            locktargets.Add(elem);
                        }
                        DX11RenderTarget2D rt = elem.Element;


                        if (this.FDepthIn.IsConnected && passInfo.UseDepth)
                        {
                            context.RenderTargetStack.Push(this.FDepthIn[0][context], true, elem.Element);
                        }
                        else
                        {
                            context.RenderTargetStack.Push(elem.Element);
                        }

                        if (passInfo.Clear)
                        {
                            elem.Element.Clear(new Color4(0, 0, 0, 0));
                        }

                        #region Check for depth/blend preset
                        bool validdepth = false;
                        bool validblend = false;

                        DepthStencilStateDescription ds = new DepthStencilStateDescription();
                        BlendStateDescription        bs = new BlendStateDescription();

                        if (passInfo.DepthPreset != "")
                        {
                            try
                            {
                                ds         = DX11DepthStencilStates.GetState(passInfo.DepthPreset);
                                validdepth = true;
                            }
                            catch
                            {
                            }
                        }

                        if (passInfo.BlendPreset != "")
                        {
                            try
                            {
                                bs         = DX11BlendStates.GetState(passInfo.BlendPreset);
                                validblend = true;
                            }
                            catch
                            {
                            }
                        }
                        #endregion

                        if (validdepth || validblend)
                        {
                            DX11RenderState state = new DX11RenderState();
                            if (validdepth)
                            {
                                state.DepthStencil = ds;
                            }
                            if (validblend)
                            {
                                state.Blend = bs;
                            }
                            context.RenderStateStack.Push(state);
                        }

                        renderSettings.RenderWidth  = w;
                        renderSettings.RenderHeight = h;
                        renderSettings.BackBuffer   = elem.Element;

                        //Apply settings (we do both here, as texture size semantic might ahve
                        variableCache.ApplyGlobals(renderSettings);
                        variableCache.ApplySlice(objectSettings, textureIndex);
                        //Bind last render target

                        shaderInfo.ApplyPrevious(lastrt.SRV);

                        this.BindPassIndexSemantic(shaderdata.ShaderInstance.Effect, passIndex);

                        if (this.FDepthIn.IsConnected)
                        {
                            if (this.FDepthIn[0].Contains(context))
                            {
                                shaderInfo.ApplyDepth(this.FDepthIn[0][context].SRV);
                            }
                        }

                        for (int list = 0; list < this.FinPrePostActions.SliceCount; list++)
                        {
                            if (this.FinPrePostActions[list] != null)
                            {
                                this.FinPrePostActions[list].OnBeginPass(context, passIndex);
                            }
                        }

                        //Apply pass and draw quad
                        passInfo.Apply(ctx);

                        if (passInfo.ComputeData.Enabled)
                        {
                            passInfo.ComputeData.Dispatch(context, w, h);
                            context.CleanUpCS();
                        }
                        else
                        {
                            ctx.ComputeShader.Set(null);
                            context.Primitives.FullScreenTriangle.Draw();
                            ctx.OutputMerger.SetTargets(this.nullrtvs);
                        }

                        //Generate mips if applicable
                        if (mips)
                        {
                            ctx.GenerateMips(rt.SRV);
                        }

                        if (!passInfo.KeepTarget)
                        {
                            rtlist.Add(rt);
                            lastrt          = rt;
                            lasttmp         = elem;
                            preservedtarget = null;
                            passcounter++;
                        }
                        else
                        {
                            preservedtarget = elem;
                        }


                        context.RenderTargetStack.Pop();

                        //Apply pass result semantic if applicable (after pop)
                        shaderInfo.ApplyPassResult(lasttmp.Element.SRV, passIndex);

                        if (validblend || validdepth)
                        {
                            context.RenderStateStack.Pop();
                        }

                        if (passInfo.HasState)
                        {
                            context.RenderStateStack.Apply();
                        }

                        for (int list = 0; list < this.FinPrePostActions.SliceCount; list++)
                        {
                            if (this.FinPrePostActions[list] != null)
                            {
                                this.FinPrePostActions[list].OnEndPass(context, passIndex);
                            }
                        }
                    }

                    //Set last render target
                    this.FOut[textureIndex][context] = lastrt;

                    //Unlock all resources
                    foreach (DX11ResourcePoolEntry <DX11RenderTarget2D> lt in locktargets)
                    {
                        lt.UnLock();
                    }

                    //Keep lock on last rt, since don't want it overidden
                    lasttmp.Lock();

                    this.previousFrameResults[textureIndex] = lasttmp;
                }
                else
                {
                    if (this.FInPreserveOnDisable[textureIndex])
                    {
                        //We kept it locked on top
                        this.FOut[textureIndex][context] = this.previousFrameResults[textureIndex] != null ? this.previousFrameResults[textureIndex].Element : null;
                    }
                    else
                    {
                        this.FOut[textureIndex][context] = this.FIn[textureIndex][context];
                    }
                }
            }

            context.RenderStateStack.Pop();

            this.OnEndQuery(context);
        }
Пример #18
0
 protected override DX11RenderState AssignPreset(string key, DX11RenderState statein)
 {
     statein.Blend = DX11BlendStates.Instance.GetState(key);
     return(statein);
 }
Пример #19
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            Device        device = context.Device;
            DeviceContext ctx    = context.CurrentDeviceContext;

            if (!this.deviceshaderdata.ContainsKey(context))
            {
                this.deviceshaderdata.Add(context, new DX11ShaderData(context));
                this.deviceshaderdata[context].SetEffect(this.FShader);
            }

            DX11ShaderData shaderdata = this.deviceshaderdata[context];

            if (this.shaderupdated)
            {
                shaderdata.SetEffect(this.FShader);
                this.shaderupdated = false;
            }

            context.RenderStateStack.Push(new DX11RenderState());

            this.OnBeginQuery(context);


            //Clear shader stages
            shaderdata.ResetShaderStages(ctx);
            context.Primitives.ApplyFullTriVS();

            foreach (DX11ResourcePoolEntry <DX11RenderTarget2D> rt in this.lastframetargets)
            {
                rt.UnLock();
            }
            this.lastframetargets.Clear();

            DX11ObjectRenderSettings or = new DX11ObjectRenderSettings();

            int  wi, he;
            bool preserve = false;
            DX11ResourcePoolEntry <DX11RenderTarget2D> preservedtarget = null;

            for (int i = 0; i < this.spmax; i++)
            {
                int passcounter = 0;

                if (this.FInEnabled[i])
                {
                    List <DX11ResourcePoolEntry <DX11RenderTarget2D> > locktargets = new List <DX11ResourcePoolEntry <DX11RenderTarget2D> >();


                    #region Manage size
                    DX11Texture2D initial;
                    if (this.FIn.PluginIO.IsConnected)
                    {
                        if (this.FInUseDefaultSize[0])
                        {
                            initial = context.DefaultTextures.WhiteTexture;
                            wi      = (int)this.FInSize[0].X;
                            he      = (int)this.FInSize[0].Y;
                        }
                        else
                        {
                            initial = this.FIn[i][context];
                            if (initial != null)
                            {
                                wi = initial.Width;
                                he = initial.Height;
                            }
                            else
                            {
                                initial = context.DefaultTextures.WhiteTexture;
                                wi      = (int)this.FInSize[0].X;
                                he      = (int)this.FInSize[0].Y;
                            }
                        }
                    }
                    else
                    {
                        initial = context.DefaultTextures.WhiteTexture;
                        wi      = (int)this.FInSize[0].X;
                        he      = (int)this.FInSize[0].Y;
                    }
                    #endregion

                    DX11RenderSettings r = new DX11RenderSettings();
                    r.RenderWidth  = wi;
                    r.RenderHeight = he;
                    if (this.FInSemantics.PluginIO.IsConnected)
                    {
                        r.CustomSemantics.AddRange(this.FInSemantics.ToArray());
                    }
                    if (this.FInResSemantics.PluginIO.IsConnected)
                    {
                        r.ResourceSemantics.AddRange(this.FInResSemantics.ToArray());
                    }

                    this.varmanager.SetGlobalSettings(shaderdata.ShaderInstance, r);

                    this.varmanager.ApplyGlobal(shaderdata.ShaderInstance);

                    DX11Texture2D lastrt = initial;
                    DX11ResourcePoolEntry <DX11RenderTarget2D> lasttmp = null;

                    List <DX11Texture2D> rtlist = new List <DX11Texture2D>();

                    //Bind Initial (once only is ok)
                    this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, "INITIAL", initial);

                    //Go trough all passes
                    EffectTechnique tech = shaderdata.ShaderInstance.Effect.GetTechniqueByIndex(tid);

                    for (int j = 0; j < tech.Description.PassCount; j++)
                    {
                        ImageShaderPass pi   = this.varmanager.passes[j];
                        EffectPass      pass = tech.GetPassByIndex(j);

                        for (int kiter = 0; kiter < pi.IterationCount; kiter++)
                        {
                            if (passcounter > 0)
                            {
                                for (int pid = 0; pid < passcounter; pid++)
                                {
                                    string pname = "PASSRESULT" + pid;
                                    this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, pname, rtlist[pid]);
                                }
                            }

                            Format fmt = initial.Format;
                            if (pi.CustomFormat)
                            {
                                fmt = pi.Format;
                            }
                            bool mips = pi.Mips;

                            int w, h;
                            if (j == 0)
                            {
                                h = he;
                                w = wi;
                            }
                            else
                            {
                                h = pi.Reference == ImageShaderPass.eImageScaleReference.Initial ? he : lastrt.Height;
                                w = pi.Reference == ImageShaderPass.eImageScaleReference.Initial ? wi : lastrt.Width;
                            }

                            if (pi.DoScale)
                            {
                                if (pi.Absolute)
                                {
                                    w = Convert.ToInt32(pi.ScaleVector.X);
                                    h = Convert.ToInt32(pi.ScaleVector.Y);
                                }
                                else
                                {
                                    w = Convert.ToInt32((float)w * pi.ScaleVector.X);
                                    h = Convert.ToInt32((float)h * pi.ScaleVector.Y);
                                }

                                w = Math.Max(w, 1);
                                h = Math.Max(h, 1);
                            }

                            //Check format support for render target, and default to rgb8 if not
                            if (!context.IsSupported(FormatSupport.RenderTarget, fmt))
                            {
                                fmt = Format.R8G8B8A8_UNorm;
                            }

                            //Since device is not capable of telling us BGR not supported
                            if (fmt == Format.B8G8R8A8_UNorm)
                            {
                                fmt = Format.R8G8B8A8_UNorm;
                            }

                            DX11ResourcePoolEntry <DX11RenderTarget2D> elem;
                            if (preservedtarget != null)
                            {
                                elem = preservedtarget;
                            }
                            else
                            {
                                elem = context.ResourcePool.LockRenderTarget(w, h, fmt, new SampleDescription(1, 0), mips, 0);
                                locktargets.Add(elem);
                            }
                            DX11RenderTarget2D rt = elem.Element;


                            if (this.FDepthIn.PluginIO.IsConnected && pi.UseDepth)
                            {
                                context.RenderTargetStack.Push(this.FDepthIn[0][context], true, elem.Element);
                            }
                            else
                            {
                                context.RenderTargetStack.Push(elem.Element);
                            }

                            if (pi.Clear)
                            {
                                elem.Element.Clear(new Color4(0, 0, 0, 0));
                            }

                            #region Check for depth/blend preset
                            bool validdepth = false;
                            bool validblend = false;

                            DepthStencilStateDescription ds = new DepthStencilStateDescription();
                            BlendStateDescription        bs = new BlendStateDescription();

                            if (pi.DepthPreset != "")
                            {
                                try
                                {
                                    ds         = DX11DepthStencilStates.Instance.GetState(pi.DepthPreset);
                                    validdepth = true;
                                }
                                catch
                                {
                                }
                            }

                            if (pi.BlendPreset != "")
                            {
                                try
                                {
                                    bs         = DX11BlendStates.Instance.GetState(pi.BlendPreset);
                                    validblend = true;
                                }
                                catch
                                {
                                }
                            }
                            #endregion

                            if (validdepth || validblend)
                            {
                                DX11RenderState state = new DX11RenderState();
                                if (validdepth)
                                {
                                    state.DepthStencil = ds;
                                }
                                if (validblend)
                                {
                                    state.Blend = bs;
                                }
                                context.RenderStateStack.Push(state);
                            }

                            r.RenderWidth  = w;
                            r.RenderHeight = h;
                            r.BackBuffer   = elem.Element;
                            this.varmanager.ApplyGlobal(shaderdata.ShaderInstance);

                            //Apply settings (note that textures swap is handled later)
                            this.varmanager.ApplyPerObject(context, shaderdata.ShaderInstance, or, i);

                            //Bind last render target
                            this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, "PREVIOUS", lastrt);

                            this.BindPassIndexSemantic(shaderdata.ShaderInstance.Effect, j);
                            this.BindPassIterIndexSemantic(shaderdata.ShaderInstance.Effect, kiter);

                            if (this.FDepthIn.PluginIO.IsConnected)
                            {
                                if (this.FDepthIn[0].Contains(context))
                                {
                                    this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, "DEPTHTEXTURE", this.FDepthIn[0][context]);
                                }
                            }

                            //Apply pass and draw quad
                            pass.Apply(ctx);

                            if (pi.ComputeData.Enabled)
                            {
                                pi.ComputeData.Dispatch(context, w, h);
                                context.CleanUpCS();
                            }
                            else
                            {
                                ctx.ComputeShader.Set(null);
                                context.Primitives.FullScreenTriangle.Draw();
                                ctx.OutputMerger.SetTargets(this.nullrtvs);
                            }

                            //Generate mips if applicable
                            if (pi.Mips)
                            {
                                ctx.GenerateMips(rt.SRV);
                            }

                            if (!pi.KeepTarget)
                            {
                                preserve = false;
                                rtlist.Add(rt);
                                lastrt          = rt;
                                lasttmp         = elem;
                                preservedtarget = null;
                                passcounter++;
                            }
                            else
                            {
                                preserve        = true;
                                preservedtarget = elem;
                            }


                            context.RenderTargetStack.Pop();

                            if (validblend || validdepth)
                            {
                                context.RenderStateStack.Pop();
                            }

                            if (pi.HasState)
                            {
                                context.RenderStateStack.Apply();
                            }
                        }
                    }

                    //Set last render target
                    this.FOut[i][context] = lastrt;

                    //Unlock all resources
                    foreach (DX11ResourcePoolEntry <DX11RenderTarget2D> lt in locktargets)
                    {
                        lt.UnLock();
                    }

                    //Keep lock on last rt, since don't want it overidden
                    lasttmp.Lock();

                    this.lastframetargets.Add(lasttmp);
                }
                else
                {
                    this.FOut[i][context] = this.FIn[i][context];
                }
            }

            context.RenderStateStack.Pop();

            this.OnEndQuery(context);

            //UnLock previous frame in applicable
            //if (previoustarget != null) { context.ResourcePool.Unlock(previoustarget); }
        }
 protected abstract DX11RenderState AssignPreset(string key, DX11RenderState statein);