Exemple #1
0
        private void CoeffToRenderTexture(CommandBuffer buffer)
        {
            ComputeShader shader = pipelineRes.shaders.probeCoeffShader;

            buffer.SetComputeBufferParam(shader, coeffToTex3DKernel, ShaderIDs._Coeff, coeff);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[0], currentTexture.coeff0);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[1], currentTexture.coeff1);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[2], currentTexture.coeff2);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[3], currentTexture.coeff3);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[4], currentTexture.coeff4);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[5], currentTexture.coeff5);
            buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[6], currentTexture.coeff6);
            buffer.SetComputeVectorParam(shader, ShaderIDs._Tex3DSize, new float4(currentIrr.resolution.x, currentIrr.resolution.y, currentIrr.resolution.z, 1));
            ComputeShaderUtility.Dispatch(shader, buffer, coeffToTex3DKernel, len / 9, 64);
        }
        public static void MoveAllScenes(float3 delta, int offset, int clusterCount)
        {
            if (clusterCount <= 0)
            {
                return;
            }
            ComputeShader shad = resources.shaders.streamingShader;
            CommandBuffer cb   = RenderPipeline.BeforeFrameBuffer;

            cb.SetComputeIntParam(shad, ShaderIDs._Offset, offset);
            cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL_MOVE_ALL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
            cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL_MOVE_ALL, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
            cb.SetComputeVectorParam(shad, ShaderIDs._OffsetDirection, float4(delta, 1));
            ComputeShaderUtility.Dispatch(shad, cb, EXECUTE_CLUSTER_KERNEL_MOVE_ALL, clusterCount);
            cb.DispatchCompute(shad, EXECUTE_POINT_KERNEL_MOVE_ALL, clusterCount, 1, 1);
        }
        public override void FinishJob()
        {
            CommandBuffer buffer = RenderPipeline.BeforeFrameBuffer;
            ComputeBuffer temp   = currentPosBuffer;

            currentPosBuffer = lastPosBuffer;
            lastPosBuffer    = temp;
            buffer.SetComputeBufferParam(movingShader, 0, ShaderIDs._TransformMatrices, currentPosBuffer);
            buffer.SetComputeBufferParam(movingShader, 0, ShaderIDs._OriginTransformMatrices, originPosBuffer);
            buffer.SetComputeTextureParam(movingShader, 0, ShaderIDs._NoiseTexture, noiseTexture);
            buffer.SetComputeVectorParam(movingShader, ShaderIDs._OffsetDirection, transform.forward);
            offset += Time.deltaTime * runSpeed;
            offset  = frac(offset);
            buffer.SetComputeFloatParam(movingShader, ShaderIDs._Offset, offset * noiseTexture.height);
            buffer.SetComputeVectorParam(movingShader, ShaderIDs._NoiseTexture_Size, new Vector2(noiseTexture.width, noiseTexture.height));
            ComputeShaderUtility.Dispatch(movingShader, buffer, 0, currentPosBuffer.count);
        }
 public void DrawTerrain(CommandBuffer buffer, int pass, Vector4[] planes)
 {
     if (loadedBufferList.Length <= 0)
     {
         return;
     }
     buffer.SetComputeBufferParam(shader, 1, ShaderIDs._DispatchBuffer, dispatchDrawBuffer);
     buffer.SetComputeBufferParam(shader, 0, ShaderIDs._DispatchBuffer, dispatchDrawBuffer);
     buffer.SetComputeBufferParam(shader, 0, ShaderIDs._CullResultBuffer, culledResultsBuffer);
     buffer.SetComputeBufferParam(shader, 0, ShaderIDs._TerrainChunks, loadedBuffer);
     buffer.SetGlobalBuffer(ShaderIDs._TerrainChunks, loadedBuffer);
     buffer.SetGlobalVector(ShaderIDs._HeightScaleOffset, float4(terrainData.heightScale, terrainData.heightOffset, 1, 1));
     buffer.SetGlobalBuffer(ShaderIDs._CullResultBuffer, culledResultsBuffer);
     buffer.SetComputeVectorArrayParam(shader, ShaderIDs.planes, planes);
     buffer.DispatchCompute(shader, 1, 1, 1, 1);
     ComputeShaderUtility.Dispatch(shader, buffer, 0, loadedBufferList.Length);
     buffer.DrawProceduralIndirect(Matrix4x4.identity, terrainData.drawTerrainMaterial, pass, MeshTopology.Triangles, dispatchDrawBuffer);
 }
        public static void MoveScene(int sceneIndex, float3 deltaPosition, int clusterCount)
        {
            ComputeShader shad       = resources.shaders.streamingShader;
            ComputeBuffer tempBuffer = GetTempPropertyBuffer(clusterCount + 1, sizeof(uint));
            CommandBuffer cb         = RenderPipeline.BeforeFrameBuffer;

            cb.SetComputeIntParam(shad, ShaderIDs._TargetElement, sceneIndex);
            cb.SetComputeBufferParam(shad, CLEAR_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
            cb.SetComputeBufferParam(shad, COLLECT_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
            cb.SetComputeBufferParam(shad, COLLECT_KERNEL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
            cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
            cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
            cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
            cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
            cb.SetComputeVectorParam(shad, ShaderIDs._OffsetDirection, float4(deltaPosition, 1));
            cb.DispatchCompute(shad, CLEAR_KERNEL, 1, 1, 1);
            ComputeShaderUtility.Dispatch(shad, cb, COLLECT_KERNEL, baseBuffer.clusterCount);
            ComputeShaderUtility.Dispatch(shad, cb, EXECUTE_CLUSTER_KERNEL, clusterCount);
            cb.DispatchCompute(shad, EXECUTE_POINT_KERNEL, clusterCount, 1, 1);
        }
        public override void DrawClusterOccSingleCheck(ref RenderClusterOptions options, ref HizOptions hizOpts)
        {
            CommandBuffer buffer = options.command;

            buffer.SetComputeVectorParam(options.cullingShader, ShaderIDs._CameraUpVector, hizOpts.hizData.lastFrameCameraUp);
            buffer.SetComputeBufferParam(options.cullingShader, 5, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
            buffer.SetComputeTextureParam(options.cullingShader, 5, ShaderIDs._HizDepthTex, hizOpts.hizData.historyDepth);
            buffer.SetComputeVectorArrayParam(options.cullingShader, ShaderIDs.planes, options.frustumPlanes);
            buffer.SetComputeBufferParam(options.cullingShader, 5, ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
            buffer.SetComputeBufferParam(options.cullingShader, 5, ShaderIDs.instanceCountBuffer, baseBuffer.instanceCountBuffer);
            buffer.SetComputeBufferParam(options.cullingShader, PipelineBaseBuffer.ComputeShaderKernels.ClearClusterKernel, ShaderIDs.instanceCountBuffer, baseBuffer.instanceCountBuffer);
            ComputeShaderUtility.Dispatch(options.cullingShader, options.command, 5, baseBuffer.clusterCount, 256);
            hizOpts.hizData.lastFrameCameraUp = hizOpts.currentCameraUpVec;
            buffer.SetGlobalBuffer(ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
            buffer.SetGlobalBuffer(ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
            PipelineFunctions.RenderProceduralCommand(baseBuffer, options.proceduralMaterial, buffer);
            buffer.DispatchCompute(options.cullingShader, PipelineBaseBuffer.ComputeShaderKernels.ClearClusterKernel, 1, 1, 1);
            //TODO 绘制其他物体

            //TODO
            buffer.Blit(hizOpts.currentDepthTex, hizOpts.hizData.historyDepth, hizOpts.linearLODMaterial, 0);
            hizOpts.hizDepth.GetMipMap(hizOpts.hizData.historyDepth, buffer);
        }
        public override void DrawCubeMap(MPointLight lit, ref RenderClusterOptions opts, ref CubeCullingBuffer buffer, int offset)
        {
            CommandBuffer cb            = opts.command;
            ComputeShader shader        = opts.cullingShader;
            Material      depthMaterial = opts.proceduralMaterial;

            cb.SetComputeIntParam(shader, ShaderIDs._LightOffset, offset);
            ComputeShaderUtility.Dispatch(shader, cb, CubeFunction.RunFrustumCull, baseBuffer.clusterCount, 256);
            PerspCam cam = new PerspCam();

            cam.aspect        = 1;
            cam.farClipPlane  = lit.range;
            cam.nearClipPlane = 0.3f;
            cam.position      = lit.position;
            cam.fov           = 90f;
            Matrix4x4 vpMatrix;

            cb.SetGlobalVector(ShaderIDs._LightPos, new Vector4(lit.position.x, lit.position.y, lit.position.z, lit.range));
            cb.SetGlobalBuffer(ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
            cb.SetGlobalBuffer(ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
            //Forward
            cam.forward  = Vector3.forward;
            cam.up       = Vector3.down;
            cam.right    = Vector3.left;
            cam.position = lit.position;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeZ);
            cb.ClearRenderTarget(true, true, Color.white);
            cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
            offset = offset * 20;
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
            //Back
            cam.forward = Vector3.back;
            cam.up      = Vector3.down;
            cam.right   = Vector3.right;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveZ);
            cb.ClearRenderTarget(true, true, Color.white);
            cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
            //Up
            cam.forward = Vector3.up;
            cam.up      = Vector3.back;
            cam.right   = Vector3.right;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveY);
            cb.ClearRenderTarget(true, true, Color.white);
            cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
            //Down
            cam.forward = Vector3.down;
            cam.up      = Vector3.forward;
            cam.right   = Vector3.right;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeY);
            cb.ClearRenderTarget(true, true, Color.white);
            cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
            //Right
            cam.forward = Vector3.right;
            cam.up      = Vector3.down;
            cam.right   = Vector3.forward;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveX);
            cb.ClearRenderTarget(true, true, Color.white);
            cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
            //Left
            cam.forward = Vector3.left;
            cam.up      = Vector3.down;
            cam.right   = Vector3.back;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeX);
            cb.ClearRenderTarget(true, true, Color.white);
            cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
        }
Exemple #8
0
        public void RemoveQuadTrees(NativeList <ulong> removeList)
        {
            void ErasePoint(TerrainQuadTree.QuadTreeNode *node)
            {
                node->listPosition = -1;
                notUsedHeightmapIndices.Add(node->panel.heightMapIndex);
            }

            int length = removeList.Length;

            TerrainQuadTree.QuadTreeNode **tree = (TerrainQuadTree.QuadTreeNode * *)removeList.unsafePtr;
            int targetLength = referenceBuffer.Length - length;
            int len          = 0;

            if (targetLength <= 0)
            {
                for (int i = 0; i < length; ++i)
                {
                    ErasePoint(tree[i]);
                }
                referenceBuffer.Clear();
                return;
            }
            for (int i = 0; i < length; ++i)
            {
                TerrainQuadTree.QuadTreeNode *currentNode = tree[i];
                if (currentNode->listPosition >= targetLength)
                {
                    referenceBuffer[currentNode->listPosition] = 0;
                    ErasePoint(currentNode);
                }
            }
            NativeArray <int2> transformList = new NativeArray <int2>(length, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            int2 *transformPtr = transformList.Ptr();

            len = 0;
            int currentIndex = referenceBuffer.Length - 1;

            for (int i = 0; i < length; ++i)
            {
                TerrainQuadTree.QuadTreeNode *treeNode = tree[i];
                if (treeNode->listPosition < 0)
                {
                    continue;
                }
                while (referenceBuffer[currentIndex] == 0)
                {
                    currentIndex--;
                    if (currentIndex < 0)
                    {
                        goto FINALIZE;
                    }
                }
                TerrainQuadTree.QuadTreeNode *lastNode = (TerrainQuadTree.QuadTreeNode *)referenceBuffer[currentIndex];
                currentIndex--;
                transformPtr[len] = new int2(treeNode->listPosition, lastNode->listPosition);
                len++;
                lastNode->listPosition = treeNode->listPosition;
                referenceBuffer[lastNode->listPosition] = (ulong)lastNode;
                ErasePoint(treeNode);
            }
FINALIZE:
            referenceBuffer.RemoveLast(length);
            if (len <= 0)
            {
                return;
            }
            if (len > removebuffer.count)
            {
                removebuffer.Dispose();
                removebuffer = new ComputeBuffer(len, sizeof(int2));
            }
            removebuffer.SetData(transformList, 0, 0, len);
            transformShader.SetBuffer(0, ShaderIDs._IndexBuffer, removebuffer);
            transformShader.SetBuffer(0, ShaderIDs.clusterBuffer, clusterBuffer);
            ComputeShaderUtility.Dispatch(transformShader, 0, len, 64);
            transformList.Dispose();
        }
        public static void DrawShadow(MPointLight lit, CommandBuffer cb, MaterialPropertyBlock block, ref CubeCullingBuffer buffer, ref PipelineBaseBuffer baseBuffer, ComputeShader shader, int offset, Material depthMaterial)
        {
            cb.SetComputeIntParam(shader, ShaderIDs._LightOffset, offset);
            ComputeShaderUtility.Dispatch(shader, cb, RunFrustumCull, baseBuffer.clusterCount, 64);
            PerspCam cam = new PerspCam();

            cam.aspect        = 1;
            cam.farClipPlane  = lit.range;
            cam.nearClipPlane = 0.3f;
            cam.position      = lit.position;
            cam.fov           = 90f;
            Matrix4x4 vpMatrix;

            block.SetVector(ShaderIDs._LightPos, new Vector4(lit.position.x, lit.position.y, lit.position.z, lit.range));
            PipelineFunctions.SetShaderBuffer(ref baseBuffer, block);
            //Forward
            cam.forward  = Vector3.forward;
            cam.up       = Vector3.down;
            cam.right    = Vector3.left;
            cam.position = lit.position;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeZ);
            cb.ClearRenderTarget(true, true, Color.white);
            block.SetMatrix(ShaderIDs._VP, vpMatrix);
            offset = offset * 20;
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
            //Back
            cam.forward = Vector3.back;
            cam.up      = Vector3.down;
            cam.right   = Vector3.right;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveZ);
            cb.ClearRenderTarget(true, true, Color.white);
            block.SetMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
            //Up
            cam.forward = Vector3.up;
            cam.up      = Vector3.back;
            cam.right   = Vector3.right;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveY);
            cb.ClearRenderTarget(true, true, Color.white);
            block.SetMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
            //Down
            cam.forward = Vector3.down;
            cam.up      = Vector3.forward;
            cam.right   = Vector3.right;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeY);
            cb.ClearRenderTarget(true, true, Color.white);
            block.SetMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
            //Right
            cam.forward = Vector3.right;
            cam.up      = Vector3.down;
            cam.right   = Vector3.forward;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveX);
            cb.ClearRenderTarget(true, true, Color.white);
            block.SetMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
            //Left
            cam.forward = Vector3.left;
            cam.up      = Vector3.down;
            cam.right   = Vector3.back;
            cam.UpdateTRSMatrix();
            cam.UpdateProjectionMatrix();
            vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
            cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeX);
            cb.ClearRenderTarget(true, true, Color.white);
            block.SetMatrix(ShaderIDs._VP, vpMatrix);
            cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
        }