public override void CommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
{
if (EngineNS.CIPlatform.Instance.PlayMode == CIPlatform.enPlayMode.Editor)
{
mLineMeshComponent?.CommitVisual(cmd, camera, param);
}
}
partial void CheckVisible_Editor(CCommandList cmd, Graphics.CGfxCamera camera, SceneGraph.CheckVisibleParam param)
{
foreach (var i in EditorActors.Values)
{
i.OnCheckVisible(cmd, null, camera, param);
}
}
public override void CommitVisual(CRenderContext rc, Graphics.CGfxCamera camera)
{
if (EngineNS.CIPlatform.Instance.PlayMode == CIPlatform.enPlayMode.Editor)
{
mLineMeshComponent?.CommitVisual(rc, camera);
}
}
public override void _OnEditorCommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
{
if (CEngine.PhysicsDebug == false)
{
return;
}
if (mDebugActor == null && mReady == false)
{
mReady = true;
var test = CreateDefaultCapsule();
test = SetMaterial();
}
if (mDebugActor != null)
{
float r = 0.5f;
float halfHeight = 0.5f;
HostShape.IfGetCapsule(ref r, ref halfHeight);
var trans = Placement.Transform * SocketMatrix * HostPlaceable.Placement.WorldMatrix;
//mDebugActor.Placement.Location = RigidBody.Position;
Vector3 scale, loc;//mDebugActor.Placement.Scale;
Quaternion rotate;
trans.Decompose(out scale, out rotate, out loc);
var y = (r + halfHeight) * 2;
scale.SetValue(scale.X * r * 2, scale.Y * y, scale.Z * r * 2);
mDebugActor.Placement.Scale = scale;
}
}
public override void CommitVisual(CCommandList cmd, Graphics.CGfxCamera Camera, SceneGraph.CheckVisibleParam param)
{
for (int i = 0; i < Components.Count; ++i)
{
var comp = Components[i];
comp.CommitVisual(cmd, Camera, param);
}
base.CommitVisual(cmd, Camera, param);
}
public override void OnEditorCommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
{
for (int i = 0; i < Components.Count; ++i)
{
var comp = Components[i];
comp.OnEditorCommitVisual(cmd, camera, param);
}
base.OnEditorCommitVisual(cmd, camera, param);
}
public void SlowDrawAll(CCommandList cmd, Graphics.CGfxCamera camera, SceneGraph.CheckVisibleParam param)
{
var it = Scenes.Values.GetEnumerator();
while (it.MoveNext())
{
it.Current.SlowDrawAll(cmd, camera, param);
}
it.Dispose();
}
partial void OnEditorCheckVisible(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
{
if (CIPlatform.Instance.PlayMode == CIPlatform.enPlayMode.Game)
{
return;
}
for (int i = 0; i < Components.Count; ++i)
{
Components[i].OnEditorCommitVisual(cmd, camera, param);
}
}
public void SetCamera(Graphics.CGfxCamera camera, float dist, Vector3 offset)
{
Camera = camera;
LookDist = dist;
Offset = offset;
if (camera != null || Host == null)
{
EyeTarget = GetLookAt() - camera.CameraData.Direction * dist;
Camera.LookAtLH(EyeTarget, GetLookAt(), Vector3.UnitY);
}
}
private void CheckVisibleForShadow(CCommandList cmd, Graphics.CGfxCamera camera)
{
var it = Scenes.Values.GetEnumerator();
while (it.MoveNext())
{
mCheckVisibleParam.Reset();
mCheckVisibleParam.FrustumCulling = false;
mCheckVisibleParam.ForShadow = true;
mCheckVisibleParam.mShadowCullDistance = camera.mShadowDistance;
it.Current.CheckVisible(cmd, camera, mCheckVisibleParam, true);
}
it.Dispose();
mCheckVisibleParam.SerialID++;
}
public void Commit(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param, EPoolType poolType)
{
switch (poolType)
{
case EPoolType.Normal:
{
using (var i = Meshes.Values.GetEnumerator())
{
while (i.MoveNext())
{
if (i.Current.CurSize == 0)
{
continue;
}
i.Current.MeshComp.CommitVisual(cmd, camera, param);
i.Current.Flush2VB(cmd);
}
}
}
break;
case EPoolType.Shadow:
{
using (var i = ShadowMeshes.Values.GetEnumerator())
{
while (i.MoveNext())
{
if (i.Current.CurSize == 0)
{
continue;
}
i.Current.MeshComp.CommitVisual(cmd, camera, param);
i.Current.Flush2VB(cmd);
}
}
}
break;
}
}
public void GetContainVertices(Rectangle rect, Graphics.CGfxCamera camera, List <int> verts, bool cullback = true)
{
//verts.Clear();
for (int i = 0; i < Vertices.Count; i++)
{
var cur = Vertices[i];
if (GetValidLinkFace(i) == 0)
{
continue;
}
var screenPos = camera.CameraData.Trans2ViewPort(ref cur.Position);
if (rect.Contains((int)screenPos.X, (int)screenPos.Y))
{
var viewNorm = Vector3.TransformNormal(cur.Normal, camera.CameraData.ViewMatrix);
if (viewNorm.Z <= 0 || cullback == false)
{
verts.Add(i);
}
}
}
}
public void SetCameraByActor(GActor actor)
{
if (actor == null)
{
return;
}
var cameraComp = actor.GetComponentRecursion <GamePlay.Camera.CameraComponent>();
if (cameraComp != null)
{
GameCamera = cameraComp.Camera;
return;
}
var camera = actor.GetComponentRecursion <GamePlay.Camera.GCameraComponent>();
if (camera != null)
{
GameCamera = camera.Camera.Camera;
return;
}
}
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 void CheckVisible(CCommandList cmd, Graphics.CGfxCamera camera)
{
ScopeCheckVisible.Begin();
var it = Scenes.Values.GetEnumerator();
while (it.MoveNext())
{
mCheckVisibleParam.Reset();
mCheckVisibleParam.FrustumCulling = true;
it.Current.CheckVisible(cmd, camera, mCheckVisibleParam, true);
}
it.Dispose();
CheckVisible_Editor(cmd, camera, mCheckVisibleParam);
mCheckVisibleParam.SerialID++;
if (CEngine.EnableShadow)
{
CheckVisibleForShadow(cmd, camera);
}
camera.SceneView?.UpdatePointLights(this.mDefaultScene);
ScopeCheckVisible.End();
}
public Actor.GActor PickActor(out VHitResult hitResult, Graphics.CGfxCamera camera, int x, int y, float length = 1000.0f)
{
if (camera == null)
{
camera = CEngine.Instance.GameInstance?.GameCamera;
}
if (camera == null)
{
hitResult = VHitResult.Default;
return(null);
}
var pickDir = new Vector3();
if (camera.GetPickRay(ref pickDir, x, y, 0, 0) == false)
{
hitResult = VHitResult.Default;
return(null);
}
var start = camera.CameraData.Position;
var end = camera.CameraData.Position + pickDir * length;
var tmp = VHitResult.Default;
Bricks.PhysicsCore.PhyFilterData filterData = new Bricks.PhysicsCore.PhyFilterData();
filterData.word1 = (uint)Bricks.PhysicsCore.CollisionComponent.CollisionLayers.Camera;
Bricks.PhysicsCore.PhyQueryFilterData queryFilterData = new Bricks.PhysicsCore.PhyQueryFilterData(filterData);
if (this.LineCheckWithFilter(ref start, ref end, ref queryFilterData, ref tmp) == false)
{
hitResult = VHitResult.Default;
return(null);
}
hitResult = tmp;
Actor.GActor outActor = null;
GetHitActorByPhysics(ref hitResult, ref outActor);
return(outActor);
}
private unsafe void UpdateIndexBufferCPU(CCommandList cmd, Graphics.CGfxCamera Camera)
{
if (mCpuDrawIndexBuffer == null)
{
return;
}
CBMeshBatch cbMesh = new CBMeshBatch();
{
var pPlanes = stackalloc Plane[6];
Camera.CullingFrustum.GetPlanes(pPlanes);
CBMeshBatch *pCBuffer = &cbMesh;
Plane * planesTar = (Plane *)pCBuffer;
for (uint i = 0; i < 6; i++)
{
planesTar[i] = pPlanes[i];
}
cbMesh.GpuDrivenCameraPosition = Camera.CullingFrustum.TipPos;
BoundingBox box = new BoundingBox();
Camera.CullingFrustum.GetBoundBox(ref box);
cbMesh.GpuDrivenFrustumMinPoint = box.Minimum;
cbMesh.GpuDrivenFrustumMaxPoint = box.Maximum;
cbMesh.MeshBatchVertexStride = (uint)AllVertices.Count;
cbMesh.ClusterNumber = (uint)GpuClusters.Count;
UpdateCBMeshbatch(cmd, Camera);
}
UInt32_3 tri = new UInt32_3();
mDrawIndices.Clear();
for (int i = 0; i < GpuClusters.Count; i++)
{
var cluster = GpuClusters[i];
var GpuDrivenCameraDirection = GpuClusters[i].BoundCenter - cbMesh.GpuDrivenCameraPosition;
var cameraDirInBoundSpace = Vector3.TransposeTransformNormal(GpuDrivenCameraDirection, GpuInstanceDatas[(int)cluster.InstanceId].InvMatrix);
if (FrustumCull(ref cluster, ref cbMesh) == false)
{
UInt64 visBits = 0;
if (cameraDirInBoundSpace.X >= 0)
{
visBits |= cluster.CubeFaces[(int)Cluster.GpuCluster.ECubeFace.CubeFace_NX];
}
else
{
visBits |= cluster.CubeFaces[(int)Cluster.GpuCluster.ECubeFace.CubeFace_X];
}
if (cameraDirInBoundSpace.Y >= 0)
{
visBits |= cluster.CubeFaces[(int)Cluster.GpuCluster.ECubeFace.CubeFace_NY];
}
else
{
visBits |= cluster.CubeFaces[(int)Cluster.GpuCluster.ECubeFace.CubeFace_Y];
}
if (cameraDirInBoundSpace.Z >= 0)
{
visBits |= cluster.CubeFaces[(int)Cluster.GpuCluster.ECubeFace.CubeFace_NZ];
}
else
{
visBits |= cluster.CubeFaces[(int)Cluster.GpuCluster.ECubeFace.CubeFace_Z];
}
uint InstanceStartIndex = cbMesh.MeshBatchVertexStride * cluster.InstanceId;
for (int j = 0; j < cluster.FaceCount; j++)
{
if (TestBit(visBits, j) == false)
{
continue;
}
int srcIndex = (int)(cluster.StartFaceIndex + j) * 3;
tri.x = InstanceStartIndex + AllIndices[srcIndex];
tri.y = InstanceStartIndex + AllIndices[srcIndex + 1];
tri.z = InstanceStartIndex + AllIndices[srcIndex + 2];
mDrawIndices.Add(tri);
}
}
}
mDrawArgs.InstanceCount = 1;
mDrawArgs.IndexCountPerInstance = (uint)mDrawIndices.Count * 3;
uint size = (uint)(mDrawIndices.Count * sizeof(UInt32_3));
if (mCpuDrawIndexBuffer.Desc.ByteWidth > size)
{
mCpuDrawIndexBuffer.UpdateBuffData(cmd, mDrawIndices.GetBufferPtr(), size);
}
}
public static void Face2Cameral(ref CGfxParticlePose pose, Graphics.CGfxCamera camera)
{
}
public void OnEditorCommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.Actor.GActor hostactor, GamePlay.SceneGraph.CheckVisibleParam param)
{
if (hostactor == null || !hostactor.Visible)
{
return;
}
var rc = CEngine.Instance.RenderContext;
switch (ShapeType)
{
case EPhysShapeType.PST_Convex:
{
if (mDebugActor == null)
{
Graphics.Mesh.CGfxMeshPrimitives mp = IfGetConvexMesh(rc);
mDebugActor = EngineNS.GamePlay.Actor.GActor.NewMeshActorDirect(CEngine.Instance.MeshManager.CreateMesh(rc, mp));
EngineNS.Thread.Async.TaskLoader.Release(ref WaitContext, null);
var test = SetMaterial();
}
mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
}
break;
case EPhysShapeType.PST_TriangleMesh:
{
if (mDebugActor == null)
{
Graphics.Mesh.CGfxMeshPrimitives mp = IfGetTriMesh(rc);
CEngine.Instance.MeshManager.CreateMesh(rc, mp);
EngineNS.Thread.Async.TaskLoader.Release(ref WaitContext, null);
mDebugActor = EngineNS.GamePlay.Actor.GActor.NewMeshActorDirect(CEngine.Instance.MeshManager.CreateMesh(rc, mp));
var test = SetMaterial();
}
mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
}
break;
case EPhysShapeType.PST_Box:
{
if (mDebugActor == null && mReady == false)
{
mReady = true;
var test = CreateDefaultBox();
test = SetMaterial();
}
if (mDebugActor != null)
{
float w = 1.0f;
float h = 1.0f;
float l = 1.0f;
SDK_PhyShape_IfGetBox(ref w, ref h, ref l);
mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
Vector3 scale = Vector3.UnitXYZ; //mDebugActor.Placement.Scale;
scale.SetValue(scale.X * w, scale.Y * h, scale.Z * l);
mDebugActor.Placement.Scale = scale;
}
}
break;
case EPhysShapeType.PST_Sphere:
{
if (mDebugActor == null && mReady == false)
{
mReady = true;
var test = CreateDefaultSphere();
test = SetMaterial();
}
if (mDebugActor != null)
{
float r = 1.0f;
IfGetSphere(ref r);
mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
Vector3 scale = Vector3.UnitXYZ; //mDebugActor.Placement.Scale;
scale.SetValue(scale.X * r, scale.Y * r, scale.Z * r);
mDebugActor.Placement.Scale = scale;
}
}
break;
default:
break;
}
if (mDebugActor != null)
{
foreach (var comp in mDebugActor.Components)
{
var meshComp = comp as EngineNS.GamePlay.Component.GVisualComponent;
if (meshComp != null)
{
meshComp.CommitVisual(cmd, camera, param);
}
}
}
}
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);
}
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 DrawScene(CRenderContext rc, CCommandList cmd, Graphics.CGfxCamera Camera, Graphics.View.CGfxSceneView view)
{
if (EnableDraw == false)
{
return;
}
if (mNeedUpdateGpuBuffer)
{
mNeedUpdateGpuBuffer = false;
UpdateGpuBuffer(rc, cmd, Camera);
}
var program = mPass.Effect.ShaderProgram;
if (UseComputeShader == false)
{
UpdateIndexBufferCPU(cmd, Camera);
}
else
{
ComputeDispatch(rc, cmd, Camera);
}
if (UseVTF)
{
CTextureBindInfo tbInfo = new CTextureBindInfo();
if (program.FindTextureBindInfo(null, "gVertexTexture", ref tbInfo))
{
mPass.ShaderResources.VSBindTexture(tbInfo.VSBindPoint, mVertexTextureView);
}
if (program.FindTextureBindInfo(null, "gInstanceDataTexture", ref tbInfo))
{
mPass.ShaderResources.VSBindTexture(tbInfo.VSBindPoint, mInstanceDataTextureView);
}
var spInfo = new CSamplerBindInfo();
if (program.FindSamplerBindInfo(null, "Samp_gVertexTexture", ref spInfo))
{
mPass.ShaderSamplerBinder.VSBindSampler(spInfo.VSBindPoint, mSamplerState);
}
if (program.FindSamplerBindInfo(null, "Samp_gInstanceDataTexture", ref spInfo))
{
mPass.ShaderSamplerBinder.VSBindSampler(spInfo.VSBindPoint, mSamplerState);
}
}
else
{
//CTextureBindInfo tbInfo = new CTextureBindInfo();
//if(program.FindTextureBindInfo(null, "AllVertexArray", ref tbInfo))
//{
// mPass.ShaderResources.VSBindTexture(tbInfo.VSBindPoint, mAllVertexSRV);
//}
//if (program.FindTextureBindInfo(null, "MeshInstanceArray", ref tbInfo))
//{
// mPass.ShaderResources.VSBindTexture(tbInfo.VSBindPoint, mMeshInstanceSRV);
//}
mPass.ShaderResources.VSBindTexture(14, mAllVertexSRV);
mPass.ShaderResources.VSBindTexture(13, mMeshInstanceSRV);
}
CConstantBufferDesc cbInfo = new CConstantBufferDesc();
if (mCBMeshBatch != null && program.GetCBufferDesc(program.FindCBuffer("cbMeshBatch"), ref cbInfo))
{
mPass.BindCBufferVS(cbInfo.VSBindPoint, mCBMeshBatch);
}
mPass.ViewPort = Camera.SceneView.Viewport;
mPass.BindCBuffer(mPass.Effect.ShaderProgram, mPass.Effect.CacheData.CBID_Camera, Camera.CBuffer);
if (view != null)
{
mPass.BindCBuffer(mPass.Effect.ShaderProgram, mPass.Effect.CacheData.CBID_View, view.SceneViewCB);
}
//mPass.ViewPort = view.Viewport;
if (UseComputeShader == false)
{
mPass.AttachIndexBuffer = mCpuDrawIndexBuffer;
var dpDesc = new CDrawPrimitiveDesc();
dpDesc.SetDefault();
dpDesc.NumPrimitives = mDrawArgs.IndexCountPerInstance / 3;
mPass.GeometryMesh.SetAtom(0, 0, ref dpDesc);
}
else
{
mPass.AttachIndexBuffer = mDrawIndexBuffer;
mPass.SetIndirectDraw(bufferIndirectDrawArgs, 0);
}
cmd.PushPass(mPass);
}
partial void CheckVisible_Editor(CCommandList cmd, Graphics.CGfxCamera camera, SceneGraph.CheckVisibleParam param);
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);
//}
}
