public CShaderSamplers GetSamplerBinder_PickedEditor(CRenderContext RHICtx, CShaderProgram shader)
        {
            if (shader == null)
            {
                return(null);
            }

            if (mSamplerBinder_PickedEditor == null)
            {
                mSamplerBinder_PickedEditor = new CShaderSamplers();
                using (var it = MtlInst.Material.GetSamplerStateDescs().GetEnumerator())
                {
                    while (it.MoveNext())
                    {
                        var name              = it.Current.Key;
                        var samplerDesc       = it.Current.Value;
                        CSamplerBindInfo info = new CSamplerBindInfo();
                        if (shader.FindSamplerBindInfoByShaderName(MtlInst, name, ref info))
                        {
                            CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, samplerDesc);
                            mSamplerBinder_PickedEditor.PSBindSampler(info.PSBindPoint, SamplerState);
                        }
                        else
                        {
                            var defaultSamplerDesc = new CSamplerStateDesc();
                            defaultSamplerDesc.SetDefault();
                            CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, defaultSamplerDesc);
                            mSamplerBinder_PickedEditor.PSBindSampler(info.PSBindPoint, SamplerState);
                        }
                    }
                }
            }
            return(mSamplerBinder_PickedEditor);
        }
        public CShaderSamplers GetSamplerBinder_Shadow(CRenderContext RHICtx, CShaderProgram shader)
        {
            if (shader == null)
            {
                return(null);
            }

            if (mSamplerBinder_Shadow == null)
            {
                mSamplerBinder_Shadow = new CShaderSamplers();
                //var SamplerDesc = new CSamplerStateDesc();
                //SamplerDesc.SetDefault();
                //for (UInt32 i = 0; i < shader.SamplerNumber; i++)
                //{
                //    CSamplerBindInfo info = new CSamplerBindInfo();
                //    shader.GetSamplerBindInfo(i, ref info);
                //    MtlInst.GetSamplerStateDesc(i, ref SamplerDesc);
                //    CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, SamplerDesc);
                //    mSamplerBinder_Shadow.PSBindSampler(info.PSBindPoint, SamplerState);
                //}
                using (var it = MtlInst.Material.GetSamplerStateDescs().GetEnumerator())
                {
                    while (it.MoveNext())
                    {
                        var name              = it.Current.Key;
                        var samplerDesc       = it.Current.Value;
                        CSamplerBindInfo info = new CSamplerBindInfo();
                        if (shader.FindSamplerBindInfoByShaderName(MtlInst, name, ref info))
                        {
                            CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, samplerDesc);
                            mSamplerBinder_Shadow.PSBindSampler(info.PSBindPoint, SamplerState);
                        }
                        else
                        {
                            var defaultSamplerDesc = new CSamplerStateDesc();
                            defaultSamplerDesc.SetDefault();
                            CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, defaultSamplerDesc);
                            mSamplerBinder_Shadow.PSBindSampler(info.PSBindPoint, SamplerState);
                        }
                    }
                }
            }

            return(mSamplerBinder_Shadow);
        }
 public void GetSamplerBinder(CRenderContext RHICtx, CShaderProgram shader, CShaderSamplers sampler)
 {
     if (shader == null || MtlInst.Material.GetSamplerStateDescs().Count <= 0)
     {
         return;
     }
     using (var it = MtlInst.Material.GetSamplerStateDescs().GetEnumerator())
     {
         while (it.MoveNext())
         {
             var name              = it.Current.Key;
             var samplerDesc       = it.Current.Value;
             CSamplerBindInfo info = new CSamplerBindInfo();
             if (shader.FindSamplerBindInfoByShaderName(MtlInst, name, ref info))
             {
                 CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, samplerDesc);
                 sampler.PSBindSampler(info.PSBindPoint, SamplerState);
             }
         }
     }
 }
        public void FillPassData(CRenderContext RHICtx,
                                 CPass refPass,
                                 CGfxEffect effect,
                                 PrebuildPassIndex ppi,
                                 bool flushVars = false)
        {
            refPass.Effect = effect;
            if (effect.CacheData.PerInstanceId != UInt32.MaxValue)
            {
                ReCreateCBuffer(RHICtx, effect, flushVars);
            }
            refPass.BindCBuffer(effect.ShaderProgram, effect.CacheData.PerInstanceId, CBuffer);
            MtlInst.BindTextures(refPass.ShaderResources, effect.ShaderProgram);
            refPass.BindShaderTextures(this);
            var tempSampler = new CShaderSamplers();

            this.GetSamplerBinder(RHICtx, effect.ShaderProgram, tempSampler);
            refPass.ShaderSamplerBinder = tempSampler;

            var PrebuildPassData = CEngine.Instance.PrebuildPassData;

            if (ppi == PrebuildPassIndex.PPI_HitProxy ||
                ppi == PrebuildPassIndex.PPI_SceneCapture)
            {
                switch (MtlInst.mRenderLayer)
                {
                case View.ERenderLayer.RL_Opaque:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mOpaqueRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mOpaqueDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_Translucent:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mTranslucentRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mTranslucentDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_CustomOpaque:
                case View.ERenderLayer.RL_CustomTranslucent:
                case View.ERenderLayer.RL_Gizmos:
                case View.ERenderLayer.RL_Sky:
                {
                    refPass.RenderPipeline.RasterizerState   = MtlInst.CustomRasterizerState;
                    refPass.RenderPipeline.DepthStencilState = MtlInst.CustomDepthStencilState;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;
                }
            }
            else if (ppi == PrebuildPassIndex.PPI_Snapshot)
            {
                switch (MtlInst.mRenderLayer)
                {
                case View.ERenderLayer.RL_Opaque:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mOpaqueRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mOpaqueDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_Translucent:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mTranslucentRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mTranslucentDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mSnapshotBlendStat;
                }
                break;

                case View.ERenderLayer.RL_CustomOpaque:
                case View.ERenderLayer.RL_CustomTranslucent:
                case View.ERenderLayer.RL_Gizmos:
                case View.ERenderLayer.RL_Sky:
                {
                    refPass.RenderPipeline.RasterizerState   = MtlInst.CustomRasterizerState;
                    refPass.RenderPipeline.DepthStencilState = MtlInst.CustomDepthStencilState;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mSnapshotBlendStat;
                }
                break;
                }
            }
            else if (ppi == PrebuildPassIndex.PPI_PickedEditor)
            {
                switch (MtlInst.mRenderLayer)
                {
                case View.ERenderLayer.RL_Opaque:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mOpaqueRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mOpaqueDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_Translucent:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mTranslucentRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mTranslucentDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_CustomOpaque:
                case View.ERenderLayer.RL_CustomTranslucent:
                case View.ERenderLayer.RL_Gizmos:
                case View.ERenderLayer.RL_Sky:
                {
                    refPass.RenderPipeline.RasterizerState   = MtlInst.CustomRasterizerState;
                    refPass.RenderPipeline.DepthStencilState = MtlInst.CustomDepthStencilState;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;
                }
            }
            else if (ppi == PrebuildPassIndex.PPI_SSM)
            {
                refPass.RenderPipeline.RasterizerState   = MtlInst.mShadowRasterState;
                refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mOpaqueDSStat;
                refPass.RenderPipeline.BlendState        = PrebuildPassData.mShadowBlendStat;
            }
            else
            {
                switch (MtlInst.mRenderLayer)
                {
                case View.ERenderLayer.RL_Shadow:
                {
                    refPass.RenderPipeline.RasterizerState   = MtlInst.mShadowRasterState;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mOpaqueDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mShadowBlendStat;
                }
                break;

                case View.ERenderLayer.RL_Opaque:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mOpaqueRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mOpaqueDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_Translucent:
                {
                    refPass.RenderPipeline.RasterizerState   = PrebuildPassData.mTranslucentRasterStat;
                    refPass.RenderPipeline.DepthStencilState = PrebuildPassData.mTranslucentDSStat;
                    refPass.RenderPipeline.BlendState        = PrebuildPassData.mTranslucentBlendStat;
                }
                break;

                case View.ERenderLayer.RL_CustomOpaque:
                case View.ERenderLayer.RL_CustomTranslucent:
                {
                    refPass.RenderPipeline.RasterizerState   = MtlInst.CustomRasterizerState;
                    refPass.RenderPipeline.DepthStencilState = MtlInst.CustomDepthStencilState;
                    refPass.RenderPipeline.BlendState        = MtlInst.CustomBlendState; // PrebuildPassData.mOpaqueBlendStat;
                }
                break;

                case View.ERenderLayer.RL_Gizmos:
                case View.ERenderLayer.RL_Sky:
                {
                    refPass.RenderPipeline.RasterizerState   = MtlInst.CustomRasterizerState;
                    refPass.RenderPipeline.DepthStencilState = MtlInst.CustomDepthStencilState;
                    refPass.RenderPipeline.BlendState        = MtlInst.CustomBlendState;
                }
                break;
                }
            }
        }
Exemple #5
0
        public void SetPassData(CRenderContext rc, CGfxMesh mesh, UInt32 index, CGfxSceneView vp, CPass pass)
        {
            //OnEffectRefresh(rc);
            if (pass.RenderPipeline == null)
            {
                var rplDesc = new CRenderPipelineDesc();
                pass.RenderPipeline = rc.CreateRenderPipeline(rplDesc);
            }
            pass.RenderPipeline.ShaderProgram     = mEffect.ShaderProgram;
            pass.RenderPipeline.RasterizerState   = mMaterial.RasterizerState;
            pass.RenderPipeline.DepthStencilState = mMaterial.DepthStencilState;
            pass.RenderPipeline.BlendState        = mMaterial.BlendState;

            pass.GeometryMesh = mesh.MeshPrimitives.GeometryMesh;

            pass.BindCBuffer(mEffect.ShaderProgram, mEffect.PerInstanceId, CBuffer);
            pass.BindCBuffer(mEffect.ShaderProgram, mEffect.PerFrameId, CEngine.Instance.PerFrameCBuffer);

            if (vp != null)
            {
                pass.ViewPort = vp.Viewport;
            }

            var textures = new CShaderResources();

            {
                Material.BindTextures(textures, mEffect.ShaderProgram);
                foreach (var i in Textures)
                {
                    textures.PSBindTexture(i.Key, i.Value);
                }
                mesh.ShadingEnv.BindResources(mesh, CBuffer, textures, mEffect.ShaderProgram);
            }
            pass.ShaderResources = textures;

            CShaderSamplers samplers = new CShaderSamplers();

            {
                CSamplerStateDesc sampDesc = new CSamplerStateDesc();
                sampDesc.SetDefault();
                sampDesc.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_POINT;
                CSamplerState samp = CEngine.Instance.SamplerStateManager.GetSamplerState(rc, sampDesc);
                for (UInt32 i = 0; i < mEffect.ShaderProgram.SamplerNumber; i++)
                {
                    CSamplerBindInfo info = new CSamplerBindInfo();
                    mEffect.ShaderProgram.GetSamplerBindInfo(i, ref info);
                    samplers.PSBindSampler(info.PSBindPoint, samp);
                }
            }
            pass.ShaderSamplers = samplers;

            foreach (var i in mesh.MdfQueue.Modifiers)
            {
                i.OnSetPassData(pass);
            }

            CDrawPrimitiveDesc dpDesc = new CDrawPrimitiveDesc();

            mesh.MeshPrimitives.GetAtom(index, 0, ref dpDesc);
            pass.BindDrawPrimitive(ref dpDesc);
        }