public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.Effect;
if (Shader.CacheData.EnvMapBindPoint != UInt32.MaxValue)
{
TexBinder.PSBindTexture(Shader.CacheData.EnvMapBindPoint, mEnvMap);
}
if (Shader.CacheData.SampEnvMapBindPoint != UInt32.MaxValue)
{
SamplerBinder.PSBindSampler(Shader.CacheData.SampEnvMapBindPoint, SamplerStat);
}
if (Shader.CacheData.BindingSlot_ShadowMap != UInt32.MaxValue)
{
TexBinder.PSBindTexture(Shader.CacheData.BindingSlot_ShadowMap, mTex_ShadowMap);
}
if (Shader.CacheData.BindingSlot_ShadowMapSampler != UInt32.MaxValue)
{
SamplerBinder.PSBindSampler(Shader.CacheData.BindingSlot_ShadowMapSampler, mSampler_ShadowMap);
}
}
public void OnSetPassData(CPass pass, bool shadow)
{
for (int i = 0; i < Modifiers.Count; i++)
{
Modifiers[i].OnSetPassData(pass, shadow);
}
}
public void BindParticleVB(CPass pass)
{
if (SubStates == null || SubStates.Length == 0)
{
return;
}
if (pass != null && pass.GeometryMesh != null)
{//这里在粒子Mesh创建Pass的时候调用
if (pass.AttachVBs == null)
{
if (HostActorMesh != null && HostActorMesh.SceneMesh != null)//MeshPrimitives
{
pass.AttachVBs = new CVertexArray();
if (TrailNode != null && IsTrail && pass.GeometryMesh != null)
{
pass.BindGeometry(TrailNode.GeomMesh, 0, 0);
}
else
{
pass.BindGeometry(HostActorMesh.SceneMesh.MeshPrimitives, 0, 0);
}
pass.AttachVBs.BindVertexBuffer(EVertexSteamType.VST_InstPos, mPosVB);
pass.AttachVBs.BindVertexBuffer(EVertexSteamType.VST_InstScale, mScaleVB);
pass.AttachVBs.BindVertexBuffer(EVertexSteamType.VST_InstQuat, mRotateVB);
pass.AttachVBs.BindVertexBuffer(EVertexSteamType.VST_F4_1, mColorVB);
if (MaterialInstanceNode != null)
{
MaterialInstanceNode.SetMaterialInstanceValue(HostActorMesh.SceneMesh);
}
}
}
if (pass.AttachVBs == null)
{
return;
}
if (TrailNode != null && IsTrail && pass.GeometryMesh != null)
{
if (TrailNode.TrailDataControlData != null && TrailNode.TrailDataControlData.IsVaild())
{
TrailNode.TrailDataControlData.BindBuffs(CEngine.Instance.RenderContext, TrailNode.GeomMesh);
pass.AttachVBs.NumInstances = 1;
}
else
{
pass.AttachVBs.NumInstances = 0;
}
}
else
{
pass.AttachVBs.NumInstances = (uint)ParticleNumber;
}
}
}
public override void OnSetPassData(CPass pass, bool shadow)
{
if (shadow)
{
mShadowHost.BindBuffers(pass);
}
else
{
mHost.BindBuffers(pass);
}
}
public void CookShadowLayerData2Pass(CRenderContext RHICtx, CGfxCamera ViewerCamera, CGfxCamera ShadowCamera, CGfxShadingEnv ShadingEnv)
{
if (ViewerCamera == null || ShadowCamera == null || RHICtx == null || ShadingEnv == null)
{
return;
}
var ShadowRenderLayer = ViewerCamera.mSceneRenderLayer[(int)ERenderLayer.RL_Shadow];
int Count = ShadowRenderLayer.GetRenderLayerAtomNum();
for (uint idx = 0; idx < Count; idx++)
{
var MtlMesh = ShadowRenderLayer.GetMtlMeshFromArray(idx);
if (MtlMesh == null)
{
return;
}
var SceneMesh = MtlMesh.mRootSceneMesh;
if (MtlMesh == null || SceneMesh == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "@Graphic", $"NullPtr here", "");
continue;
}
MtlMesh.UpdatePerMtlMeshCBufferForShadow(RHICtx, ShadowCamera);
CPass refPass = MtlMesh.GetPass(PrebuildPassIndex.PPI_SSM);
if (refPass == null)
{
continue;
}
if (refPass.PreUse() == false)
{
continue;
}
refPass.BindShaderTextures(MtlMesh);
refPass.ShaderSamplerBinder = MtlMesh.GetSamplerBinder_Shadow(RHICtx, refPass.Effect.ShaderProgram);
ShadingEnv.BindResources(SceneMesh, refPass);
refPass.ViewPort = mViewport;
refPass.BindCBuffer(refPass.Effect.ShaderProgram, refPass.Effect.CacheData.CBID_Camera, ShadowCamera.CBuffer);
refPass.BindCBuffer(refPass.Effect.ShaderProgram, refPass.Effect.CacheData.CBID_View, SceneViewCB);
SceneMesh.MdfQueue.OnSetPassData(refPass, true);
SendPassToCorrectRenderLayer(ERenderLayer.RL_Shadow, refPass);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
//, CConstantBuffer cbPerInstance, CShaderResources TexBinder, CShaderSamplers SamplerBinder, CShaderProgram Shader)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.Effect;
if (Shader.CacheData.EnvMapBindPoint != UInt32.MaxValue)
{
TexBinder.PSBindTexture(Shader.CacheData.EnvMapBindPoint, mEnvMap);
}
if (Shader.CacheData.SampEnvMapBindPoint != UInt32.MaxValue)
{
SamplerBinder.PSBindSampler(Shader.CacheData.SampEnvMapBindPoint, SamplerStat);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
//, CConstantBuffer cbPerInstance, CShaderResources TexBinder, CShaderSamplers SamplerBinder, CShaderProgram Shader)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.GpuProgram;
//up
{
if (Shader.FindTextureBindInfo(null, "gSrcTexUp", ref mTexBindInfo_SrcTexUp))
{
TexBinder.PSBindTexture(mTexBindInfo_SrcTexUp.PSBindPoint, mSrcTexUp);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gSrcTexUp", ref mSamplerBindInfo_SrcTexUp) == true)
{
mSamplerStateDesc_SrcTexUp.SetDefault();
mSamplerStateDesc_SrcTexUp.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_LINEAR;
mSamplerStateDesc_SrcTexUp.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_SrcTexUp.AddressV = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_SrcTexUp);
SamplerBinder.PSBindSampler(mSamplerBindInfo_SrcTexUp.PSBindPoint, SamplerStat);
}
}
//down
{
if (Shader.FindTextureBindInfo(null, "gSrcTexDown", ref mTexBindInfo_SrcTexDown))
{
TexBinder.PSBindTexture(mTexBindInfo_SrcTexDown.PSBindPoint, mSrcTexDown);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gSrcTexDown", ref mSamplerBindInfo_SrcTexDown) == true)
{
mSamplerStateDesc_SrcTexDown.SetDefault();
mSamplerStateDesc_SrcTexDown.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_LINEAR;
mSamplerStateDesc_SrcTexDown.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_SrcTexDown.AddressV = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_SrcTexDown);
SamplerBinder.PSBindSampler(mSamplerBindInfo_SrcTexDown.PSBindPoint, SamplerStat);
}
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
//CTextureBindInfo info = new CTextureBindInfo(); //this is a struct,so you can use new as convenient;
//if (Shader.FindTextureBindInfo(null, "gEnvMap", ref info))
//{
// TexBinder.PSBindTexture(info.PSBindPoint, mEnvMap);
//}
//var SamplerBindInfo = new CSamplerBindInfo();
//if (Shader.FindSamplerBindInfo(null, "Samp_gEnvMap", ref SamplerBindInfo) == true)
//{
// var SamplerStatDesc = new CSamplerStateDesc();
// SamplerStatDesc.SetDefault();
// SamplerStatDesc.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_LINEAR;
// var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, SamplerStatDesc);
// SamplerBinder.PSBindSampler(SamplerBindInfo.PSBindPoint, SamplerStat);
//}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
//, CConstantBuffer cbPerInstance, CShaderResources TexBinder, CShaderSamplers SamplerBinder, CShaderProgram Shader)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.GpuProgram;
//base scene view;
if (Shader.FindTextureBindInfo(null, "gBaseSceneView", ref mTexBindInfo_BaseSceneView))
{
TexBinder.PSBindTexture(mTexBindInfo_BaseSceneView.PSBindPoint, mBaseSceneView);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gBaseSceneView", ref mSamplerBindInfo_BaseSceneView) == true)
{
mSamplerStateDesc_BaseSceneView.SetDefault();
mSamplerStateDesc_BaseSceneView.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_LINEAR;
mSamplerStateDesc_BaseSceneView.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_BaseSceneView.AddressV = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_BaseSceneView);
SamplerBinder.PSBindSampler(mSamplerBindInfo_BaseSceneView.PSBindPoint, SamplerStat);
}
//bloom;
if (Shader.FindTextureBindInfo(null, "gBloomTex", ref mTexBindInfo_BloomTex))
{
TexBinder.PSBindTexture(mTexBindInfo_BloomTex.PSBindPoint, mBloomTex);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gBloomTex", ref mSamplerBindInfo_BloomTex) == true)
{
mSamplerStateDesc_BloomTex.SetDefault();
mSamplerStateDesc_BloomTex.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_LINEAR;
mSamplerStateDesc_BloomTex.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_BloomTex.AddressV = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_BloomTex);
SamplerBinder.PSBindSampler(mSamplerBindInfo_BloomTex.PSBindPoint, SamplerStat);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.GpuProgram;
if (Shader.FindTextureBindInfo(null, "gPickedSetUpTex", ref mTBI_PickedSetUp))
{
TexBinder.PSBindTexture(mTBI_PickedSetUp.PSBindPoint, mSRV_PickedSetUp);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gPickedSetUp", ref mSBI_PickedSetUp) == true)
{
mSSD_PickedSetUp.SetDefault();
mSSD_PickedSetUp.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_POINT;
mSSD_PickedSetUp.AddressU = EAddressMode.ADM_CLAMP;
mSSD_PickedSetUp.AddressV = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSSD_PickedSetUp);
SamplerBinder.PSBindSampler(mSBI_PickedSetUp.PSBindPoint, SamplerStat);
}
//
if (Shader.FindTextureBindInfo(null, "gPickedBlurTex", ref mTBI_PickedBlur))
{
TexBinder.PSBindTexture(mTBI_PickedBlur.PSBindPoint, mSRV_PickedBlur);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gPickedBlur", ref mSBI_PickedBlur) == true)
{
mSSD_PickedBlur.SetDefault();
mSSD_PickedBlur.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_POINT;
mSSD_PickedBlur.AddressU = EAddressMode.ADM_CLAMP;
mSSD_PickedBlur.AddressV = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSSD_PickedBlur);
SamplerBinder.PSBindSampler(mSBI_PickedBlur.PSBindPoint, SamplerStat);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
//, CConstantBuffer cbPerInstance, CShaderResources TexBinder, CShaderSamplers SamplerBinder, CShaderProgram Shader)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var effect = pass.Effect;
//env map;
if (effect.CacheData.EnvMapBindPoint != UInt32.MaxValue)
{
TexBinder.PSBindTexture(effect.CacheData.EnvMapBindPoint, mEnvMap);
}
if (effect.CacheData.SampEnvMapBindPoint != UInt32.MaxValue)
{
SamplerBinder.PSBindSampler(effect.CacheData.SampEnvMapBindPoint, SamplerStat);
}
//eye env map;
if (effect.CacheData.EyeEnvMapBindPoint != UInt32.MaxValue)
{
TexBinder.PSBindTexture(effect.CacheData.EyeEnvMapBindPoint, mEyeEnvMap);
}
if (effect.CacheData.SampEyeEnvMapBindPoint != UInt32.MaxValue)
{
SamplerBinder.PSBindSampler(effect.CacheData.SampEyeEnvMapBindPoint, SamplerStat);
}
//shadow map binding;
if (effect.CacheData.BindingSlot_ShadowMap != UInt32.MaxValue)
{
TexBinder.PSBindTexture(effect.CacheData.BindingSlot_ShadowMap, mTex_ShadowMap);
}
if (effect.CacheData.BindingSlot_ShadowMapSampler != UInt32.MaxValue)
{
SamplerBinder.PSBindSampler(effect.CacheData.BindingSlot_ShadowMapSampler, mSampler_ShadowMap);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
var fmesh = mesh.Tag as CFontMesh;
if (fmesh != null)
{
if (fmesh.CBuffer == null)
{
fmesh.CBuffer = CEngine.Instance.RenderContext.CreateConstantBuffer(pass.Effect.ShaderProgram, pass.Effect.CacheData.CBID_ShadingEnv);
int TextMatrixId = fmesh.CBuffer.FindVar("RenderMatrix");
int TextOpacityId = fmesh.CBuffer.FindVar("TextOpacity");
int TextColorId = fmesh.CBuffer.FindVar("TextColor");
fmesh.CBuffer.SetValue(TextMatrixId, fmesh.RenderMatrix, 0);
fmesh.CBuffer.SetValue(TextOpacityId, fmesh.TextOpacity, 0);
fmesh.CBuffer.SetValue(TextColorId, fmesh.TextColor, 0);
}
pass.BindCBuffer(pass.GpuProgram, pass.Effect.CacheData.CBID_ShadingEnv, fmesh.CBuffer);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.GpuProgram;
if (Shader.FindTextureBindInfo(null, "gSrcTex", ref mTexBindInfo_Src))
{
TexBinder.PSBindTexture(mTexBindInfo_Src.PSBindPoint, mSRV_Src);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gSrcTex", ref mSampBindInfo_Src) == true)
{
mSampStateDesc_Src.SetDefault();
mSampStateDesc_Src.Filter = ESamplerFilter.SPF_MIN_MAG_LINEAR_MIP_POINT;
mSampStateDesc_Src.AddressU = EAddressMode.ADM_CLAMP;
mSampStateDesc_Src.AddressV = EAddressMode.ADM_CLAMP;
mSampStateDesc_Src.AddressW = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSampStateDesc_Src);
SamplerBinder.PSBindSampler(mSampBindInfo_Src.PSBindPoint, SamplerStat);
}
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
var TexBinder = pass.ShaderResources;
var SamplerBinder = pass.ShaderSamplerBinder;
var Shader = pass.GpuProgram;
//base scene view;
if (Shader.FindTextureBindInfo(null, "gBaseSceneView", ref mTexBindInfo_BaseSceneView))
{
TexBinder.PSBindTexture(mTexBindInfo_BaseSceneView.PSBindPoint, mBaseSceneView);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gBaseSceneView", ref mSamplerBindInfo_BaseSceneView) == true)
{
mSamplerStateDesc_BaseSceneView.SetDefault();
mSamplerStateDesc_BaseSceneView.Filter = ESamplerFilter.SPF_MIN_MAG_LINEAR_MIP_POINT;
mSamplerStateDesc_BaseSceneView.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_BaseSceneView.AddressV = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_BaseSceneView.AddressW = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_BaseSceneView);
SamplerBinder.PSBindSampler(mSamplerBindInfo_BaseSceneView.PSBindPoint, SamplerStat);
}
//bloom;
if (Shader.FindTextureBindInfo(null, "gBloomTex", ref mTexBindInfo_BloomTex))
{
TexBinder.PSBindTexture(mTexBindInfo_BloomTex.PSBindPoint, mBloomTex);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gBloomTex", ref mSamplerBindInfo_BloomTex) == true)
{
mSamplerStateDesc_BloomTex.SetDefault();
mSamplerStateDesc_BloomTex.Filter = ESamplerFilter.SPF_MIN_MAG_LINEAR_MIP_POINT;
mSamplerStateDesc_BloomTex.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_BloomTex.AddressV = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_BloomTex.AddressW = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_BloomTex);
SamplerBinder.PSBindSampler(mSamplerBindInfo_BloomTex.PSBindPoint, SamplerStat);
}
//vignette;
if (Shader.FindTextureBindInfo(null, "gVignette", ref mTexBindInfo_Vignette))
{
TexBinder.PSBindTexture(mTexBindInfo_Vignette.PSBindPoint, mVignetteTex);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gVignette", ref mSamplerBindInfo_Vignette) == true)
{
mSamplerStateDesc_Vignette.SetDefault();
mSamplerStateDesc_Vignette.Filter = ESamplerFilter.SPF_MIN_MAG_LINEAR_MIP_POINT;
mSamplerStateDesc_Vignette.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_Vignette.AddressV = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_Vignette.AddressW = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_Vignette);
SamplerBinder.PSBindSampler(mSamplerBindInfo_Vignette.PSBindPoint, SamplerStat);
}
//sun shaft;
if (Shader.FindTextureBindInfo(null, "gSunShaft", ref mTexBindInfo_SunShaft))
{
TexBinder.PSBindTexture(mTexBindInfo_SunShaft.PSBindPoint, mSunShaftTex);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gSunShaft", ref mSamplerBindInfo_SunShaft) == true)
{
mSamplerStateDesc_SunShaft.SetDefault();
mSamplerStateDesc_SunShaft.Filter = ESamplerFilter.SPF_MIN_MAG_LINEAR_MIP_POINT;
mSamplerStateDesc_SunShaft.AddressU = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_SunShaft.AddressV = EAddressMode.ADM_CLAMP;
mSamplerStateDesc_SunShaft.AddressW = EAddressMode.ADM_CLAMP;
var SamplerStat = CEngine.Instance.SamplerStateManager.GetSamplerState(CEngine.Instance.RenderContext, mSamplerStateDesc_SunShaft);
SamplerBinder.PSBindSampler(mSamplerBindInfo_SunShaft.PSBindPoint, SamplerStat);
}
//mobile ao srv binding;
if (Shader.FindTextureBindInfo(null, "gMobileAoTex", ref mTBI_MobileAo))
{
TexBinder.PSBindTexture(mTBI_MobileAo.PSBindPoint, mSRV_MobileAo);
}
if (Shader.FindSamplerBindInfo(null, "Samp_gMobileAoTex", ref mSBI_MobileAo) == true)
{
SamplerBinder.PSBindSampler(mSBI_MobileAo.PSBindPoint, mSampStat_MobileAo);
}
}
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;
}
}
}
public bool InitByEffects(CRenderContext RHICtx, CGfxMesh SceneMesh, UInt32 index, CGfxMaterialInstance mtl_inst, CGfxEffect[] effects, CGfxShadingEnv[] EnvShaderArray, bool preUseEffect)
{
MtlInst = mtl_inst;
mRootSceneMesh = SceneMesh;
mAtomIndex = index;
if (mPrebuildPassArray == null)
{
mPrebuildPassArray = new CPass[(int)PrebuildPassIndex.PPI_Num];
}
for (int ppi = 0; ppi < (int)PrebuildPassIndex.PPI_Num; ppi++)
{
var effect = effects[ppi];
if (effect == null)
{
continue;
}
CPass refPass = null;
if (mPrebuildPassArray[ppi] != null)
{
refPass = mPrebuildPassArray[ppi];
}
else
{
refPass = RHICtx.CreatePass();
}
refPass.InitPass(RHICtx, effect, EnvShaderArray[ppi], this, index);
refPass.PassIndex = (PrebuildPassIndex)ppi;
//如果Effect已经加载完成，那么设置Pass状态
//否则就要等渲染的时候Pass.PreUse来间接触发了
//
if (refPass.Effect.IsValid)
{
FillPassData(RHICtx, refPass, effect, (PrebuildPassIndex)ppi, true);
}
else
{
if (preUseEffect)
{
effect.PreUse((successed) =>
{
if (successed == false)
{
return;
}
FillPassData(RHICtx, refPass, effect, (PrebuildPassIndex)ppi);
});
}
}
//这里一旦PreUse了，那就把所有shader都在初始化的时候就加载了
//effect.PreUse((successed) =>
//{
// if(successed==false)
// {
// return;
// }
// FillPassData(RHICtx, refPass, effect, (PrebuildPassIndex)ppi);
//});
mPrebuildPassArray[ppi] = refPass;
}
return(true);
}
public async System.Threading.Tasks.Task <bool> Init(CRenderContext RHICtx, CSwapChain SwapChain,
CGfxScreenViewDesc ViewInfo, CGfxShadingEnv ShadingEnv, CGfxMaterialInstance MtlInst, CGfxMesh ViewportMesh)
{
if (ShadingEnv == null)
{
return(false);
}
if (ViewportMesh == null)
{
var ScreenAlignedTriangle = CEngine.Instance.MeshPrimitivesManager.GetMeshPrimitives(RHICtx, CEngineDesc.ScreenAlignedTriangleName, true);
ViewportMesh = CEngine.Instance.MeshManager.CreateMesh(RHICtx, ScreenAlignedTriangle);
ViewportMesh.SetMaterialInstance(RHICtx, 0, await CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(RHICtx,
RName.GetRName("Material/defaultmaterial.instmtl")),
CEngine.Instance.PrebuildPassData.DefaultShadingEnvs);
//await ViewportMesh.AwaitEffects();
}
mViewInfo = ViewInfo;
mViewport = new CViewport();
mViewport.Width = ViewInfo.Width;
mViewport.Height = ViewInfo.Height;
mViewport.TopLeftX = 0.0f;
mViewport.TopLeftY = 0.0f;
mViewport.MinDepth = 0.0f;
mViewport.MaxDepth = 1.0f;
var ShaderProgram = CEngine.Instance.EffectManager.DefaultEffect.ShaderProgram;
mScreenViewCB = RHICtx.CreateConstantBuffer(ShaderProgram, CEngine.Instance.EffectManager.DefaultEffect.CacheData.CBID_View);
if (mScreenViewCB == null)
{
return(false);
}
mIDViewportSizeAndRcp = mScreenViewCB.FindVar("gViewportSizeAndRcp");
mID_SunPosNDC = mScreenViewCB.FindVar("gSunPosNDC");
mID_DirLightColor_Intensity = mScreenViewCB.FindVar("gDirLightColor_Intensity");
mID_AoParam = mScreenViewCB.FindVar("gAoParam");
CRasterizerStateDesc RSDesc = new CRasterizerStateDesc();
RSDesc.InitForCustom();
mRasterState = CEngine.Instance.RasterizerStateManager.GetRasterizerState(RHICtx, RSDesc);
CDepthStencilStateDesc DSSDesc = new CDepthStencilStateDesc();
DSSDesc.InitForCustomLayers();
mDepthStencilState = CEngine.Instance.DepthStencilStateManager.GetDepthStencilState(RHICtx, DSSDesc);
CBlendStateDesc BlendDesc = new CBlendStateDesc();
BlendDesc.InitForCustomLayers();
mBlendState = CEngine.Instance.BlendStateManager.GetBlendState(RHICtx, BlendDesc);
mPass = RHICtx.CreatePass();
if (false == await mPass.InitPassForViewportView(RHICtx, ShadingEnv, MtlInst, ViewportMesh))
{
return(false);
}
return(OnResize(RHICtx, SwapChain, ViewInfo.Width, ViewInfo.Height));
}
public void SendPassToCorrectRenderLayer(ERenderLayer index, CPass pass)
{
SDK_GfxSceneView_SendPassToCorrectRenderLayer(mCoreObject, index, pass.CoreObject);
}
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);
}
public virtual void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
//每个shadingenv根据自己的shader代码，在这里绑定纹理，设置cbPerInstance变量
//正常情况ShadingEnv不应该给cbPerInstance设置变量，特殊需求在这个函数特殊写
//shadingEnv的变量，应该主要在非cbPerInstance里面
}
public async System.Threading.Tasks.Task InitPass(CRenderContext rc, Graphics.CGfxMaterialInstance MtlInst = null, bool isSM3 = false)
{
if (rc == null)
{
rc = CEngine.Instance.RenderContext;
}
if (CRenderContext.ShaderModel >= 4)
{
UseComputeShader = true;
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "Graphics", $"GpuDriven: SM = {CRenderContext.ShaderModel},Use ComputeShader");
}
else
{
UseComputeShader = false;
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "Graphics", $"GpuDriven: SM = {CRenderContext.ShaderModel},CPU Culling");
}
if (rc.ContextCaps.MaxVertexShaderStorageBlocks == 0)
{
UseVTF = true;
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "Graphics", $"GpuDriven: No SSBO in VertexShader,Use VTF");
}
else
{
UseVTF = false;
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "Graphics", $"GpuDriven: Use SSBO in VertexShader");
}
if (mMergeInstanceSE == null)
{
mMergeInstanceSE = mMergeInstanceSE = EngineNS.CEngine.Instance.ShadingEnvManager.GetGfxShadingEnv <CGfxMergeInstanceSE>();
if (UseVTF)
{
mMergeInstanceSE.SetMacroDefineValue("ENV_USEVTF", "1");
}
else
{
mMergeInstanceSE.SetMacroDefineValue("ENV_USEVTF", "0");
}
}
if (MtlInst == null)
{
MtlInst = await CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(rc, RName.GetRName("Material/defaultmaterial.instmtl"));
}
if (mPass == null)
{
var pass = rc.CreatePass();
var meshpri = CEngine.Instance.MeshPrimitivesManager.CreateMeshPrimitives(rc, 1);
EngineNS.Graphics.Mesh.CGfxMeshCooker.MakeRect3D(rc, meshpri);
//var meshpri = CEngine.Instance.MeshPrimitivesManager.GetMeshPrimitives(rc, CEngineDesc.ScreenAlignedTriangleName, true);
var ViewportMesh = CEngine.Instance.MeshManager.CreateMesh(rc, meshpri);
ViewportMesh.SetMaterialInstance(rc, 0, MtlInst,
CEngine.Instance.PrebuildPassData.DefaultShadingEnvs);
var affectLights = new List <GamePlay.SceneGraph.GSceneGraph.AffectLight>();
ViewportMesh.mMeshVars.SetPointLights(affectLights);
await pass.InitPassForViewportView(rc, mMergeInstanceSE, MtlInst, ViewportMesh);
mPass = pass;
var vsDesc = mPass.Effect.ShaderProgram.VertexShader.Desc;
var tbInfo = new CTextureBindInfo();
if (vsDesc.GetSRVDesc(vsDesc.FindSRVDesc("AllVertexArray"), ref tbInfo))
{
}
if (vsDesc.GetSRVDesc(vsDesc.FindSRVDesc("MeshInstanceArray"), ref tbInfo))
{
}
}
//const string CSVersion = "cs_5_0";
var macros = new CShaderDefinitions();
var shaderFile = RName.GetRName("Shaders/Compute/GpuDriven/Cluster.compute", RName.enRNameType.Engine);
mCS_MeshBatchDesc = rc.CreateShaderDesc(shaderFile, "CSMain_MeshBatch", EShaderType.EST_ComputeShader, macros, CIPlatform.Instance.PlatformType);
mCS_MeshBatch = rc.CreateComputeShader(mCS_MeshBatchDesc);
mCS_ClearBatchArgsDesc = rc.CreateShaderDesc(shaderFile, "CSMain_ClearBatchArgs", EShaderType.EST_ComputeShader, macros, CIPlatform.Instance.PlatformType);
mCS_ClearBatchArgs = rc.CreateComputeShader(mCS_ClearBatchArgsDesc);
var cbIndex = mCS_MeshBatchDesc.FindCBufferDesc("cbMeshBatch");
if (cbIndex != uint.MaxValue)
{
mCBMeshBatch = rc.CreateConstantBuffer(mCS_MeshBatchDesc, cbIndex);
}
}
public override void BindResources(CGfxMesh mesh, CPass pass)
{
}
public void BindBuffers(CPass pass)
{
pass.AttachSRVs = mAttachSRVs;
pass.AttachVBs = mAttachVBs;
}
public void ClearLatestPass()
{
mLatestPass = null;
}
public override void BindResources(Graphics.Mesh.CGfxMesh mesh, CPass pass)
{
}
public virtual void OnSetPassData(CPass pass, bool shadow)
{
}
public override void OnSetPassData(CPass pass, bool shadow)
{
ParticleSys.BindParticleVB(pass);
pass.SetInstanceNumber(ParticleSys.ParticleNumber);
mPass = pass;
}
public void CookSpecRenderLayerDataToPass(CRenderContext RHICtx, ERenderLayer RenderLayer, CGfxCamera ViewerCamera, CGfxShadingEnv ShadingEnv, PrebuildPassIndex ppi)
{
ScopeCook2Pass.Begin();
if (ViewerCamera == null || RenderLayer == ERenderLayer.RL_Shadow)
{
return;
}
if (RenderLayer == ERenderLayer.RL_Num)
{
RenderLayer = ERenderLayer.RL_Num - 1;
return;
}
var SpecRenderLayer = ViewerCamera.mSceneRenderLayer[(int)RenderLayer];
int Count = SpecRenderLayer.GetRenderLayerAtomNum();
for (uint idx = 0; idx < Count; idx++)
{
var MtlMesh = SpecRenderLayer.GetMtlMeshFromArray(idx);
if (MtlMesh == null)
{
break;
}
var SceneMesh = MtlMesh.mRootSceneMesh;
if (MtlMesh == null || SceneMesh == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "@Graphic", $"NullPtr here", "");
continue;
}
if (ppi == PrebuildPassIndex.PPI_HitProxy && SceneMesh.mMeshVars.mHitProxyId == 0)
{
continue;
}
if (ppi == PrebuildPassIndex.PPI_PickedEditor)
{
if (SceneMesh.mSelected == false)
{
continue;
}
}
MtlMesh.UpdatePerMtlMeshCBuffer(RHICtx, ViewerCamera);
CPass refPass = MtlMesh.GetPass(ppi);
if (refPass == null)
{
continue;
}
if (false == refPass.PreUse())
{
continue;
}
refPass.OnCookRenderData(ShadingEnv, ppi);
switch (ppi)
{
case PrebuildPassIndex.PPI_PickedEditor:
refPass.BindShaderTextures(MtlMesh);
refPass.ShaderSamplerBinder = MtlMesh.GetSamplerBinder_PickedEditor(RHICtx, refPass.Effect.ShaderProgram);
ShadingEnv.BindResources(SceneMesh, refPass);
break;
case PrebuildPassIndex.PPI_HitProxy:
{
refPass.BindShaderTextures(MtlMesh);
refPass.ShaderSamplerBinder = MtlMesh.GetSamplerBinder_HitProxy(RHICtx, refPass.Effect.ShaderProgram);
ShadingEnv.BindResources(SceneMesh, refPass);
}
break;
case PrebuildPassIndex.PPI_SceneCapture:
case PrebuildPassIndex.PPI_OpaquePbr:
case PrebuildPassIndex.PPI_TransparentPbr:
case PrebuildPassIndex.PPI_CustomTranslucentPbr:
case PrebuildPassIndex.PPI_OpaquePbrEditor:
case PrebuildPassIndex.PPI_CustomTranslucentPbrEditor:
case PrebuildPassIndex.PPI_Gizmos:
case PrebuildPassIndex.PPI_Snapshot:
case PrebuildPassIndex.PPI_Sky:
{
refPass.BindShaderTextures(MtlMesh);
//refPass.ShaderSamplerBinder = MtlMesh.GetSamplerBinder(RHICtx, refPass.Effect.ShaderProgram);
ShadingEnv.BindResources(SceneMesh, refPass);
//var sEnv = refPass.Effect.Desc.EnvShaderPatch;
//sEnv.BindResources(SceneMesh, refPass);
}
break;
default:
break;
}
refPass.ViewPort = Viewport;
#if DEBUG
if (ViewerCamera.CBuffer == null)
{
System.Diagnostics.Debug.Assert(false);
}
#endif
refPass.BindCBuffer(refPass.Effect.ShaderProgram, refPass.Effect.CacheData.CBID_Camera, ViewerCamera.CBuffer);
refPass.BindCBuffer(refPass.Effect.ShaderProgram, refPass.Effect.CacheData.CBID_View, SceneViewCB);
SceneMesh.MdfQueue.OnSetPassData(refPass, false);
SendPassToCorrectRenderLayer(RenderLayer, refPass);
}
ScopeCook2Pass.End();
}
