void DrawParticles()
{
int kernel = positionsToShaderData.FindKernel("PositionsToShaderData");
positionsToShaderData.SetBuffer(kernel, "positions", positions);
positionsToShaderData.SetBuffer(kernel, "velocities", velocities);
positionsToShaderData.SetBuffer(kernel, "colors", colors);
positionsToShaderData.SetBuffer(kernel, "_InstancedIndirectShaderData", particleShaderData);
Profiler.BeginSample("Positions To Shader Data");
positionsToShaderData.Dispatch(kernel, (int)math.ceil(particleCount / 32.0f), 1, 1);
Profiler.EndSample();
MaterialPropertyBlock properties = new MaterialPropertyBlock();
properties.SetBuffer("_InstancedIndirectShaderData", particleShaderData);
properties.SetBuffer("colors", colors);
properties.SetMatrix("_LocalToWorld", transform.localToWorldMatrix);
Graphics.DrawMeshInstancedIndirect(
particleMesh,
0,
particleMaterial,
new Bounds(transform.position, transform.lossyScale * 10000),
particleShaderArgs,
0,
properties,
ShadowCastingMode.Off
);
}
unsafe void RenderBatch(Mesh mesh, int batchSize, int layer)
{
ComputeBuffer argsBuffer = ArgBuffers.Rent(1, args.Length * sizeof(uint));
ComputeBuffer positionBuffer = StructuredBuffers.Rent(kBatchSize, sizeof(Vector2));
ComputeBuffer colorBuffer = StructuredBuffers.Rent(kBatchSize, sizeof(Color));
ComputeBuffer rotationBuffer = StructuredBuffers.Rent(kBatchSize, sizeof(float));
colorBuffer.SetData(colorCache, 0, 0, batchSize);
positionBuffer.SetData(positionCache, 0, 0, batchSize);
rotationBuffer.SetData(rotationCache, 0, 0, batchSize);
propertyBlock.SetBuffer(positionPropertyId, positionBuffer);
propertyBlock.SetBuffer(rotationPropertyId, rotationBuffer);
propertyBlock.SetBuffer(colorPropertyId, colorBuffer);
args[0] = mesh.GetIndexCount(0);
args[1] = (uint)batchSize;
argsBuffer.SetData(args);
Graphics.DrawMeshInstancedIndirect(mesh, 0, renderMaterial,
bounds: new Bounds(Vector3.zero, Vector3.one * 1000f),
bufferWithArgs: argsBuffer,
argsOffset: 0,
properties: propertyBlock,
castShadows: ShadowCastingMode.Off,
receiveShadows: false,
layer: layer,
camera: null);
}
void IssueDrawCall(CommandBuffer cb)
{
if (properties == null)
{
properties = new MaterialPropertyBlock();
}
var cont = GetComponent <IBezierPatchContainer>();
var bpatches = cont.GetBezierPatches();
var aabbs = cont.GetAABBs();
if (m_buf_vertices == null)
{
BatchRendererUtil.CreateVertexBuffer(m_bound_mesh, ref m_buf_vertices, ref m_num_vertices, BatchRendererUtil.VertexFormat.P);
properties.SetBuffer("_Vertices", m_buf_vertices);
}
if (m_buf_bpatches == null)
{
m_buf_bpatches = new ComputeBuffer(bpatches.Length, BezierPatchRaw.size);
properties.SetBuffer("_BezierPatches", m_buf_bpatches);
}
if (m_buf_aabbs == null)
{
m_buf_aabbs = new ComputeBuffer(aabbs.Length, BezierPatchAABB.size);
properties.SetBuffer("_AABBs", m_buf_aabbs);
}
m_buf_bpatches.SetData(bpatches);
m_buf_aabbs.SetData(aabbs);
cb.DrawProcedural(Matrix4x4.identity, m_material, 0, MeshTopology.Triangles, m_num_vertices, bpatches.Length, properties);
}
private void Update()
{
for (int i = 0; i < meshToWorld.Length; ++i)
{
// mesh坐标系转世界坐标系
meshToWorld[i] = bones[i].localToWorldMatrix /* 骨骼坐标系转世界坐标系 */ * bindPoses[i] /* mesh坐标系转骨骼坐标系 */;
}
bonePositionBuffer.SetData(meshToWorld);
// 向GPU传值
rendererBlock.Clear();
//shader->BindRootSignature
compute.SetBuffer(0, "_BoneWeightsBuffer", boneWeightBuffer);
compute.SetBuffer(0, "_BonePositionBuffer", bonePositionBuffer);
compute.SetBuffer(0, "_VertexBuffer", vertexBuffer);
compute.SetBuffer(0, "_VertexReadBuffer", vertexReadBuffer);
int threadCount = boneWeightBuffer.count;
compute.SetInt("_Count", threadCount);
compute.Dispatch(0, (threadCount + 63) / 64, 1, 1);
rendererBlock.SetBuffer("_BoneWeightsBuffer", boneWeightBuffer);
rendererBlock.SetBuffer("_BonePositionBuffer", bonePositionBuffer);
rendererBlock.SetBuffer("_VertexBuffer", vertexBuffer);
targetRenderer.SetPropertyBlock(rendererBlock);
}
public override void _Create()
{
if (mpb == null)
{
mpb = new MaterialPropertyBlock();
}
if (verts == null)
{
verts = GetComponent <MeshVerts>();
}
if (triangles == null)
{
triangles = GetComponent <MeshTris>();
}
SafeInsert(verts);
SafeInsert(triangles);
mpb.SetInt("_VertCount", verts.count);
mpb.SetBuffer("_VertBuffer", verts._buffer);
mpb.SetBuffer("_TriBuffer", triangles._buffer);
DoCreate();
}
public override void _Create()
{
print("run SEcOND");
if (mpb == null)
{
mpb = new MaterialPropertyBlock();
}
if (verts == null)
{
verts = GetComponent <Form>();
}
if (triangles == null)
{
triangles = GetComponent <IndexForm>();
}
SafeInsert(verts);
SafeInsert(triangles);
mpb.SetInt("_VertCount", verts.count);
mpb.SetBuffer("_VertBuffer", verts._buffer);
mpb.SetBuffer("_TriBuffer", triangles._buffer);
DoCreate();
}
private void RenderMe(Camera c)
{
if (!Application.isPlaying)
{
return;
}
fCBP.Flush();
v2CBP.Flush();
argsCBP.Flush();
args[0] = ri.mesh.GetIndexCount(0);
for (int done = 0; done < instanceCount; done += batchSize)
{
int run = Math.Min(instanceCount - done, batchSize);
args[1] = (uint)run;
for (int batchInd = 0; batchInd < run; ++batchInd)
{
var obj = objects[done + batchInd];
posArr[batchInd] = obj.position;
dirArr[batchInd] = new Vector2(Mathf.Cos(obj.rotation) * obj.scale, Mathf.Sin(obj.rotation) * obj.scale);
timeArr[batchInd] = obj.time;
}
var posCB = v2CBP.Rent();
var dirCB = v2CBP.Rent();
var timeCB = fCBP.Rent();
posCB.SetData(posArr, 0, 0, run);
dirCB.SetData(dirArr, 0, 0, run);
timeCB.SetData(timeArr, 0, 0, run);
pb.SetBuffer(positionPropertyId, posCB);
pb.SetBuffer(directionPropertyId, dirCB);
pb.SetBuffer(timePropertyId, timeCB);
var argsCB = argsCBP.Rent();
argsCB.SetData(args);
CallRender(c, argsCB);
}
}
public override void WhileDebug()
{
mpb.SetBuffer("_VertBuffer", toIndex._buffer);
mpb.SetBuffer("_TriBuffer", _buffer);
mpb.SetInt("_Count", count);
mpb.SetInt("_VertCount", toIndex.count);
Graphics.DrawProcedural(debugMaterial, new Bounds(transform.position, Vector3.one * 5000), MeshTopology.Lines, (count - 1) * 2, 1, null, mpb, ShadowCastingMode.Off, true, LayerMask.NameToLayer("Debug"));
}
protected void Render(float extents = 100f)
{
block.SetBuffer("_Nodes", dendrite.NodeBuffer);
block.SetBuffer("_Edges", dendrite.EdgeBuffer);
block.SetInt("_EdgesCount", dendrite.EdgesCount);
block.SetMatrix("_World2Local", transform.worldToLocalMatrix);
block.SetMatrix("_Local2World", transform.localToWorldMatrix);
Graphics.DrawMeshInstancedIndirect(segment, 0, material, new Bounds(Vector3.zero, Vector3.one * extents), drawBuffer, 0, block);
}
public void AddChunkToRender(ComputeBuffer args, ComputeBuffer vertices, ComputeBuffer normals)
{
MaterialPropertyBlock block = new MaterialPropertyBlock();
block.SetBuffer(ShaderIds.vertices, vertices);
block.SetBuffer(ShaderIds.normals, normals);
chunks.Add(new ChunkRenderParams(args, block));
}
public void SetSkinAndBones(ComputeBuffer skin, ComputeBuffer bones)
{
var r = GetComponent <Renderer>();
var mpb = new MaterialPropertyBlock();
r.GetPropertyBlock(mpb);
mpb.SetBuffer("_Skin", skin);
mpb.SetBuffer("_Bones", bones);
r.SetPropertyBlock(mpb);
}
void UpdateMaterial()
{
if (_props == null)
{
_props = new MaterialPropertyBlock();
}
Debug.Log(DeviceController.ID.PositionMap);
_props.SetTexture(DeviceController.ID.PositionMap, _device.PositionMap);
_props.SetBuffer(ShaderID.rTriangles, this.trianglesBuffer);
_props.SetBuffer(ShaderID.rPoints, this.pointsBuffer);
_props.SetMatrix("_LocalToWorld", this.transform.localToWorldMatrix);
this.triangleCounts = new int[] { 0, 1, 0, 0 };
this.triangleCountsBuffer.SetData(this.triangleCounts);
ComputeBuffer.CopyCount(this.pointsBuffer, triangleCountsBuffer, 0);
this.triangleCountsBuffer.GetData(this.triangleCounts);
Debug.Log("p: " + this.triangleCounts[0]);
_props.SetInt("_PointCount", this.triangleCounts[0]);
this.triangleCounts = new int[] { 0, 1, 0, 0 };
this.triangleCountsBuffer.SetData(this.triangleCounts);
ComputeBuffer.CopyCount(this.trianglesBuffer, triangleCountsBuffer, 0);
this.triangleCountsBuffer.GetData(this.triangleCounts);
Debug.Log("t: " + this.triangleCounts[0]);
/*
* Vector3Int[] tri = new Vector3Int[maxPointNum];
* this.trianglesBuffer.GetData(tri);
* for (int i = 0; i < 10; i++) {
* Debug.Log(tri[i]);
* }
* Vector2Int[] pp = new Vector2Int[maxPointNum];
* this.pointsBuffer.GetData(pp);
* for (int i = 0; i < 10; i++) {
* Debug.Log(pp[i]);
* }
*/
_props.SetInt("_TriangleCount", this.triangleCounts[0]);
Graphics.DrawProcedural(
_material,
new Bounds(this.transform.position, this.transform.lossyScale * 200),
MeshTopology.Triangles, this.triangleCounts[0] * 3, 1,
null, _props,
ShadowCastingMode.TwoSided, true, this.gameObject.layer
);
}
public override void _WhileLiving(float v)
{
// List<int> indicies;
int baseIndex;
DoLiving(v);
if (active)
{
if (mainMesh.subMeshCount != materials.Length)
{
DebugThis("your mat count: " + materials.Length + "mesh mat count: " + mainMesh.subMeshCount);
}
else
{
baseIndex = 0;
mpb.SetInt("_VertCount", verts.count);
mpb.SetBuffer("_VertBuffer", verts._buffer);
mpb.SetBuffer("_TriBuffer", triangles._buffer);
for (int i = 0; i < mainMesh.subMeshCount; i++)
{
MaterialPropertyBlock mpb1 = new MaterialPropertyBlock();
mpb1.SetInt("_VertCount", verts.count);
mpb1.SetBuffer("_VertBuffer", verts._buffer);
mpb1.SetBuffer("_TriBuffer", triangles._buffer);
int[] indicies = mainMesh.GetIndices(i);
mpb1.SetInt("_BaseID", baseIndex);
mpb1.SetInt("_SubMeshID", i);
// Infinit bounds so its always drawn!
Graphics.DrawProcedural(
materials[i],
new Bounds(transform.position, Vector3.one * 50000),
MeshTopology.Triangles,
indicies.Length,
1,
null,
mpb1,
ShadowCastingMode.TwoSided,
true,
gameObject.layer
);
baseIndex += indicies.Length;
}
}
}
}
public void UpdateSettingsBuffer(ComputeBuffer computeBuffer)
{
if (m_propertyBlock == null)
{
m_propertyBlock = new MaterialPropertyBlock();
}
m_propertyBlock.SetBuffer(MaterialProperties.Settings_StructuredBuffer, computeBuffer);
m_renderer.SetPropertyBlock(m_propertyBlock);
}
public override void Bind()
{
print("binding");
locationMPB.SetBuffer("_ParticleBuffer", data.textParticles.particles._buffer);
glyphMPB.SetBuffer("_ParticleBuffer", data.textParticles.particles._buffer);
glyphMPB.SetTexture("_TextMap", GlyphTexture);
glyphMPB.SetBuffer("_VertBuffer", data.textParticles.body.verts._buffer);
glyphMPB.SetBuffer("_TriBuffer", data.textParticles.body.triangles._buffer);
}
private void Render(ScriptableRenderContext ctx, Camera camera)
{
BeginCameraRendering(ctx, camera);
_cb.Clear();
_cb.ClearRenderTarget(true, true, camera.backgroundColor);
foreach (var world in World.AllWorlds)
{
Profiler.BeginSample("World " + world.Name);
var vrs = world.GetExistingSystem <VoxelRenderSystem>();
if (vrs != null)
{
_cb.BeginSample("World " + world.Name);
Profiler.BeginSample("World " + world.Name);
var positionBuffer = _positionBufferPool.Rent();
var colorBuffer = _colorBufferPool.Rent();
vrs.LastJob.Complete();
while (vrs._batchQueue.TryDequeue(out var batch))
{
Profiler.BeginSample("Batch");
Profiler.BeginSample("Copy");
{
colorBuffer.SetData(vrs._lastColors, batch.GlobalIndex, 0, batch.Length);
positionBuffer.SetData(vrs._lastMatrices, batch.GlobalIndex, 0, batch.Length);
}
Profiler.EndSample();
Profiler.BeginSample("Submitting");
_matPropBlock.Clear();
_matPropBlock.SetBuffer(_colorProp, colorBuffer);
_matPropBlock.SetBuffer(_positionBufferProp, positionBuffer);
_cb.DrawMeshInstancedProcedural(_voxMesh, 0, _voxMat, -1, batch.Length, _matPropBlock);
Profiler.EndSample();
Profiler.BeginSample("Resetting");
positionBuffer = _positionBufferPool.Rent();
colorBuffer = _colorBufferPool.Rent();
Profiler.EndSample();
Profiler.EndSample();
}
Profiler.EndSample();
_cb.EndSample("World " + world.Name);
}
Profiler.EndSample();
}
ctx.ExecuteCommandBuffer(_cb);
EndCameraRendering(ctx, camera);
}
void Update()
{
ComputeBuffer _PositionBuffer = computeGrassBuffer.PositionBuffer;
ComputeBuffer.CopyCount(_PositionBuffer, argsBuffer, 0);
if (prop == null)
{
prop = new MaterialPropertyBlock();
}
prop.SetBuffer("_PositionBuffer", _PositionBuffer);
prop.SetFloat("_Radius", radius);
prop.SetFloat("_Length", length);
prop.SetFloat("_bendForward", bendForward);
prop.SetFloat("_bendCurve", bendCurve);
prop.SetFloat("_rotRand", rotRand);
prop.SetVector("_Wind", Vector3.Normalize(wind + eps));
prop.SetFloat("_windSpeed", windSpeed);
prop.SetFloat("_windScale", windScale);
prop.SetFloat("_windStrength", windStrength);
prop.SetFloat("_time", Time.time);
Vector3 size = new Vector3(computeGrassBuffer.SizeX * 1.5f, 5, computeGrassBuffer.SizeY * 1.5f);
Graphics.DrawProceduralIndirect(
material,
new Bounds(transform.localPosition, size),
MeshTopology.Points,
argsBuffer, 0, null,
prop, ShadowCastingMode.TwoSided,
true, gameObject.layer
);
}
protected void Update()
{
if (Time.frameCount % frame == 0)
{
cached = Sample();
// bounds = cached.bounds;
bounds.Encapsulate(cached.bounds.min);
bounds.Encapsulate(cached.bounds.max);
Voxelize(cached, bounds);
}
// if(flowRandom && Time.frameCount % flowRandomFreq == 0) FlowRandom();
var dt = Time.deltaTime;
if (voxelMode != VoxelMode.Default)
{
ComputeVoxel(voxelKernels[voxelMode], dt);
}
ComputeParticle(particleKernels[particleMode], dt);
particleUpdate.SetFloat("_UseColor", useColor ? 1f : 0f);
particleUpdate.SetFloat("_GradientScale", gradientScale);
particleUpdate.SetFloat("_GradientSpeed", gradientSpeed);
ComputeParticle(gradKer, dt);
block.SetBuffer(kParticleBufferKey, particleBuffer);
_emission = Color.Lerp(_emission, emission, dt);
block.SetColor("_Emission", _emission);
renderer.SetPropertyBlock(block);
}
private void Render()
{
foreach (var item in cachedAnimated)
{
var hash = item.Key;
var matrices = matricesData[hash];
var animated = cachedAnimated[hash];
var entityIds = entityIndices[hash];
var clipData = clipDatas[hash];
var overrideFrameData = overrideFrames[hash];
var currentLength = matrices.Count;
var start = 0;
while (start < currentLength)
{
var len = Math.Min(1023, currentLength - start);
matrices.CopyTo(start, tempMatrices, 0, len);
entityIds.CopyTo(start, tempIndices, 0, len);
clipData.CopyTo(start, tempClipDatas, 0, len);
overrideFrameData.CopyTo(start, overrideFrameDatas, 0, len);
block.SetFloatArray("_CurrentAnimation", tempClipDatas);
block.SetFloatArray("_OverrideFrame", overrideFrameDatas);
block.SetFloatArray("_EntityID", tempIndices);
block.SetBuffer("_RunningState", computeData);
Graphics.DrawMeshInstanced(animated.Mesh, 0, animated.Material, tempMatrices, len, block, ShadowCastingMode.On, true);
start += len;
}
}
}
protected override void OnUpdate()
{
_renderedItemPositionComputationSystem.SetupDependency.Complete();
var renderedItemPositions = _renderedItemPositionComputationSystem.RenderedItemPositions;
var prefabs = GetSingleton <World.Prefabs>();
for (var index = 0; index < renderedItemPositions.Length; index++)
{
NativeArray <float3> itemPositions = renderedItemPositions[index];
if (itemPositions.Length == 0)
{
continue;
}
if (_graphicsBuffers[index] == null || _graphicsBuffers[index].count != itemPositions.Length)
{
_graphicsBuffers[index]?.Dispose();
_graphicsBuffers[index] = new GraphicsBuffer(GraphicsBuffer.Target.Structured, itemPositions.Length, 12);
}
_graphicsBuffers[index].SetData(itemPositions);
var materialPropertyBlock = new MaterialPropertyBlock();
materialPropertyBlock.SetBuffer("_AllInstancesTransformBuffer", _graphicsBuffers[index]);
var m = EntityManager.GetSharedComponentData <Unity.Rendering.RenderMesh>(
index == 0 ? prefabs.ItemPrefab : prefabs.Item2Prefab);
Graphics.DrawMeshInstancedProcedural(m.mesh, 0, m.material, new Bounds(Vector3.zero, Vector3.one * 10000), itemPositions.Length, materialPropertyBlock);
}
}
private void _setShaderParams()
{
// ComputeShader
int kernelId = _computeShader.FindKernel("MainCS");
_computeShader.SetFloat("_Duration", _duration);
_computeShader.SetFloat("_DeltaTime", Time.deltaTime);
_computeShader.SetFloat("_Emitting", _isEmit ? 1f : 0);
_computeShader.SetFloat("_Strength", _strength);
_computeShader.SetVector("_Position", transform.position);
//_computeShader.SetVector("_Velocity", transform.position-_pastPos);
_computeShader.SetFloat("_Distance", _Distance);
//_pastPos=transform.position;
_computeShader.SetBuffer(kernelId, "_CubeDataBuffer", _cubeDataBuffer);
_computeShader.Dispatch(kernelId, (Mathf.CeilToInt(_num / ThreadBlockSize) + 1), 1, 1);
//おまじないパラメータ
_args[0] = (uint)_mesh.GetIndexCount(0);
_args[1] = (uint)_num;
_args[2] = (uint)_mesh.GetIndexStart(0);
_args[3] = (uint)_mesh.GetBaseVertex(0);
_argsBuffer.SetData(_args);
// GPU Instaicing
_block.SetFloat("_Duration", _duration);
_block.SetBuffer("_CubeDataBuffer", _cubeDataBuffer);//データを渡す
_block.SetFloat("_Size", _size);
}
void Update()
{
// 不对四元数进行递增操作，float值的微量不精确累加会导致四元数不合法！
// Quaternion deltaRotation = Quaternion.Euler(0, 22.5f * Time.deltaTime, 0);
float angleDelta = 22.5f * Time.deltaTime;
// 旋转根节点
var rootPart = parts[0][0];
// rootPart.rotation *= deltaRotation;
rootPart.angle += angleDelta;
rootPart.worldRotation = transform.rotation *
(rootPart.rotation * Quaternion.Euler(0, rootPart.angle, 0));
rootPart.worldPosition = transform.position;
parts[0][0] = rootPart;
// 根节点的变换矩阵
// 平移-旋转-缩放 Translation-Rotation-Scale
float objectScale = transform.lossyScale.x;
var mat4 = Matrix4x4.TRS(
rootPart.worldPosition,
rootPart.worldRotation,
Vector3.one * objectScale
);
matrices[0][0] = mat4;
float scale = objectScale;
for (int li = 1; li < depth; li++)
{
// 每下一层，缩放比例就减小一半
scale *= .5f;
var parentParts = parts[li - 1];
var levelParts = parts[li];
var levelMat4 = matrices[li];
Matrix4x4[] levelMatrices = matrices[li];
for (int fpi = 0; fpi < levelParts.Length; fpi++)
{
var parentPart = parentParts[fpi / 5];
var part = levelParts[fpi];
part.angle += angleDelta;
part.worldRotation = parentPart.worldRotation * (part.rotation * Quaternion.Euler(0, part.angle, 0));
part.worldPosition = parentPart.worldPosition +
parentPart.worldRotation *
(1.5f * scale * part.direction);
levelParts[fpi] = part;
levelMatrices[fpi] = Matrix4x4.TRS(
part.worldPosition,
part.worldRotation,
scale * Vector3.one
);
}
}
var bounds = new Bounds(rootPart.worldPosition, 3 * objectScale * Vector3.one);
for (int i = 0; i < matricesBuffers.Length; i++)
{
var buffer = matricesBuffers[i];
buffer.SetData(matrices[i]);
propertyBlock.SetBuffer(matricesId, buffer);
Graphics.DrawMeshInstancedProcedural(mesh, 0, material, bounds, buffer.count, propertyBlock);
}
}
public void Draw(Camera camera)
{
if (CanDraw())
{
var lodLevelCount = Mathf.Min(MaxLodLevelCount, _renderer.LodLevelCount);
for (int i = 0; i < lodLevelCount; ++i)
{
var lodRenderer = _renderer.GetLodRenderer(i);
var count = lodRenderer.Renderers.Length;
int drawCallOffset = 0;
for (int j = 0; j < count; ++j)
{
var renderer = lodRenderer.Renderers[j];
if (renderer == null)
{
continue;
}
for (int k = 0; k < renderer.SubMeshCount; ++k)
{
if (sorted)
{
_argsData[i].SetData(args);
}
else
{
ComputeBuffer.CopyCount(_drawInstanceDataForLod[i], _argsData[i],
drawCallOffset + Constants.StrideSizeUint);
// _argsData[i].GetData(args);
// _argsData[i].SetData(args);
}
_mbp.SetBuffer(Constants.MeshVariable.DrawInstanceData, _drawInstanceDataForLod[i]);
SetMaterialPropertyBlock();
if (SharedConfig.GrassQueue != -1)
{
renderer.Materials[k].renderQueue = SharedConfig.GrassQueue;
}
Graphics.DrawMeshInstancedIndirect(
renderer.Mesh,
k,
renderer.Materials[k],
testBounds,
_argsData[i],
drawCallOffset,
_mbp,
_castShadow,
_receiveShadow,
Layer,
camera);
drawCallOffset += ArgCountPerDraw * sizeof(uint);
}
}
}
}
}
private void CreateIndirectDrawResources()
{
_indirectDrawMaterial = new Material(_resources.FilledVoxelInstanceMaterial);
_indirectDrawMaterial.enableInstancing = true;
var volumeSize = _voxelsData.VolumeSize;
_indirectDrawMaterial.SetVector(VoxelizationResources.VOLUME_SIZE,
new Vector4(volumeSize.x, volumeSize.y, volumeSize.z, _voxelsData.VoxelSize));
_materialPropertyBlock = new MaterialPropertyBlock();
_materialPropertyBlock.Clear();
_materialPropertyBlock.SetBuffer(VoxelizationResources.FILLED_VOXELS_INSTANCES,
_voxelsData.FilledVoxelInstances);
var instancedMesh = _resources.FilledVoxelInstanceMesh;
var args = new uint[5];
args[0] = instancedMesh.GetIndexCount(0);
args[1] = 0; // instance count
args[2] = instancedMesh.GetIndexStart(0);
args[3] = instancedMesh.GetBaseVertex(0);
args[4] = 0; // start instance location
_indirectDrawArgs = new ComputeBuffer(1, args.Length * sizeof(uint), ComputeBufferType.IndirectArguments);
_indirectDrawArgs.SetData(args);
}
void UpdateMeshRenderer()
{
var meshRenderer = GetComponent <MeshRenderer>();
if (_drawProps == null)
{
_drawProps = new MaterialPropertyBlock();
}
_drawProps.SetBuffer("_PositionBuffer", _positionBuffer1);
_drawProps.SetBuffer("_NormalBuffer", _normalBuffer);
_drawProps.SetBuffer("_TangentBuffer", _tangentBuffer);
_drawProps.SetFloat("_TriangleCount", _data.triangleCount);
meshRenderer.SetPropertyBlock(_drawProps);
}
static public void ExecuteLightClusterDebug(CommandBuffer cmd, LightClusterDebugParameters parameters, LightClusterDebugResources resources, MaterialPropertyBlock debugMaterialProperties)
{
// Bind the output texture
CoreUtils.SetRenderTarget(cmd, resources.debugLightClusterTexture, resources.depthStencilBuffer, clearFlag: ClearFlag.Color, clearColor: Color.black);
// Inject all the parameters to the debug compute
cmd.SetComputeBufferParam(parameters.lightClusterDebugCS, parameters.lightClusterDebugKernel, HDShaderIDs._RaytracingLightCluster, parameters.lightCluster);
cmd.SetComputeVectorParam(parameters.lightClusterDebugCS, _ClusterCellSize, parameters.clusterCellSize);
cmd.SetComputeTextureParam(parameters.lightClusterDebugCS, parameters.lightClusterDebugKernel, HDShaderIDs._CameraDepthTexture, resources.depthStencilBuffer);
// Target output texture
cmd.SetComputeTextureParam(parameters.lightClusterDebugCS, parameters.lightClusterDebugKernel, _DebutLightClusterTexture, resources.debugLightClusterTexture);
// Dispatch the compute
int lightVolumesTileSize = 8;
int numTilesX = (parameters.texWidth + (lightVolumesTileSize - 1)) / lightVolumesTileSize;
int numTilesY = (parameters.texHeight + (lightVolumesTileSize - 1)) / lightVolumesTileSize;
cmd.DispatchCompute(parameters.lightClusterDebugCS, parameters.lightClusterDebugKernel, numTilesX, numTilesY, 1);
// Bind the parameters
debugMaterialProperties.SetBuffer(HDShaderIDs._RaytracingLightCluster, parameters.lightCluster);
debugMaterialProperties.SetVector(_ClusterCellSize, parameters.clusterCellSize);
debugMaterialProperties.SetTexture(HDShaderIDs._CameraDepthTexture, resources.depthTexture);
// Draw the faces
cmd.DrawProcedural(Matrix4x4.identity, parameters.debugMaterial, 1, MeshTopology.Lines, 48, 64 * 64 * 32, debugMaterialProperties);
cmd.DrawProcedural(Matrix4x4.identity, parameters.debugMaterial, 0, MeshTopology.Triangles, 36, 64 * 64 * 32, debugMaterialProperties);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// fetch a command buffer to use
CommandBuffer cmd = CommandBufferPool.Get(profilerTag);
cmd.Clear();
// if using MSAA we should resolve before looking for bright spots
if (isUsingMSAA)
{
RenderTargetIdentifier resolvedTargetIdent = new RenderTargetIdentifier(resolvedCameraColourID);
cmd.Blit(cameraColorIdent, resolvedTargetIdent);
cmd.SetComputeTextureParam(brightsCompute, findBrightsKernel, sourceTextureID, resolvedTargetIdent);
}
else
{
// if not using MSAA we can directly read from the camera's render target
cmd.SetComputeTextureParam(brightsCompute, findBrightsKernel, sourceTextureID, cameraColorIdent);
}
// Compute shader to find brightest pixels, limited to one per group thread region.
// When it finds a bright pixel record its details in the brightPoints buffer
cmd.SetComputeBufferParam(brightsCompute, findBrightsKernel, brightQuadsID, brightPoints);
cmd.SetComputeFloatParam(brightsCompute, luminanceThresholdID, luminanceThreshold);
// calculation of thread groups ensures the whole screen is covered
cmd.DispatchCompute(brightsCompute, findBrightsKernel,
Mathf.CeilToInt(cameraTextureDescriptor.width / groupSizeX),
Mathf.CeilToInt(cameraTextureDescriptor.height / groupSizeY),
1
);
// put brightPoints count into instanceCount slot of drawArgsBuffer
cmd.CopyCounterValue(brightPoints, drawArgsBuffer, sizeof(uint));
// earlier resolve Blit may have changed render target, so set it back
cmd.SetRenderTarget(cameraColorIdent);
// draw the quads described by brightsCompute
MaterialPropertyBlock properties = new MaterialPropertyBlock();
properties.SetBuffer(brightQuadsID, brightPoints);
properties.SetFloat(angleID, angle);
properties.SetFloat(widthRatioID, renderingData.cameraData.camera.aspect);
properties.SetFloat(screenSizeXID, cameraTextureDescriptor.width);
properties.SetFloat(screenSizeYID, cameraTextureDescriptor.height);
// it would make sense to use MeshTopology.Quads as we're drawing quads, but Unity docs say:
// "quad topology is emulated on many platforms, so it's more efficient to use a triangular mesh."
cmd.DrawProceduralIndirect(Matrix4x4.identity, flareMaterial, 0, MeshTopology.Triangles,
drawArgsBuffer, 0, properties);
// don't forget to tell ScriptableRenderContext to actually execute the commands
context.ExecuteCommandBuffer(cmd);
// tidy up after ourselves
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public void DrawMesh()
{
m_propertyBlock.SetBuffer("_MeshBuffer", m_meshBuffer);
m_propertyBlock.SetMatrix("_ObjectToWorld", m_chunkTransform.localToWorldMatrix);
m_propertyBlock.SetInt("_Lod", m_lod);
Graphics.DrawProcedural(m_meshMaterial, m_bounds, MeshTopology.Triangles, m_maxVertices, 1, null, m_propertyBlock, UnityEngine.Rendering.ShadowCastingMode.TwoSided);
}
protected void Update()
{
Reset();
CalculateNormal();
Build();
block.SetBuffer("_Buffer", vertexBuffer);
renderer.SetPropertyBlock(block);
}
public void Set(ComputeBuffer buffer)
{
var r = GetComponent <Renderer>();
var mpb = new MaterialPropertyBlock();
r.GetPropertyBlock(mpb);
mpb.SetBuffer(propName, buffer);
r.SetPropertyBlock(mpb);
}
