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); }