public async System.Threading.Tasks.Task <bool> Init(Graphics.CGfxMaterialInstance material, float halfWidth = 0.1F)
{
var rc = CEngine.Instance.RenderContext;
Material = material;
GeomMesh = new Graphics.Mesh.CGfxMeshPrimitives();
GeomMesh.Init(rc, null, 1);
CDrawPrimitiveDesc dpDesc = new CDrawPrimitiveDesc();
dpDesc.SetDefault();
dpDesc.StartIndex = 0xFFFFFFFF;
GeomMesh.PushAtomLOD(0, ref dpDesc);
var Mesh = new Graphics.Mesh.CGfxMesh();
Mesh.Init(rc, null, GeomMesh);
var img = new Graphics.Mesh.CGfxImage2D();
Mesh.Tag = img;
UpdateGeomMesh(rc, halfWidth);
GraphActor = GamePlay.Actor.GActor.NewMeshActorDirect(Mesh);
var meshComp = GraphActor.GetComponent <GamePlay.Component.GMeshComponent>();
await meshComp.SetMaterialInstanceAsync(rc, 0, material, null);
//await meshComp.SetMaterial(rc, 0, material, CEngine.Instance.PrebuildPassData.Image2DShadingEnvs, false, true);
return(true);
}
public async System.Threading.Tasks.Task <bool> InitPassForViewportView(CRenderContext RHICtx, Graphics.CGfxShadingEnv shadingEnv, Graphics.CGfxMaterialInstance MtlInst,
Graphics.Mesh.CGfxMesh ViewportMesh)
{
var effect = GetEffect(RHICtx, shadingEnv.EnvCode, MtlInst, ViewportMesh);
if (effect == null)
{
return(false);
}
await effect.AwaitLoad();
if (effect.ShaderProgram == null)
{
return(false);
}
this.ShadingEnv = shadingEnv;
this.Effect = effect;
this.mMtlInst = MtlInst;
this.MtlMesh = ViewportMesh.MtlMeshArray[0];
if (mRenderPipeline == null)
{
var RplDesc = new CRenderPipelineDesc();
RenderPipeline = RHICtx.CreateRenderPipeline(RplDesc);
}
BindCBuffer(effect.ShaderProgram, effect.CacheData.PerInstanceId, ViewportMesh.MtlMeshArray[0].CBuffer);
BindCBuffer(effect.ShaderProgram, effect.CacheData.PerFrameId, CEngine.Instance.PerFrameCBuffer);
this.BindGeometry(ViewportMesh.MeshPrimitives, 0, 0);
PreUse();
return(true);
}
public async System.Threading.Tasks.Task <bool> SetMaterialInstanceAsync(CRenderContext RHICtx, UInt32 index,
Graphics.CGfxMaterialInstance material, CGfxShadingEnv[] envs, bool preUseEffect = false)
{
var ret = SetMaterialInstance(RHICtx, index, material, envs, preUseEffect);
await SceneMesh.AwaitEffects();
return(ret);
}
private Graphics.CGfxEffect GetEffect(CRenderContext RHICtx,
Graphics.GfxEnvShaderCode ShaderEnv,
Graphics.CGfxMaterialInstance mtl,
Graphics.Mesh.CGfxMesh mesh)
{
var desc = Graphics.CGfxEffectDesc.CreateDesc(mtl.Material, mesh.MdfQueue, ShaderEnv);
return(CEngine.Instance.EffectManager.GetEffect(RHICtx, desc));
}
public bool SetMaterialInstance(CRenderContext RHICtx, UInt32 index, Graphics.CGfxMaterialInstance material, CGfxShadingEnv[] envs, bool preUseEffect = false)
{
if (index >= mSceneMesh.MtlMeshArray.Length)
{
return(false);
}
SceneMesh.SetMaterialInstance(RHICtx, index, material, envs, preUseEffect);
return(true);
}
public UInt32 FindTextureIndexPS(Graphics.CGfxMaterialInstance mtl, string name)
{
CTextureBindInfo desc = new CTextureBindInfo();
if (FindTextureBindInfo(mtl, name, ref desc) == false)
{
return(UInt32.MaxValue);
}
return(desc.PSBindPoint);
}
public int GetOrAddMaterialId(Graphics.CGfxMaterialInstance mtl)
{
for (int i = 0; i < mGpuSceneMaterials.Count; i++)
{
if (mGpuSceneMaterials[i] == mtl)
{
return(i);
}
}
mGpuSceneMaterials.Add(mtl);
return(mGpuSceneMaterials.Count - 1);
}
public bool FindSamplerBindInfoByShaderName(Graphics.CGfxMaterialInstance mtl, string name, ref CSamplerBindInfo desc)
{
if (mtl != null)
{
name = "Samp_" + name;
}
var index = SDK_IShaderProgram_GetSamplerBindSlotIndex(CoreObject, name);
if ((int)index < 0)
{
return(false);
}
GetSamplerBindInfo(index, ref desc);
return(true);
}
public bool FindSamplerBindInfo(Graphics.CGfxMaterialInstance mtl, string name, ref CSamplerBindInfo desc)
{
if (mtl != null)
{
name = Graphics.CGfxMaterialManager.GetValidShaderVarName(name, mtl.Material.GetHash64().ToString());
}
var index = SDK_IShaderProgram_GetSamplerBindSlotIndex(CoreObject, name);
if ((int)index < 0)
{
return(false);
}
GetSamplerBindInfo(index, ref desc);
return(true);
}
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);
}
}
