public DX11RenderStateStack(DX11RenderContext context)
 {
     this.context = context;
     this.defaultstate = new DX11RenderState();
     stack = new Stack<DX11RenderState>();
     this.defaultstate.Apply(context);
 }
 public DX11RenderStateStack(DX11RenderContext context)
 {
     this.context      = context;
     this.defaultstate = new DX11RenderState();
     stack             = new Stack <DX11RenderState>();
     this.defaultstate.Apply(context);
 }
        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;
                }
            }
        }
Beispiel #4
0
 public DX11RenderState Clone()
 {
     DX11RenderState result = new DX11RenderState();
     result.Blend = this.Blend;
     result.DepthStencil = this.DepthStencil;
     result.Rasterizer = this.Rasterizer;
     return result;
 }
Beispiel #5
0
        public DX11RenderState Clone()
        {
            DX11RenderState result = new DX11RenderState();

            result.Blend        = this.Blend;
            result.DepthStencil = this.DepthStencil;
            result.Rasterizer   = this.Rasterizer;
            return(result);
        }
Beispiel #6
0
        public DX11RenderState Clone()
        {
            DX11RenderState result = new DX11RenderState();

            result.Blend                 = this.Blend;
            result.DepthStencil          = this.DepthStencil;
            result.Rasterizer            = this.Rasterizer;
            result.BlendFactor           = this.BlendFactor;
            result.DepthStencilReference = this.DepthStencilReference;
            result.Tag = this.Tag;
            return(result);
        }
        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.PluginIO.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;
            }
        }
        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.PluginIO.IsConnected)
                    {
                        rs = this.FInState[i].Clone();
                    }
                    else
                    {
                        rs = new DX11RenderState();
                    }

                    rs.DepthStencilReference = this.FInReference[i];
                    this.FOutState[i] = rs;
                }

            }
        }
        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[i].X;
                                he = (int)this.FInSize[i].Y;
                            }
                        }
                    }
                    else
                    {
                        initial = context.DefaultTextures.WhiteTexture;
                        wi = (int)this.FInSize[i].X;
                        he = (int)this.FInSize[i].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);
                        bool isLastPass = j == tech.Description.PassCount - 1;

                        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 || (isLastPass && FInMipLastPass[i]);

                            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 (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); }
        }
 public void Push(DX11RenderState state)
 {
     stack.Push(state);
     this.Apply();
 }
 protected override DX11RenderState AssignPreset(string key, DX11RenderState statein)
 {
     statein.DepthStencil = DX11DepthStencilStates.Instance.GetState(key);
     return statein;
 }
 protected override DX11RenderState AssignPreset(string key, DX11RenderState statein)
 {
     statein.Rasterizer = DX11RasterizerStates.Instance.GetState(key);
     return statein;
 }
        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;
                }

            }
        }
Beispiel #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();
                     }
                 }
             }
        }
Beispiel #16
0
 public void Push(DX11RenderState state)
 {
     stack.Push(state);
     this.Apply();
 }
 protected abstract DX11RenderState AssignPreset(string key,DX11RenderState statein);
Beispiel #18
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));
             }

             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();
                 }
             }
        }