Exemplo n.º 1
0
        protected override void Render(ScriptableRenderContext context, Camera[] cameras)
        {
            BeginFrameRendering(context, cameras);
            foreach (var RenderCamera in cameras)
            {
#if UNITY_EDITOR
                //seting UI in SceneEdit
                bool isSceneViewCam = RenderCamera.cameraType == CameraType.SceneView;
                if (isSceneViewCam)
                {
                    ScriptableRenderContext.EmitWorldGeometryForSceneView(RenderCamera);
                }
#endif

                //////Set Camera Property
                BeginCameraRendering(context, RenderCamera);
                context.SetupCameraProperties(RenderCamera);

                /////Cull Object
                ScriptableCullingParameters cullingParameters;
                if (!RenderCamera.TryGetCullingParameters(out cullingParameters))
                {
                    continue;
                }

                CullingResults CullingData = context.Cull(ref cullingParameters);

                //Drwa PipeLine Pass
                RenderingContent(isSceneViewCam, RenderCamera, CullingData, context);

                ///Submit RenderContent
                context.Submit();
                EndCameraRendering(context, RenderCamera);
            }
        }
        protected override void Render(ScriptableRenderContext RenderContext, Camera[] RenderCameras)
        {
            //Gather MeshBatch
            NativeList <FMeshBatch> MeshBatchList = GetWorld().GetMeshBatchColloctor().GetMeshBatchList();

            //Render Pipeline
            BeginFrameRendering(RenderContext, RenderCameras);
            foreach (Camera RenderCamera in RenderCameras)
            {
                RenderCamera.allowHDR = true;

                bool isSceneViewCam = RenderCamera.cameraType == CameraType.SceneView;
                #if UNITY_EDITOR
                if (isSceneViewCam)
                {
                    ScriptableRenderContext.EmitWorldGeometryForSceneView(RenderCamera);
                }
                #endif

                //Prepare VisualEffects
                VFXManager.PrepareCamera(RenderCamera);

                //Prepare ViewUnifrom
                ViewUnifrom.UnpateBufferData(false, RenderCamera);

                //View RenderFamily
                CommandBuffer CmdBuffer = CommandBufferPool.Get("");

                //Binding ViewParameter
                BeginCameraRendering(RenderContext, RenderCamera);
                CmdBuffer.DisableScissorRect();
                ViewUnifrom.BindGPUProperty(CmdBuffer);
                RenderContext.SetupCameraProperties(RenderCamera);

                //Binding VisualEffects
                VFXManager.ProcessCameraCommand(RenderCamera, CmdBuffer);

                //Culling MeshBatch
                NativeArray <FPlane>            ViewFrustum          = new NativeArray <FPlane>(6, Allocator.Persistent);
                NativeArray <FVisibleMeshBatch> VisibleMeshBatchList = new NativeArray <FVisibleMeshBatch>(MeshBatchList.Length, Allocator.TempJob);

                Plane[] FrustumPlane = GeometryUtility.CalculateFrustumPlanes(RenderCamera);
                for (int PlaneIndex = 0; PlaneIndex < 6; PlaneIndex++)
                {
                    ViewFrustum[PlaneIndex] = FrustumPlane[PlaneIndex];
                }

                CullMeshBatch CullTask = new CullMeshBatch();
                {
                    CullTask.ViewFrustum          = ViewFrustum;
                    CullTask.ViewOrigin           = RenderCamera.transform.position;
                    CullTask.MeshBatchList        = MeshBatchList;
                    CullTask.VisibleMeshBatchList = VisibleMeshBatchList;
                }
                JobHandle CullTaskHandle = CullTask.Schedule(MeshBatchList.Length, 256);

                /*SortMeshBatch SortTask = new SortMeshBatch();
                 * {
                 *  SortTask.VisibleMeshBatchList = VisibleMeshBatchList;
                 * }
                 * JobHandle SortTaskHandle = SortTask.Schedule(CullTaskHandle);*/

                //Culling Context
                ScriptableCullingParameters CullingParameter;
                RenderCamera.TryGetCullingParameters(out CullingParameter);
                CullingResults CullingResult = RenderContext.Cull(ref CullingParameter);

                CullTaskHandle.Complete();
                //SortTaskHandle.Complete();

                //Render Family
                RenderOpaqueDepth(RenderCamera, CullingResult);
                RenderOpaqueGBuffer(RenderCamera, CullingResult, VisibleMeshBatchList);
                RenderOpaqueMotion(RenderCamera, CullingResult);
                RenderSkyAtmosphere(RenderCamera);
                RenderPresentView(RenderCamera, GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_ThinGBufferA), RenderCamera.targetTexture);

                //Draw DrawGizmos
                #if UNITY_EDITOR
                if (Handles.ShouldRenderGizmos())
                {
                    RenderGizmo(RenderCamera, GizmoSubset.PostImageEffects);
                }
                #endif

                //Execute RenderGraph
                GraphBuilder.Execute(RenderContext, GetWorld(), CmdBuffer, ViewUnifrom.FrameIndex);
                EndCameraRendering(RenderContext, RenderCamera);

                //Execute ViewRender
                RenderContext.ExecuteCommandBuffer(CmdBuffer);
                CommandBufferPool.Release(CmdBuffer);
                RenderContext.Submit();

                //Prepare ViewUnifrom
                ViewUnifrom.UnpateBufferData(true, RenderCamera);

                //Release View
                ViewFrustum.Dispose();
                VisibleMeshBatchList.Dispose();
            }
            EndFrameRendering(RenderContext, RenderCameras);
        }