public void Draw(EngineNS.CRenderContext rc, EngineNS.CCommandList cmd, EngineNS.Graphics.View.CGfxScreenView view)
{
if (!mInitialized)
{
return;
}
foreach (var data in mTransformHandles)
{
data?.Show?.Draw(rc, cmd, view);
}
foreach (var data in mCanvasAnchorsHandles)
{
data?.Show?.Draw(rc, cmd, view);
}
}
private void UpdateCBMeshbatch(EngineNS.CCommandList cmd, Graphics.CGfxCamera Camera)
{
var varIdx = mCBMeshBatch.FindVar("ClusterNumber");
mCBMeshBatch.SetValue(varIdx, GpuClusters.Count, 0);
varIdx = mCBMeshBatch.FindVar("MeshBatchVertexStride");
mCBMeshBatch.SetValue(varIdx, AllVertices.Count, 0);
if (Camera != null)
{
unsafe
{
varIdx = mCBMeshBatch.FindVar("GpuDrivenCameraPlanes");
var pPlanes = stackalloc Plane[6];
Camera.CullingFrustum.GetPlanes(pPlanes);
for (uint i = 0; i < 6; i++)
{
mCBMeshBatch.SetValue(varIdx, pPlanes[i], i);
}
varIdx = mCBMeshBatch.FindVar("GpuDrivenCameraPosition");
mCBMeshBatch.SetValue(varIdx, Camera.CullingFrustum.TipPos, 0);
BoundingBox box = new BoundingBox();
Camera.CullingFrustum.GetBoundBox(ref box);
varIdx = mCBMeshBatch.FindVar("GpuDrivenFrustumMinPoint");
mCBMeshBatch.SetValue(varIdx, box.Minimum, 0);
varIdx = mCBMeshBatch.FindVar("GpuDrivenFrustumMaxPoint");
mCBMeshBatch.SetValue(varIdx, box.Maximum, 0);
varIdx = mCBMeshBatch.FindVar("EnableGpuCulling");
mCBMeshBatch.SetValue(varIdx, (uint)(1), 0);
}
}
else
{
varIdx = mCBMeshBatch.FindVar("EnableGpuCulling");
mCBMeshBatch.SetValue(varIdx, (uint)(0), 0);
}
}
public static void CaptureGeoBox(EngineNS.Bricks.HollowMaker.Agent.GeoBox geoBox,
EngineNS.Bricks.HollowMaker.GeomScene.AgentBoxs agentData,
EngineNS.Graphics.CGfxCamera camera,
EngineNS.CRenderContext rc,
UInt32 numElem,
EngineNS.Graphics.RenderPolicy.CGfxRP_SceneCapture rp,
EngineNS.CCommandList cmd,
UInt32 cbIndex,
EngineNS.CConstantBuffer cbuffer,
EngineNS.CGpuBuffer buffer_visible,
EngineNS.CShaderDesc csMain_visible,
EngineNS.CComputeShader cs_visible,
EngineNS.CUnorderedAccessView uav_visible,
EngineNS.CGpuBuffer buffer_setBit,
EngineNS.CShaderDesc csMain_setBit,
EngineNS.CComputeShader cs_setBit,
EngineNS.CUnorderedAccessView uav_setBit,
EngineNS.CComputeShader cs_Clear,
List <EngineNS.Support.BitSet> savedBitsets,
UInt32 textureIdx,
Action <int, EngineNS.Support.CBlobObject, EngineNS.Support.CBlobObject> actionAfterCapturePerDir)
{
var cornerPos = geoBox.Box.GetCorners();
//for(int posIdx = 0; posIdx < cornerPos.Length; posIdx++)
//{
// await CaptureSceneWithPoint(cornerPos[posIdx], world, camera, rc, camDirs, camUps, dataBlobs, picBlobs);
//}
cmd.SetComputeShader(cs_visible);
UInt32[] pUAVInitialCounts = new UInt32[1] {
1,
};
cmd.CSSetUnorderedAccessView(0, uav_visible, pUAVInitialCounts);
//await CaptureSceneWithPoint(geoBox.Box.GetCenter(), agentData.Mat , camera, rc, camDirs, camUps, numElem/*, dataBlobs, picBlobs*/);
for (int camIdx = 0; camIdx < 6; camIdx++)
{
EngineNS.Support.CBlobObject idBlob = null;
EngineNS.Support.CBlobObject picBlob = null;
EditorCommon.PVSAssist.CaptureWithPoint(geoBox.Box.GetCenter(), agentData.Mat, camera, rc, camDirs[camIdx], camUps[camIdx], numElem, rp, textureIdx, ref idBlob, ref picBlob);
actionAfterCapturePerDir?.Invoke(camIdx, idBlob, picBlob);
}
// gbuffer0
var blob = new EngineNS.Support.CBlobObject();
buffer_visible.GetBufferData(rc, blob);
var idArray = blob.ToUInts();
// fill uav1, clear uav0
cmd.SetComputeShader(cs_setBit);
UInt32[] pUAVInitialCounts1 = new UInt32[1] {
1,
};
cmd.CSSetUnorderedAccessView(0, uav_visible, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(1, uav_setBit, pUAVInitialCounts);
var cbDesc = new EngineNS.CConstantBufferDesc();
if (csMain_setBit.GetCBufferDesc(cbIndex, ref cbDesc))
{
if (cbDesc.Type == EngineNS.ECBufferRhiType.SIT_CBUFFER)
{
cmd.CSSetConstantBuffer(cbDesc.CSBindPoint, cbuffer);
}
}
cmd.CSDispatch(numElem, 1, 1);
var blob0 = new EngineNS.Support.CBlobObject();
buffer_visible.GetBufferData(rc, blob0);
var visArray = blob0.ToUInts();
// gbuffer1
var blob1 = new EngineNS.Support.CBlobObject();
buffer_setBit.GetBufferData(rc, blob1);
var idArray1 = blob1.ToBytes();
var bitSet = new EngineNS.Support.BitSet();
var bitSet1 = new EngineNS.Support.BitSet();
bitSet.Init(numElem * 2, idArray1);
bitSet1.Init(numElem);
for (UInt32 e = 0; e < numElem; e++)
{
var bit1 = bitSet.IsBit(e * 2 + 0);
var bit2 = bitSet.IsBit(e * 2 + 1);
bitSet1.SetBit(e, bit1 || bit2);
}
savedBitsets.Add(bitSet1);
cmd.SetComputeShader(cs_Clear);
cmd.CSSetUnorderedAccessView(0, uav_visible, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(1, uav_setBit, pUAVInitialCounts);
cmd.CSDispatch(numElem / 16 + 1, 1, 1);
}
public unsafe void UpdateGpuBufferVTF(CRenderContext rc, EngineNS.CCommandList cmd, Graphics.CGfxCamera Camera)
{
CTexture2DDesc desc = new CTexture2DDesc();
desc.Init();
var spDesc = new CSamplerStateDesc();
spDesc.SetDefault();
spDesc.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_POINT;
mSamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(rc, spDesc);
int vertStride = sizeof(Cluster.GpuSceneVertex);
int size = mAllVertices.Count * vertStride;
int side = (int)Math.Sqrt((float)size) + 1;
desc.Width = 512;
desc.Height = 512;
desc.MipLevels = 1;
desc.Format = EPixelFormat.PXF_R32G32B32A32_FLOAT;
mVertexTexture = rc.CreateTexture2D(desc);
CShaderResourceViewDesc srvDesc = new CShaderResourceViewDesc();
srvDesc.mFormat = desc.Format;
srvDesc.mTexture2D = mVertexTexture.CoreObject;
mVertexTextureView = rc.CreateShaderResourceView(srvDesc);
mVertexTextureView.ResourceState.StreamState = EStreamingState.SS_Valid;
{
var copyArray = mAllVertices.ToArray();
fixed(Vector4 *p = &mVertexTexData[0])
fixed(Cluster.GpuSceneVertex * v = ©Array[0])
{
CoreSDK.SDK_Memory_Copy(p, v, (uint)size);
mVertexTexture.UpdateMipData(cmd, 0, p, 512, 512, 512 * 4 * 4);
}
}
int InstStride = sizeof(GpuMeshInstanceData);
size = mGpuInstanceDatas.Count * InstStride;
side = (int)Math.Sqrt((float)size) + 1;
desc.Width = 256;
desc.Height = 256;
desc.MipLevels = 1;
desc.Format = EPixelFormat.PXF_R32G32B32A32_FLOAT;
mInstanceDataTexture = rc.CreateTexture2D(desc);
srvDesc.mFormat = desc.Format;
srvDesc.mTexture2D = mInstanceDataTexture.CoreObject;
mInstanceDataTextureView = rc.CreateShaderResourceView(srvDesc);
mInstanceDataTextureView.ResourceState.StreamState = EStreamingState.SS_Valid;
{
var copyArray = mGpuInstanceDatas.ToArray();
fixed(Vector4 *p = &mInstTexData[0])
fixed(GpuMeshInstanceData * v = ©Array[0])
{
CoreSDK.SDK_Memory_Copy(p, v, (uint)size);
mInstanceDataTexture.UpdateMipData(cmd, 0, p, 256, 256, 256 * 4 * 4);
}
}
}
public void ComputeDispatch(CRenderContext rc, EngineNS.CCommandList cmd, Graphics.CGfxCamera Camera)
{
if (mCS_ClearBatchArgs == null)
{
return;
}
UInt32[] pUAVInitialCounts = new UInt32[1] {
1,
};
{
cmd.SetComputeShader(mCS_ClearBatchArgs);
//if (mCS_ClearBatchArgsDesc.GetCBufferDesc("IndirectDrawArgs", ref cbDesc))
// cmd.CSSetUnorderedAccessView(cbDesc.CSBindPoint, uavIndirectDrawArgs, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(5, uavIndirectDrawArgs, pUAVInitialCounts);
cmd.CSDispatch(1, 1, 1);
cmd.CSSetUnorderedAccessView(5, null, pUAVInitialCounts);
}
cmd.SetComputeShader(mCS_MeshBatch);
//if (mCS_MeshBatchDesc.GetCBufferDesc("MeshInstanceArray", ref cbDesc))
// cmd.CSSetUnorderedAccessView(cbDesc.CSBindPoint, uavMeshInstanceArray, pUAVInitialCounts);
//if (mCS_MeshBatchDesc.GetCBufferDesc("ClusterArray", ref cbDesc))
// cmd.CSSetUnorderedAccessView(cbDesc.CSBindPoint, uavClusterArray, pUAVInitialCounts);
//if (mCS_MeshBatchDesc.GetCBufferDesc("StaticSceneAllFaces", ref cbDesc))
// cmd.CSSetUnorderedAccessView(cbDesc.CSBindPoint, uavStaticSceneAllFaces, pUAVInitialCounts);
//if (mCS_MeshBatchDesc.GetCBufferDesc("StaticSceneDrawFaces", ref cbDesc))
// cmd.CSSetUnorderedAccessView(cbDesc.CSBindPoint, uavStaticSceneDrawFaces, pUAVInitialCounts);
//if (mCS_MeshBatchDesc.GetCBufferDesc("IndirectDrawArgs", ref cbDesc))
// cmd.CSSetUnorderedAccessView(cbDesc.CSBindPoint, uavIndirectDrawArgs, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(1, uavMeshInstanceArray, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(2, uavClusterArray, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(3, uavStaticSceneAllFaces, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(4, uavStaticSceneDrawFaces, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(5, uavIndirectDrawArgs, pUAVInitialCounts);
UpdateCBMeshbatch(cmd, Camera);
mCBMeshBatch.FlushContent(cmd);
var cbIndex = mCS_MeshBatchDesc.FindCBufferDesc("cbMeshBatch");
var tmpDesc = new EngineNS.CConstantBufferDesc();
if (mCS_MeshBatchDesc.GetCBufferDesc(cbIndex, ref tmpDesc))
{
if (tmpDesc.Type == EngineNS.ECBufferRhiType.SIT_CBUFFER)
{
cmd.CSSetConstantBuffer(tmpDesc.CSBindPoint, mCBMeshBatch);
}
}
cmd.CSDispatch((uint)((GpuClusters.Count + 63) / 64), 1, 1);
cmd.CSSetUnorderedAccessView(1, null, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(2, null, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(3, null, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(4, null, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(5, null, pUAVInitialCounts);
cmd.SetComputeShader(null);
//unsafe
//{
// CEngine.Instance.EventPoster.RunOn(() =>
// {
// var blobDrawArgs = new EngineNS.Support.CBlobObject();
// bufferIndirectDrawArgs.GetBufferData(rc, blobDrawArgs);
// EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs* pArg = (EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs*)blobDrawArgs.Data.ToPointer();
// if (pArg != null)
// {
// mDrawArgs = *pArg;
// }
// return null;
// }, Thread.Async.EAsyncTarget.Main);
//}
}
public unsafe void UpdateGpuBuffer(CRenderContext rc, EngineNS.CCommandList cmd, Graphics.CGfxCamera Camera)
{
if (UseVTF)
{
UpdateGpuBufferVTF(rc, cmd, Camera);
}
else
{
var bfDesc = new CGpuBufferDesc();
//mAllVertexSRV
{
bfDesc.SetMode(false, false);
bfDesc.ByteWidth = (uint)(mAllVertices.Count * sizeof(EngineNS.Bricks.GpuDriven.Cluster.GpuSceneVertex));
bfDesc.StructureByteStride = (uint)sizeof(EngineNS.Bricks.GpuDriven.Cluster.GpuSceneVertex);
var copyArray = mAllVertices.ToArray();
fixed(EngineNS.Bricks.GpuDriven.Cluster.GpuSceneVertex *p = ©Array[0])
{
bufferAllVertex = rc.CreateGpuBuffer(bfDesc, (IntPtr)p);
}
var srvDesc = new ISRVDesc();
srvDesc.ToDefault();
srvDesc.ViewDimension = EResourceDimension.RESOURCE_DIMENSION_BUFFER;
srvDesc.Buffer.ElementOffset = 0;
srvDesc.Buffer.NumElements = (uint)mAllVertices.Count;
mAllVertexSRV = rc.CreateShaderResourceViewFromBuffer(bufferAllVertex, srvDesc);
}
//uavMeshInstanceArray
{
bfDesc.SetMode(false, true);
bfDesc.ByteWidth = (uint)(GpuInstanceDatas.Count * sizeof(EngineNS.Bricks.GpuDriven.GpuScene.GpuMeshInstanceData));
bfDesc.StructureByteStride = (uint)sizeof(EngineNS.Bricks.GpuDriven.GpuScene.GpuMeshInstanceData);
var copyArray = GpuInstanceDatas.ToArray();
fixed(EngineNS.Bricks.GpuDriven.GpuScene.GpuMeshInstanceData *p = ©Array[0])
{
bufferMeshInstanceArray = rc.CreateGpuBuffer(bfDesc, (IntPtr)p);
//bufferMeshInstanceArray.UpdateBufferData(cmd, (IntPtr)p, bfDesc.ByteWidth);
}
var uavDesc = new CUnorderedAccessViewDesc();
uavDesc.ToDefault();
uavDesc.Buffer.NumElements = (uint)GpuInstanceDatas.Count;
uavMeshInstanceArray = rc.CreateUnorderedAccessView(bufferMeshInstanceArray, uavDesc);
var srvDesc = new ISRVDesc();
srvDesc.ToDefault();
srvDesc.ViewDimension = EResourceDimension.RESOURCE_DIMENSION_BUFFER;
srvDesc.Buffer.ElementOffset = 0;
srvDesc.Buffer.NumElements = (uint)GpuInstanceDatas.Count;
mMeshInstanceSRV = rc.CreateShaderResourceViewFromBuffer(bufferMeshInstanceArray, srvDesc);
}
}
if (UseComputeShader)
{
var bfDesc = new CGpuBufferDesc();
if (uavMeshInstanceArray == null)
{
bfDesc.SetMode(false, true);
bfDesc.ByteWidth = (uint)(GpuInstanceDatas.Count * sizeof(EngineNS.Bricks.GpuDriven.GpuScene.GpuMeshInstanceData));
bfDesc.StructureByteStride = (uint)sizeof(EngineNS.Bricks.GpuDriven.GpuScene.GpuMeshInstanceData);
var copyArray = GpuInstanceDatas.ToArray();
fixed(EngineNS.Bricks.GpuDriven.GpuScene.GpuMeshInstanceData *p = ©Array[0])
{
bufferMeshInstanceArray = rc.CreateGpuBuffer(bfDesc, (IntPtr)p);
//bufferMeshInstanceArray.UpdateBufferData(cmd, (IntPtr)p, bfDesc.ByteWidth);
}
var uavDesc = new CUnorderedAccessViewDesc();
uavDesc.ToDefault();
uavDesc.Buffer.NumElements = (uint)GpuInstanceDatas.Count;
uavMeshInstanceArray = rc.CreateUnorderedAccessView(bufferMeshInstanceArray, uavDesc);
var srvDesc = new ISRVDesc();
srvDesc.ToDefault();
srvDesc.ViewDimension = EResourceDimension.RESOURCE_DIMENSION_BUFFER;
srvDesc.Buffer.ElementOffset = 0;
srvDesc.Buffer.NumElements = (uint)GpuInstanceDatas.Count;
mMeshInstanceSRV = rc.CreateShaderResourceViewFromBuffer(bufferMeshInstanceArray, srvDesc);
}
//uavClusterArray
{
bfDesc.SetMode(false, true);
bfDesc.ByteWidth = (uint)(GpuClusters.Count * sizeof(EngineNS.Bricks.GpuDriven.Cluster.GpuCluster));
bfDesc.StructureByteStride = (uint)sizeof(EngineNS.Bricks.GpuDriven.Cluster.GpuCluster);
var copyArray = GpuClusters.ToArray();
fixed(EngineNS.Bricks.GpuDriven.Cluster.GpuCluster *p = ©Array[0])
{
bufferClusterArray = rc.CreateGpuBuffer(bfDesc, (IntPtr)p);
//bufferClusterArray.UpdateBufferData(cmd, (IntPtr)p, bfDesc.ByteWidth);
}
var uavDesc = new CUnorderedAccessViewDesc();
uavDesc.ToDefault();
uavDesc.Buffer.NumElements = (uint)GpuClusters.Count;
uavClusterArray = rc.CreateUnorderedAccessView(bufferClusterArray, uavDesc);
}
//uavStaticSceneAllFaces
{
bfDesc.SetMode(false, true);
bfDesc.ByteWidth = (uint)(AllIndices.Count * sizeof(uint));
bfDesc.StructureByteStride = (uint)sizeof(uint);
var copyArray = AllIndices.ToArray();
fixed(uint *p = ©Array[0])
{
bufferStaticSceneAllFaces = rc.CreateGpuBuffer(bfDesc, (IntPtr)p);
//bufferStaticSceneAllFaces.UpdateBufferData(cmd, (IntPtr)p, bfDesc.ByteWidth);
}
var uavDesc = new CUnorderedAccessViewDesc();
uavDesc.ToDefault();
uavDesc.Buffer.NumElements = (uint)(AllIndices.Count);
uavStaticSceneAllFaces = rc.CreateUnorderedAccessView(bufferStaticSceneAllFaces, uavDesc);
}
//uavStaticSceneDrawFaces
{
bfDesc.SetMode(false, true);
int MaxInstanceNumber = 20;
bfDesc.ByteWidth = (uint)(AllIndices.Count * MaxInstanceNumber * sizeof(uint));
bfDesc.StructureByteStride = (uint)sizeof(uint);
bfDesc.MiscFlags = (UInt32)EResourceMiscFlag.BUFFER_ALLOW_RAW_VIEWS;
bfDesc.BindFlags |= (UInt32)EBindFlag.INDEX_BUFFER;
bfDesc.CPUAccessFlags = 0;
bufferStaticSceneDrawFaces = rc.CreateGpuBuffer(bfDesc, IntPtr.Zero);
var uavDesc = new CUnorderedAccessViewDesc();
uavDesc.ToDefault();
uavDesc.Format = EPixelFormat.PXF_R32_TYPELESS;
uavDesc.Buffer.NumElements = (uint)(AllIndices.Count * MaxInstanceNumber);
uavDesc.Buffer.Flags = (UInt32)EUAVBufferFlag.UAV_FLAG_RAW;
uavStaticSceneDrawFaces = rc.CreateUnorderedAccessView(bufferStaticSceneDrawFaces, uavDesc);
var ibDesc = new CIndexBufferDesc();
ibDesc.CPUAccess = 0;
ibDesc.InitData = IntPtr.Zero;
ibDesc.ByteWidth = bfDesc.ByteWidth;
ibDesc.Type = EIndexBufferType.IBT_Int32;
mDrawIndexBuffer = rc.CreateIndexBufferFromBuffer(ibDesc, bufferStaticSceneDrawFaces);
}
//uavIndirectDrawArgs
{
bfDesc.SetMode(false, true);
bfDesc.ByteWidth = 20; //(uint)(1 * sizeof(EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs));
bfDesc.StructureByteStride = 4; //(uint)sizeof(EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs);
bfDesc.MiscFlags = (UInt32)(EResourceMiscFlag.DRAWINDIRECT_ARGS | EResourceMiscFlag.BUFFER_ALLOW_RAW_VIEWS);
bfDesc.CPUAccessFlags = 0;
bufferIndirectDrawArgs = rc.CreateGpuBuffer(bfDesc, IntPtr.Zero);
var uavDesc = new CUnorderedAccessViewDesc();
uavDesc.ToDefault();
uavDesc.Format = EPixelFormat.PXF_R32_TYPELESS;
uavDesc.Buffer.NumElements = (uint)(5);
uavDesc.Buffer.Flags = (UInt32)EUAVBufferFlag.UAV_FLAG_RAW;
uavIndirectDrawArgs = rc.CreateUnorderedAccessView(bufferIndirectDrawArgs, uavDesc);
var drawAgrs = new EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs();
drawAgrs.InstanceCount = 1;
drawAgrs.StartInstanceLocation = 0;
drawAgrs.IndexCountPerInstance = 0;
bufferIndirectDrawArgs.UpdateBufferData(cmd, (IntPtr)(&drawAgrs), bfDesc.ByteWidth);
}
ComputeDispatch(rc, cmd, Camera);
}
else
{
CIndexBufferDesc ibDesc = new CIndexBufferDesc(EIndexBufferType.IBT_Int32);
ibDesc.CPUAccess = (UInt32)ECpuAccess.CAS_WRITE;
ibDesc.ByteWidth = (uint)(mAllIndices.Count * sizeof(UInt32) * 20);
mCpuDrawIndexBuffer = rc.CreateIndexBuffer(ibDesc);
}
//CEngine.Instance.EventPoster.RunOn(() =>
//{
// var blobDrawArgs = new EngineNS.Support.CBlobObject();
// bufferIndirectDrawArgs.GetBufferData(rc, blobDrawArgs);
// EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs* pArg = (EngineNS.Bricks.GpuDriven.GpuScene.GpuDrawArgs*)blobDrawArgs.Data.ToPointer();
// if (pArg != null)
// {
// mDrawArgs = *pArg;
// }
// return null;
//}, Thread.Async.EAsyncTarget.Main);
}
