public async System.Threading.Tasks.Task <bool> Init(CRenderContext rc, CSwapChain SwapChain,
View.CGfxScreenViewDesc ViewInfo, CGfxShadingEnv ShadingEnv, RName MtlInst, string debugName)
{
mCmdList = new CCommandList[2];
EngineNS.CCommandListDesc CmdListDesc = new EngineNS.CCommandListDesc();
mCmdList[0] = rc.CreateCommandList(CmdListDesc);
mCmdList[1] = rc.CreateCommandList(CmdListDesc);
mCmdList[0].DebugName = debugName;
mCmdList[1].DebugName = debugName;
var ScreenAlignedTriangle = CEngine.Instance.MeshPrimitivesManager.GetMeshPrimitives(rc, CEngineDesc.ScreenAlignedTriangleName, true);
mScreenAlignedTriangle = CEngine.Instance.MeshManager.CreateMesh(rc, ScreenAlignedTriangle);
var mtl = await CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(rc, MtlInst);
mScreenAlignedTriangle.SetMaterialInstance(rc, 0,
mtl,
CEngine.Instance.PrebuildPassData.DefaultShadingEnvs);
//await mScreenAlignedTriangle.AwaitEffects();
mShadingEnv = ShadingEnv;
mScreenView = new View.CGfxScreenView();
return(await mScreenView.Init(rc, SwapChain, ViewInfo, ShadingEnv, mtl, mScreenAlignedTriangle));
}
public void CookViewportMeshToPass(CRenderContext RHICtx, CGfxShadingEnv ShaderEnv, CGfxCamera Camera, CGfxMesh ViewportMesh)
{
if (ViewportMesh == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "@Graphic", $"ViewportViewError!!!", "");
System.Diagnostics.Debug.Assert(false);
return;
}
if (mPass == null)
{
System.Diagnostics.Debug.Assert(false);
return;
}
ViewportMesh.MeshPrimitives.PreUse(false);
var refMtlMesh = ViewportMesh.MtlMeshArray[0];
if (refMtlMesh == null)
{
return;
}
mPass.RenderPipeline.RasterizerState = mRasterState;
mPass.RenderPipeline.DepthStencilState = mDepthStencilState;
mPass.RenderPipeline.BlendState = mBlendState;
mPass.BindShaderTextures(refMtlMesh);
//if(mPass.ShaderSamplerBinder==null)
//{
// mPass.ShaderSamplerBinder = new CShaderSamplers();
//}
//refMtlMesh.GetSamplerBinder(RHICtx, mPass.Effect.ShaderProgram, mPass.ShaderSamplerBinder);
//var tempSampler = new CShaderSamplers();
var tempSampler = mCookVPMeshSampler;
refMtlMesh.GetSamplerBinder(RHICtx, mPass.Effect.ShaderProgram, tempSampler);
mPass.ShaderSamplerBinder = tempSampler;
ShaderEnv.BindResources(ViewportMesh, mPass);
mPass.BindGeometry(ViewportMesh.MeshPrimitives, 0, 0);
mPass.ViewPort = mViewport;
mPass.BindCBuffer(mPass.Effect.ShaderProgram, mPass.Effect.CacheData.CBID_Camera, Camera.CBuffer);
mPass.BindCBuffer(mPass.Effect.ShaderProgram, mPass.Effect.CacheData.CBID_View, mScreenViewCB);
mPass.OnCookRenderData(ShaderEnv, PrebuildPassIndex.PPI_Default);
return;
}
public void CookViewportMeshToPassInMultiPassMode(CRenderContext RHICtx, CGfxShadingEnv ShaderEnv, UInt32 ActivePassIndex, CGfxCamera Camera, CGfxMesh ViewportMesh)
{
if (ViewportMesh == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "@Graphic", $"ViewportViewError!!!", "");
System.Diagnostics.Debug.Assert(false);
return;
}
if (ActivePassIndex > mPassArray.Count - 1)
{
System.Diagnostics.Debug.Assert(false);
return;
}
ViewportMesh.MeshPrimitives.PreUse(false);
var refMtlMesh = ViewportMesh.MtlMeshArray[0];
if (refMtlMesh == null)
{
System.Diagnostics.Debug.Assert(false);
return;
}
mPassArray[(int)ActivePassIndex].RenderPipeline.RasterizerState = mRasterState;
mPassArray[(int)ActivePassIndex].RenderPipeline.DepthStencilState = mDepthStencilState;
mPassArray[(int)ActivePassIndex].RenderPipeline.BlendState = mBlendState;
mPassArray[(int)ActivePassIndex].BindShaderTextures(refMtlMesh);
refMtlMesh.GetSamplerBinder(RHICtx, mPassArray[(int)ActivePassIndex].Effect.ShaderProgram, mSampler4Cook);
mPassArray[(int)ActivePassIndex].ShaderSamplerBinder = mSampler4Cook;
ShaderEnv.BindResources(ViewportMesh, mPassArray[(int)ActivePassIndex]);
mPassArray[(int)ActivePassIndex].BindGeometry(ViewportMesh.MeshPrimitives, 0, 0);
mPassArray[(int)ActivePassIndex].ViewPort = mViewport;
mPassArray[(int)ActivePassIndex].BindCBuffer(mPassArray[(int)ActivePassIndex].Effect.ShaderProgram, mPassArray[(int)ActivePassIndex].Effect.CacheData.CBID_Camera, Camera.CBuffer);
mPassArray[(int)ActivePassIndex].BindCBuffer(mPassArray[(int)ActivePassIndex].Effect.ShaderProgram, mPassArray[(int)ActivePassIndex].Effect.CacheData.CBID_View, mScreenViewCB);
return;
}
public async System.Threading.Tasks.Task <bool> Init2(CRenderContext rc, CGfxShadingEnv ShadingEnv, RName MtlInst, View.CGfxScreenView view)
{
mCmdList = new CCommandList[2];
EngineNS.CCommandListDesc CmdListDesc = new EngineNS.CCommandListDesc();
mCmdList[0] = rc.CreateCommandList(CmdListDesc);
mCmdList[1] = rc.CreateCommandList(CmdListDesc);
var ScreenAlignedTriangle = CEngine.Instance.MeshPrimitivesManager.GetMeshPrimitives(rc, CEngineDesc.ScreenAlignedTriangleName, true);
mScreenAlignedTriangle = CEngine.Instance.MeshManager.CreateMesh(rc, ScreenAlignedTriangle);
var mtl = await CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(rc, MtlInst);
mScreenAlignedTriangle.SetMaterialInstance(rc, 0,
mtl,
CEngine.Instance.PrebuildPassData.DefaultShadingEnvs);
mShadingEnv = ShadingEnv;
mScreenView = view;
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 SetRLayerParameter(View.ERenderLayer layer, PrebuildPassIndex passIndex, CGfxShadingEnv shadingEnv)
{
RLayerParameter parameter;
if (mLayerParameter.TryGetValue(layer, out parameter) == false)
{
parameter = new RLayerParameter();
mLayerParameter.Add(layer, parameter);
}
parameter.Layer = layer;
parameter.PassIndex = passIndex;
parameter.ShadingEnv = shadingEnv;
}
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 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();
}
