/// <summary>
/// Run Culling With Compute Shader
/// </summary>
/// <param name="view"></param> World To View Matrix
/// <param name="proj"></param> View To NDC Matrix
/// <param name="buffers"></param> Buffers
public static void RunCulling(ref Matrix4x4 view, ref Matrix4x4 proj, ref Matrix4x4 rtProj, ref CullingBuffers buffers)
{
Matrix4x4 vp = proj * view;
buffers.cullingShader.SetMatrix(ShaderIDs._VPMatrix, rtProj * view);
GetCullingPlanes(ref vp, planes);
for (int i = 0; i < 6; ++i)
{
Vector3 normal = planes[i].normal;
float distance = planes[i].distance;
planesVector[i] = new Vector4(normal.x, normal.y, normal.z, distance);
}
buffers.cullingShader.SetVectorArray(ShaderIDs.planes, planesVector);
ComputeShaderUtility.Dispatch(buffers.cullingShader, buffers.csmainKernel, buffers.count, THREADGROUPCOUNT);
buffers.currentCullingResult = (int)GetCullingBufferResult(ref buffers);
}
public MeshResources(MarchingCubeAsset asset, int maxGridLength) : this()
{
this.ArgsBufferForInstancing = ComputeShaderUtility.CreateIndirectArgumentsBufferForInstancing();
this.ArgsBufferForDispatch = ComputeShaderUtility.CreateIndirectArgumentsBufferForDispatch();
this.CubeInstancesBuffer = createCubeIdInstancingShaderBuffer_(32 * 32 * 32 * maxGridLength);
this.GridCubeIdBuffer = createGridCubeIdShaderBuffer_(maxGridLength);
var vertexNormalDict = makeVertexNormalsDict_(asset.CubeIdAndVertexIndicesList); Debug.Log(vertexNormalDict.Count);
this.NormalBuffer = createNormalList_(vertexNormalDict);
this.CubePatternBuffer = createCubePatternBuffer_(asset.CubeIdAndVertexIndicesList, vertexNormalDict);
this.CubeVertexBuffer = createCubeVertexBuffer_(asset.BaseVertexList);
this.GridBuffer = createGridShaderBuffer_(512);
this.mesh = createMesh_();
}
public static void RunCullDispatching(ref PipelineBaseBuffer baseBuffer, ComputeShader computeShader)
{
computeShader.Dispatch(1, 1, 1, 1);
ComputeShaderUtility.Dispatch(computeShader, 0, baseBuffer.clusterCount, 64);
}
void Awake()
{
var em = World.DefaultGameObjectInjectionWorld.EntityManager;
var drawModelArchetype = em.CreateArchetype(
typeof(DrawModel.BoneVectorSettingData),
typeof(DrawModel.InstanceCounterData),
typeof(DrawModel.VectorBufferData),
typeof(DrawModel.GeometryData),
typeof(DrawModel.ComputeArgumentsBufferData)
);
this.PrefabEntities = this.PrefabGameObjects
//.Select( prefab => prefab.Convert( em, drawMeshCsResourceHolder, initDrawModelComponents_ ) )
.Select(prefab => prefab.Convert(em, initDrawModelComponents_))
.ToArray();
return;
Entity initDrawModelComponents_(Mesh mesh, Material mat, BoneType BoneType, int boneLength)
{
// キャプチャ（暫定）
var em_ = em;
var drawModelArchetype_ = drawModelArchetype;
var sys = em.World.GetExistingSystem <DrawBufferManagementSystem>();
var boneVectorBuffer = sys.GetSingleton <DrawSystem.ComputeTransformBufferData>().Transforms;
setShaderProps_(mat, mesh, boneVectorBuffer, boneLength);
return(createEntityAndInitComponents_(drawModelArchetype_, boneLength));
void setShaderProps_(Material mat_, Mesh mesh_, ComputeBuffer boneVectorBuffer_, int boneLength_)
{
mat_.SetBuffer("BoneVectorBuffer", boneVectorBuffer_);
mat_.SetInt("BoneLengthEveryInstance", boneLength_);
//mat_.SetInt( "BoneVectorOffset", 0 );// 毎フレームのセットが必要
}
Entity createEntityAndInitComponents_(EntityArchetype drawModelArchetype__, int boneLength_)
{
//var drawModelArchetype = em.CreateArchetype(
// typeof( DrawModelBoneInfoData ),
// typeof( DrawModelInstanceCounterData ),
// typeof( DrawModelInstanceOffsetData ),
// typeof( DrawModelMeshData ),
// typeof( DrawModelComputeArgumentsBufferData )
//);
var ent = em.CreateEntity(drawModelArchetype__);
em.SetComponentData(ent,
new DrawModel.BoneVectorSettingData
{
BoneLength = boneLength_,
VectorLengthInBone = (int)BoneType,
}
);
em.SetComponentData(ent,
new DrawModel.GeometryData
{
Mesh = mesh,
Material = mat,
}
);
em.SetComponentData(ent,
new DrawModel.ComputeArgumentsBufferData
{
InstanceArgumentsBuffer = ComputeShaderUtility.CreateIndirectArgumentsBuffer(),
}
);
return(ent);
}
}
}
static public Entity CreateDrawModelEntityComponents
(
this GameObjectConversionSystem gcs, GameObject topGameObject,
Mesh mesh, Material mat,
BoneType boneType, int boneLength, int instanceDataVectorLength = 0
)
{
var em = gcs.DstEntityManager;
setShaderProps_(em, mat, mesh, boneLength);
var drawModelEntity = createDrawModelEntity_(gcs, topGameObject);
initInfomationData_(em, drawModelEntity, mesh.bounds, boneLength, boneType, instanceDataVectorLength);
initResourceData_(em, drawModelEntity, mat, mesh);
return(drawModelEntity);
void setShaderProps_(EntityManager em_, Material mat_, Mesh mesh_, int boneLength_)
{
var sys = em_.World.GetExistingSystem <DrawBufferManagementSystem>();
var boneVectorBuffer = sys.GetSingleton <DrawSystem.ComputeTransformBufferData>().Transforms;
mat_.SetBuffer("BoneVectorBuffer", boneVectorBuffer);
mat_.SetInt("BoneLengthEveryInstance", boneLength_);
//mat_.SetInt( "BoneVectorOffset", 0 );// 毎フレームのセットが必要なので、ここではやらない
}
Entity createDrawModelEntity_
(GameObjectConversionSystem gcs_, GameObject top_)
{
var em_ = gcs_.DstEntityManager;
var drawModelArchetype = em_.CreateArchetype(
typeof(DrawModel.BoneVectorSettingData),
typeof(DrawModel.InstanceCounterData),
typeof(DrawModel.VectorBufferData),
typeof(DrawModel.VectorLengthData),
typeof(DrawModel.BoundingBoxData),
typeof(DrawModel.GeometryData),
typeof(DrawModel.ComputeArgumentsBufferData)
);
var ent = em_.CreateEntity(drawModelArchetype);
gcs.AddToModelEntityDictionary(top_, ent);
em_.SetName_(ent, $"{top_.name} model");
return(ent);
}
void initInfomationData_
(
EntityManager em_, Entity ent_,
Bounds bbox_, int boneLength_, BoneType boneType_, int instanceDataVectorLength_
)
{
em_.SetComponentData(ent_,
new DrawModel.BoneVectorSettingData
{
BoneLength = boneLength_,
VectorLengthInBone = (int)boneType_,
}
);
em_.SetComponentData(ent_,
new DrawModel.BoundingBoxData
{
LocalBbox = new AABB
{
Center = (float3)bbox_.center, // + meshpos_,
Extents = (float3)bbox_.extents,
}
}
);
em_.SetComponentData(ent_,
new DrawModel.VectorLengthData
{
VectorLengthOfInstanceAdditionalData = instanceDataVectorLength_,
VecotrLengthPerInstance = (int)boneType_ * boneLength_ + instanceDataVectorLength_,
}
);
Debug.Log($"{boneType_} {boneLength_} {instanceDataVectorLength_}");
}
void initResourceData_
(EntityManager em_, Entity ent_, Material mat_, Mesh mesh_)
{
em_.SetComponentData(ent_,
new DrawModel.GeometryData
{
Mesh = mesh_,
Material = mat_,
}
);
em_.SetComponentData(ent_,
new DrawModel.ComputeArgumentsBufferData
{
InstanceArgumentsBuffer = ComputeShaderUtility.CreateIndirectArgumentsBuffer(),
}
);
}
}
private static void Dispatch(ref RainData data)
{
ComputeShaderUtility.Dispatch(data.settingData.randomDrawShader, 0, data.shaderData.instancingBuffer.count, THREADGROUPCOUNT);
}
