public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { storeDataHandler.Complete(); int count = Mathf.Min(maximumProbe, reflectProbes.Length); reflectionEnabled = (count > 0); if (!reflectionEnabled) { return; } CommandBuffer buffer = data.buffer; ComputeShader cullingShader = data.resources.shaders.reflectionCullingShader; ref CBDRSharedData cbdr = ref lightingEvents.cbdr;
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { RenderTargetIdentifier source, dest; PipelineFunctions.RunPostProcess(ref cam.targets, out source, out dest); data.buffer.BlitSRT(source, dest, ShaderIDs._DepthBufferTexture, lightingMaterial, 0); data.buffer.BlitSRT(source, dest, ShaderIDs._DepthBufferTexture, lightingMaterial, 1); //Calculate CBDR DirLight(cam, ref data); PointLight(cam, ref data); //Calculate Lighting data.buffer.BlitSRTWithDepth(cam.targets.renderTargetIdentifier, ShaderIDs._DepthBufferTexture, lightingMaterial, 2); LightFilter.Clear(); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { Graphics.SetRenderTarget(cam.depthTexture.colorBuffer, cam.renderTarget.depthBuffer); GL.Clear(true, true, Color.black); Shader.SetGlobalTexture(_CameraDepthTexture, cam.depthTexture); int childCount = transformParent.childCount; gbufferMaterial.SetPass(0); for (int i = 0; i < childCount; ++i) { Transform tr = transformParent.GetChild(i); MeshFilter filter = tr.GetComponent <MeshFilter>(); Graphics.DrawMeshNow(filter.sharedMesh, tr.localToWorldMatrix); } }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data, CommandBuffer buffer) { buffer.SetRenderTarget(cam.targets.renderTargetIdentifier, cam.targets.depthIdentifier); cullJobHandler.Complete(); UnsafeUtility.ReleaseGCObject(gcHandler); //Use Result Indices foreach (int i in cullJob.resultIndices) { ReflectionCube cube = ReflectionCube.allCubes[i]; block.SetTexture(_ReflectionProbe, cube.reflectionCube); buffer.DrawMesh(GraphicsUtility.cubeMesh, cube.localToWorld, reflectMaterial, 0, 0, block); } //TODO cullJob.resultIndices.Dispose(); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; RenderClusterOptions options = new RenderClusterOptions { command = buffer, frustumPlanes = data.frustumPlanes, cullingShader = data.resources.shaders.gpuFrustumCulling, terrainCompute = data.resources.shaders.terrainCompute }; SceneController.DrawCluster(ref options, ref cam.targets, ref data, cam.cam); // buffer.Blit(cam.targets.gbufferIdentifier[2], BuiltinRenderTextureType.CameraTarget); }
public override void FrameUpdate(PipelineCamera camera, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; handle.Complete(); SkyboxPreviewMatrix last = IPerCameraData.GetProperty(camera, () => new SkyboxPreviewMatrix()); buffer.SetGlobalMatrix(_LastSkyVP, last.lastViewProj); targetIdentifiers[0] = camera.targets.renderTargetIdentifier; targetIdentifiers[1] = ShaderIDs._CameraMotionVectorsTexture; buffer.SetRenderTarget(colors: targetIdentifiers, depth: ShaderIDs._DepthBufferTexture); data.ExecuteCommandBuffer(); data.context.DrawSkybox(camera.cam); last.lastViewProj = job.viewProj; }
public override void FrameUpdate(PipelineCamera camera, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; handle.Complete(); SkyboxPreviewMatrix last = IPerCameraData.GetProperty(camera, () => new SkyboxPreviewMatrix()); buffer.SetGlobalMatrix(_InvSkyVP, job.invViewProj); buffer.SetGlobalMatrix(_LastSkyVP, last.lastViewProj); targetIdentifiers[0] = camera.targets.renderTargetIdentifier; targetIdentifiers[1] = ShaderIDs._CameraMotionVectorsTexture; buffer.SetRenderTarget(colors: targetIdentifiers, depth: ShaderIDs._DepthBufferTexture); buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, skyboxMaterial, 0, 0); last.lastViewProj = job.viewProj; }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; cullJobHandler.Complete(); UnsafeUtility.ReleaseGCObject(gcHandler); pointLightMaterial.SetBuffer(ShaderIDs.verticesBuffer, sphereBuffer); //Un Shadow Point light buffer.SetRenderTarget(cam.targets.renderTargetIdentifier, cam.targets.depthIdentifier); for (int c = 0; c < unShadowCount; c++) { var i = cullJob.indices[cullJob.length - c]; MPointLight light = MPointLight.allPointLights[i]; block.SetVector(ShaderIDs._LightColor, light.color); block.SetVector(ShaderIDs._LightPos, new Vector4(light.position.x, light.position.y, light.position.z, light.range)); block.SetFloat(ShaderIDs._LightIntensity, light.intensity); buffer.DrawProceduralIndirect(Matrix4x4.identity, pointLightMaterial, 0, MeshTopology.Triangles, sphereIndirectBuffer, 0, block); } //TODO if (shadowCount > 0) { NativeArray <Vector4> positions = new NativeArray <Vector4>(shadowCount, Allocator.Temp, NativeArrayOptions.UninitializedMemory); for (int i = 0; i < shadowCount; i++) { MPointLight light = MPointLight.allPointLights[cullJob.indices[i]]; positions[i] = new Vector4(light.position.x, light.position.y, light.position.z, light.range); } CubeFunction.UpdateLength(ref cubeBuffer, shadowCount); var cullShader = data.resources.pointLightFrustumCulling; CubeFunction.SetBuffer(ref cubeBuffer, ref data.baseBuffer, cullShader, buffer); CubeFunction.PrepareDispatch(ref cubeBuffer, buffer, cullShader, positions); for (int i = 0; i < shadowCount; i++) { MPointLight light = MPointLight.allPointLights[cullJob.indices[i]]; CubeFunction.DrawShadow(light, buffer, block, ref cubeBuffer, ref data.baseBuffer, cullShader, i, cubeDepthMaterial); buffer.SetRenderTarget(cam.targets.renderTargetIdentifier, cam.targets.depthIdentifier); block.Clear(); block.SetVector(ShaderIDs._LightColor, light.color); block.SetVector(ShaderIDs._LightPos, positions[i]); block.SetFloat(ShaderIDs._LightIntensity, light.intensity); block.SetTexture(ShaderIDs._CubeShadowMap, light.shadowmapTexture); buffer.DrawProceduralIndirect(Matrix4x4.identity, pointLightMaterial, 1, MeshTopology.Triangles, sphereIndirectBuffer, 0, block); } positions.Dispose(); } //Shadow Point Light indicesArray.Dispose(); }
private void PointLight(PipelineCamera cam, ref PipelineCommandData data) { shadowCullHandle.Complete(); CommandBuffer buffer = data.buffer; VoxelLightCommonData(buffer, cam.cam); lightingHandle.Complete(); foreach (var i in addMLightCommandList) { MLight.AddMLight(i); } foreach (var i in needCheckedShadows) { MLight mlt = MUnsafeUtility.GetObject <MLight>(i.mlight.ToPointer()); mlt.CheckShadowSetting(i.isAvaliable); } addMLightCommandList.Clear(); int count = Mathf.Min(cubemapVPMatrices.Length, CBDRSharedData.MAXIMUMPOINTLIGHTCOUNT); cbdr.pointshadowCount = count; //Calculate PointLight Shadow if (LightFilter.pointLightCount > 0) { if (count > 0) { var cullShader = data.resources.shaders.gpuFrustumCulling; buffer.SetGlobalTexture(ShaderIDs._CubeShadowMapArray, cbdr.cubeArrayMap); NativeArray <VisibleLight> allLights = proper.cullResults.visibleLights; PointLightStruct * pointLightPtr = pointLightArray.Ptr(); for (int i = 0; i < count; ++i) { ref CubemapViewProjMatrix vpMatrices = ref cubemapVPMatrices[i]; int2 lightIndex = vpMatrices.index; Light lt = allLights[lightIndex.y].light; MLight light = MUnsafeUtility.GetObject <MLight>(vpMatrices.mLightPtr); light.CheckShadowCamera(); ref PointLightStruct ptLitStr = ref pointLightPtr[lightIndex.x]; if (!light.useShadowCache || light.updateShadowCache) { light.updateShadowCache = false; SceneController.DrawPointLight(light, localLightShadowLayer, ref ptLitStr, cubeDepthMaterial, buffer, cullShader, i, ref data, cubemapVPMatrices.unsafePtr, cbdr.cubeArrayMap, cam.inverseRender, proper.overrideOpaqueMaterial); } ptLitStr.shadowIndex = light.ShadowIndex; //TODO //Multi frame shadowmap } }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; sharedData.autoExposureTexture = RuntimeUtilities.whiteTexture; sharedData.screenSize = new Vector2Int(cam.cam.pixelWidth, cam.cam.pixelHeight); sharedData.uberMaterial.SetTexture(PostProcessing.ShaderIDs.AutoExposureTex, sharedData.autoExposureTexture); renderAction(ref data); if (sharedData.keywordsTransformed) { sharedData.keywordsTransformed = false; sharedData.uberMaterial.shaderKeywords = sharedData.shaderKeywords.ToArray(); } PostFunctions.RunPostProcess(ref cam.targets, buffer, ref data, uberAction); PipelineFunctions.ReleaseRenderTarget(sharedData.temporalRT); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { handle.Complete(); lastViewProjection = calculateJob.lastVP; inverseLastViewProjection = calculateJob.lastInverseVP; CommandBuffer buffer = data.buffer; buffer.SetKeyword("RENDERING_TEXTURE", cam.cam.targetTexture != null); buffer.SetGlobalMatrix(ShaderIDs._LastVp, lastViewProjection); buffer.SetGlobalMatrix(ShaderIDs._NonJitterVP, calculateJob.nonJitterVP); buffer.SetGlobalMatrix(ShaderIDs._NonJitterTextureVP, calculateJob.nonJitterTextureVP); buffer.SetGlobalMatrix(ShaderIDs._InvNonJitterVP, calculateJob.nonJitterInverseVP); buffer.SetGlobalMatrix(ShaderIDs._InvVP, inverseVP); buffer.SetGlobalVector(ShaderIDs._RandomSeed, calculateJob.randNumber); lastData.lastVP = calculateJob.nonJitterVP; }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { //Press Space To Start Tracing if (pressSpace) { pressSpace = false; Matrix4x4 invvp = GL.GetGPUProjectionMatrix(cam.cam.projectionMatrix, true) * cam.cam.worldToCameraMatrix; invvp = invvp.inverse; traceMat.SetMatrix(ShaderIDs._InvVP, invvp); traceMat.SetTexture(ShaderIDs._EnvMap, environmentMap); Graphics.SetRenderTarget(cam.renderTarget); GL.Clear(true, true, Color.black); traceMat.SetPass(0); Graphics.DrawMeshNow(GraphicsUtility.mesh, Matrix4x4.identity); } }
public void PreRenderFrame(ref PipelineCommandData data) { if (IrradianceVolumeController.current == null) { return; } NativeList <LoadedIrradiance> allVolume = IrradianceVolumeController.current.loadedIrradiance; cullingResult = new NativeList <int>(allVolume.Length, Allocator.Temp); handle = new IrradianceVolumeCulling { cameraFrustum = (float4 *)UnsafeUtility.AddressOf(ref data.frustumPlanes[0]), irradiance = allVolume.unsafePtr, result = cullingResult }.Schedule(allVolume.Length, 32); }
public void PreRender(ref PipelineCommandData data, PropertySetEvent proper) { if (!AreaVolumeProbe.allAreaLight.isCreated) { return; } areaCullResult = new NativeArray <AreaLight>(AreaVolumeProbe.allAreaLight.Length, Allocator.Temp); job = new VolJob { count = 0, light = areaCullResult.Ptr(), allArea = AreaVolumeProbe.allAreaLight.unsafePtr, planes = (float4 *)proper.frustumPlanes.Ptr() }; jobHandle = job.ScheduleRefBurst(AreaVolumeProbe.allAreaLight.Length, 32); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { if (!enabledPost) { data.buffer.Blit(cam.targets.renderTargetIdentifier, cam.cameraTarget); return; } #if UNITY_EDITOR if (!enableInEditor && RenderPipeline.renderingEditor) { data.buffer.Blit(cam.targets.renderTargetIdentifier, cam.cameraTarget); return; } #endif postContext.camera = cam.cam; postContext.command = data.buffer; postContext.sourceFormat = RenderTextureFormat.ARGBHalf; postContext.autoExposureTexture = RuntimeUtilities.whiteTexture; postContext.bloomBufferNameID = -1; RenderTargetIdentifier source, dest; postContext.source = cam.targets.renderTargetIdentifier; postContext.destination = cam.targets.backupIdentifier; postContext.logHistogram.Generate(postContext); foreach (var i in allPostEffects) { PostProcessEffectSettings setting; if (allSettings.TryGetValue(i.type, out setting)) { if (i.needBlit && setting.active) { PipelineFunctions.RunPostProcess(ref cam.targets, out source, out dest); postContext.source = source; postContext.destination = dest; } i.renderer.SetSettings(setting); i.renderer.Render(postContext); } } ; cyberColor.FrameUpdate(data.buffer); data.buffer.BlitSRT(cam.targets.renderTargetIdentifier, cam.cameraTarget, postContext.uberSheet.material, 0, postContext.uberSheet.properties); if (postContext.bloomBufferNameID > -1) { data.buffer.ReleaseTemporaryRT(postContext.bloomBufferNameID); } }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { data.buffer.SetRenderTarget(BuiltinRenderTextureType.CameraTarget); data.buffer.ClearRenderTarget(true, true, Color.black); data.ExecuteCommandBuffer(); //Execute the commandbuffer, buffer will be automatically cleared after executed FilterRenderersSettings filterSettings = new FilterRenderersSettings(true); filterSettings.excludeMotionVectorObjects = false; filterSettings.layerMask = cam.cam.cullingMask; filterSettings.renderQueueRange = RenderQueueRange.opaque; DrawRendererSettings drawSettings = new DrawRendererSettings(cam.cam, new ShaderPassName("Unlit")); drawSettings.flags = DrawRendererFlags.EnableDynamicBatching; drawSettings.rendererConfiguration = RendererConfiguration.None; drawSettings.sorting.flags = SortFlags.CommonOpaque; data.context.DrawRenderers(data.cullResults.visibleRenderers, ref drawSettings, filterSettings); }
private static void RenderScene(ref PipelineCommandData data, Camera cam) { data.ExecuteCommandBuffer(); FilteringSettings renderSettings = new FilteringSettings(); renderSettings.renderQueueRange = RenderQueueRange.opaque; renderSettings.layerMask = cam.cullingMask; renderSettings.renderingLayerMask = (uint)cam.cullingMask; DrawingSettings dsettings = new DrawingSettings(new ShaderTagId("GBuffer"), new SortingSettings(cam)) { enableDynamicBatching = true, enableInstancing = false, perObjectData = UnityEngine.Rendering.PerObjectData.MotionVectors }; data.context.DrawRenderers(data.cullResults, ref dsettings, ref renderSettings); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; handle.Complete(); kernelBuffer.SetData(kernel); kernel.Dispose(); buffer.SetGlobalFloat(ShaderIDs._SSSScale, SubsurfaceScaler); buffer.SetGlobalBuffer(ShaderIDs._Kernel, kernelBuffer); RenderTargetIdentifier source, dest; PipelineFunctions.RunPostProcess(ref cam.targets, out source, out dest); buffer.BlitSRT(source, dest, ShaderIDs._DepthBufferTexture, mat, 0); PipelineFunctions.RunPostProcess(ref cam.targets, out source, out dest); buffer.BlitSRT(source, dest, ShaderIDs._DepthBufferTexture, mat, 1); }
private void DirLight(PipelineCamera cam, ref PipelineCommandData data) { if (SunLight.current == null || !SunLight.current.enabled) { return; } cbdr.lightFlag |= 0b100; if (SunLight.current.enableShadow) { cbdr.lightFlag |= 0b010; } CommandBuffer buffer = data.buffer; if (SunLight.current.enableShadow) { RenderClusterOptions opts = new RenderClusterOptions { frustumPlanes = shadowFrustumVP, command = buffer, cullingShader = data.resources.shaders.gpuFrustumCulling, }; buffer.SetGlobalVector(ShaderIDs._ShadowDisableDistance, new Vector4(SunLight.current.firstLevelDistance, SunLight.current.secondLevelDistance, SunLight.current.thirdLevelDistance, SunLight.current.farestDistance));//Only Mask buffer.SetGlobalVector(ShaderIDs._SoftParam, SunLight.current.cascadeSoftValue / SunLight.current.resolution); float *cascadeShadowmap = stackalloc float[4]; cascadeShadowmap[0] = 0; float maxCascadeLevel = SunLight.CASCADELEVELCOUNT - 1; for (int i = 1; i < 4; ++i) { cascadeShadowmap[i] = min(maxCascadeLevel, i); } buffer.SetGlobalVector(ShaderIDs._CascadeShadowWeight, *(float4 *)cascadeShadowmap); sunCullResultHandle.Complete(); SceneController.DrawDirectionalShadow(cam, ref data, ref opts, clipDistances, sunShadowCams, cascadeShadowMapVP, proper.overrideOpaqueMaterial); buffer.SetGlobalMatrixArray(ShaderIDs._ShadowMapVPs, cascadeShadowMapVP); buffer.SetGlobalTexture(ShaderIDs._DirShadowMap, SunLight.current.shadowmapTexture); cbdr.dirLightShadowmap = SunLight.current.shadowmapTexture; staticFit.frustumCorners.Dispose(); } buffer.SetGlobalVector(ShaderIDs._DirLightFinalColor, SunLight.current.light.color * SunLight.current.light.intensity); buffer.SetGlobalVector(ShaderIDs._DirLightPos, -SunLight.current.transform.forward); }
public override void PreRenderFrame(PipelineCamera cam, ref PipelineCommandData data) { HistoryTexture.GetHistoryTexture getHis = new HistoryTexture.GetHistoryTexture { cam = cam.cam }; texComponent = IPerCameraData.GetProperty <HistoryTexture, HistoryTexture.GetHistoryTexture>(cam, getHis); PreviousDepthData.GetPreviousDepthData getDepthData = new PreviousDepthData.GetPreviousDepthData { currentSize = new Vector2Int(cam.cam.pixelWidth, cam.cam.pixelHeight) }; prevDepthData = IPerCameraData.GetProperty <PreviousDepthData, PreviousDepthData.GetPreviousDepthData>(cam, getDepthData); prevDepthData.targetObject = this; data.buffer.SetGlobalVector(ShaderIDs._LastJitter, texComponent.jitter); cam.cam.ResetProjectionMatrix(); ConfigureJitteredProjectionMatrix(cam.cam, ref texComponent.jitter); data.buffer.SetGlobalVector(ShaderIDs._Jitter, texComponent.jitter); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data, CommandBuffer buffer) { HistoryTexture texComponent = IPerCameraData.GetProperty <HistoryTexture>(cam, GetHistoryTex); texComponent.UpdateProperty(cam); SetHistory(cam.cam, buffer, ref texComponent.historyTex, cam.targets.renderTarget); historyTex = texComponent.historyTex; //TAA Start const float kMotionAmplification_Blending = 100f * 60f; const float kMotionAmplification_Bounding = 100f * 30f; block.SetVector(ShaderIDs._Jitter, jitter); block.SetFloat(ShaderIDs._Sharpness, sharpness); block.SetVector(ShaderIDs._TemporalClipBounding, new Vector4(stationaryAABBScale, motionAABBScale, kMotionAmplification_Bounding, 0f)); block.SetVector(ShaderIDs._FinalBlendParameters, new Vector4(stationaryBlending, motionBlending, kMotionAmplification_Blending, 0f)); block.SetTexture(ShaderIDs._HistoryTex, historyTex); PostFunctions.RunPostProcess(ref cam.targets, buffer, ref data, taaFunction); }
private static void RenderScene(ref PipelineCommandData data, Camera cam) { data.ExecuteCommandBuffer(); FilterRenderersSettings renderSettings = new FilterRenderersSettings(true) { renderQueueRange = RenderQueueRange.opaque, layerMask = cam.cullingMask }; data.defaultDrawSettings.SetShaderPassName(0, new ShaderPassName("GBuffer")); data.defaultDrawSettings.sorting = new DrawRendererSortSettings { flags = SortFlags.CommonOpaque, sortMode = DrawRendererSortMode.Perspective, cameraPosition = cam.transform.position }; data.defaultDrawSettings.rendererConfiguration = RendererConfiguration.PerObjectMotionVectors; data.context.DrawRenderers(data.cullResults.visibleRenderers, ref data.defaultDrawSettings, renderSettings); }
private void DirLight(PipelineCamera cam, ref PipelineCommandData data) { if (SunLight.current == null || !SunLight.current.enabled) { return; } cbdr.lightFlag |= 0b100; if (SunLight.current.enableShadow) { cbdr.lightFlag |= 0b010; } CommandBuffer buffer = data.buffer; int pass; if (SunLight.current.enableShadow) { RenderClusterOptions opts = new RenderClusterOptions { frustumPlanes = shadowFrustumVP, command = buffer, cullingShader = data.resources.gpuFrustumCulling, isOrtho = true }; buffer.SetGlobalVector(ShaderIDs._NormalBiases, SunLight.current.normalBias); //Only Depth buffer.SetGlobalVector(ShaderIDs._ShadowDisableDistance, new Vector4(SunLight.current.firstLevelDistance, SunLight.current.secondLevelDistance, SunLight.current.thirdLevelDistance, SunLight.current.farestDistance));//Only Mask buffer.SetGlobalVector(ShaderIDs._SoftParam, SunLight.current.cascadeSoftValue / SunLight.current.resolution); SceneController.DrawDirectionalShadow(cam.cam, ref data, ref opts, SunLight.current, cascadeShadowMapVP); buffer.SetGlobalMatrixArray(ShaderIDs._ShadowMapVPs, cascadeShadowMapVP); buffer.SetGlobalTexture(ShaderIDs._DirShadowMap, SunLight.current.shadowmapTexture); cbdr.dirLightShadowmap = SunLight.current.shadowmapTexture; pass = 0; } else { pass = 1; } buffer.SetGlobalVector(ShaderIDs._DirLightFinalColor, SunLight.current.light.color * SunLight.current.light.intensity); buffer.SetGlobalVector(ShaderIDs._DirLightPos, -(Vector3)SunLight.current.shadCam.forward); buffer.SetRenderTarget(cam.targets.renderTargetIdentifier, cam.targets.depthIdentifier); buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, shadMaskMaterial, 0, pass); }
public override void PreRenderFrame(PipelineCamera cam, ref PipelineCommandData data) { var visLights = data.cullResults.visibleLights; LightFilter.allVisibleLight = visLights.Ptr(); allLights.Clear(); cbdr.UpdateFroxel(volumetricEvent && volumetricEvent.Enabled); foreach (var i in visLights) { allLights.Add(i.light); } addMLightCommandList.Clear(); LightFilter.allMLightCommandList = addMLightCommandList; pointLightArray = new NativeArray <PointLightStruct>(visLights.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory); spotLightArray = new NativeArray <SpotLight>(visLights.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory); cubemapVPMatrices = new NativeList <CubemapViewProjMatrix>(CBDRSharedData.MAXIMUMPOINTLIGHTCOUNT, Allocator.Temp); spotLightMatrices = new NativeList <SpotLightMatrix>(CBDRSharedData.MAXIMUMSPOTLIGHTCOUNT, Allocator.Temp); LightFilter.allLights = allLights; LightFilter.pointLightArray = pointLightArray; LightFilter.spotLightArray = spotLightArray; LightFilter.cubemapVPMatrices = cubemapVPMatrices; LightFilter.spotLightMatrices = spotLightMatrices; lightingHandle = (new LightFilter()).Schedule(allLights.Count, 1); if (SunLight.current != null && SunLight.current.enabled && SunLight.current.enableShadow) { clipDistances = (float *)UnsafeUtility.Malloc(SunLight.CASCADECLIPSIZE * sizeof(float), 16, Allocator.Temp); staticFit = DirectionalShadowStaticFit(cam.cam, SunLight.current, clipDistances); cascadeWorldToCamera = (float4x4 *)UnsafeUtility.Malloc(SunLight.CASCADELEVELCOUNT * sizeof(float4x4), 16, Allocator.Temp); cascadeProjection = (float4x4 *)UnsafeUtility.Malloc(SunLight.CASCADELEVELCOUNT * sizeof(float4x4), 16, Allocator.Temp); PipelineFunctions.GetfrustumCorners(clipDistances, SunLight.CASCADELEVELCOUNT + 1, cam.cam, staticFit.frustumCorners.Ptr()); csmStruct = new CascadeShadowmap { cascadeShadowmapVPs = (float4x4 *)cascadeShadowMapVP.Ptr(), cascadeProjection = cascadeProjection, cascadeWorldToCamera = cascadeWorldToCamera, orthoCam = (OrthoCam *)UnsafeUtility.AddressOf(ref SunLight.current.shadCam), farClipPlane = SunLight.current.farestZ, frustumCorners = staticFit.frustumCorners.Ptr(), resolution = staticFit.resolution, isD3D = GraphicsUtility.platformIsD3D }; csmHandle = csmStruct.ScheduleRefBurst(SunLight.CASCADELEVELCOUNT, 1); } }
private void DirLight(PipelineCamera cam, ref PipelineCommandData data) { if (SunLight.current == null || !SunLight.current.enabled) { return; } cbdr.lightFlag |= 0b100; if (SunLight.current.enableShadow) { cbdr.lightFlag |= 0b010; } CommandBuffer buffer = data.buffer; int pass; if (SunLight.current.enableShadow) { RenderClusterOptions opts = new RenderClusterOptions { frustumPlanes = shadowFrustumVP, command = buffer, cullingShader = data.resources.shaders.gpuFrustumCulling, }; buffer.SetGlobalVector(ShaderIDs._NormalBiases, SunLight.current.normalBias); //Only Depth buffer.SetGlobalVector(ShaderIDs._ShadowDisableDistance, new Vector4(SunLight.current.firstLevelDistance, SunLight.current.secondLevelDistance, SunLight.current.thirdLevelDistance, SunLight.current.farestDistance));//Only Mask buffer.SetGlobalVector(ShaderIDs._SoftParam, SunLight.current.cascadeSoftValue / SunLight.current.resolution); csmHandle.Complete(); SceneController.DrawDirectionalShadow(cam, ref staticFit, ref data, ref opts, clipDistances, cascadeWorldToCamera, cascadeProjection); buffer.SetGlobalMatrixArray(ShaderIDs._ShadowMapVPs, cascadeShadowMapVP); buffer.SetGlobalTexture(ShaderIDs._DirShadowMap, SunLight.current.shadowmapTexture); cbdr.dirLightShadowmap = SunLight.current.shadowmapTexture; staticFit.frustumCorners.Dispose(); pass = 0; } else { pass = 1; } buffer.SetGlobalVector(ShaderIDs._DirLightFinalColor, SunLight.current.light.color * SunLight.current.light.intensity); buffer.SetGlobalVector(ShaderIDs._DirLightPos, -(Vector3)SunLight.current.shadCam.forward); }
public override void PreRenderFrame(PipelineCamera cam, ref PipelineCommandData data) { reflectProbes = proper.cullResults.visibleReflectionProbes; reflectionData = new NativeArray <ReflectionData>(Mathf.Min(maximumProbe, reflectProbes.Length), Allocator.Temp, NativeArrayOptions.UninitializedMemory); storeRef = new StoreReflectionData { data = reflectionData.Ptr(), allProbes = reflectProbes.Ptr(), count = 0, camPos = cam.cam.transform.position, dist = availiableDistance, maximumProbe = maximumProbe }; storeDataHandler = storeRef.ScheduleRefBurst(reflectProbes.Length, 32); if (ssrEvents.enabled && !RenderPipeline.renderingEditor) { ssrEvents.PreRender(cam); } }
public override void PreRenderFrame(PipelineCamera cam, ref PipelineCommandData data) { reflectProbes = proper.cullResults.visibleReflectionProbes; reflectionData = new NativeArray <ReflectionData>(reflectProbes.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory); storeRef = new StoreReflectionData { data = reflectionData.Ptr(), allProbes = reflectProbes.Ptr(), count = reflectProbes.Length, camPos = cam.cam.transform.position, dist = availiableDistance, localToWorldMat = MUnsafeUtility.Malloc <Matrix4x4>(sizeof(Matrix4x4) * reflectProbes.Length, Allocator.Temp) }; storeDataHandler = storeRef.ScheduleRefBurst(); if (ssrEvents.enabled && !RenderPipeline.renderingEditor) { ssrEvents.PreRender(cam); } }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { #if UNITY_EDITOR if (!enableInEditor && RenderPipeline.renderingEditor) { data.buffer.Blit(cam.targets.renderTargetIdentifier, BuiltinRenderTextureType.CameraTarget); return; } #endif postContext.camera = cam.cam; postContext.command = data.buffer; postContext.bloomBufferNameID = -1; postContext.sourceFormat = RenderTextureFormat.ARGBHalf; var settings = profile.settings; postContext.autoExposureTexture = RuntimeUtilities.whiteTexture; postContext.bloomBufferNameID = -1; RenderTargetIdentifier source, dest; postContext.source = cam.targets.renderTargetIdentifier; postContext.destination = cam.targets.backupIdentifier; postContext.logHistogram.Generate(postContext); foreach (var i in settings) { PostEffect ef; if (allEvents.TryGetValue(i.GetType(), out ef)) { if (ef.needBlit && i.active) { PipelineFunctions.RunPostProcess(ref cam.targets, out source, out dest); postContext.source = source; postContext.destination = dest; } ef.renderer.SetSettings(i); ef.renderer.Render(postContext); } } ; // data.buffer.Blit(cam.targets.renderTargetIdentifier, BuiltinRenderTextureType.CameraTarget); data.buffer.BlitSRT(cam.targets.renderTargetIdentifier, BuiltinRenderTextureType.CameraTarget, postContext.uberSheet.material, 0, postContext.uberSheet.properties); if (postContext.bloomBufferNameID > -1) { data.buffer.ReleaseTemporaryRT(postContext.bloomBufferNameID); } }
public void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; handle.Complete(); buffer.GetTemporaryRT(ShaderIDs._BackupAlbedoMap, cam.cam.pixelWidth, cam.cam.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1, false); buffer.GetTemporaryRT(ShaderIDs._BackupNormalMap, cam.cam.pixelWidth, cam.cam.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear, 1, false); buffer.CopyTexture(cam.targets.gbufferIndex[2], 0, 0, ShaderIDs._BackupNormalMap, 0, 0); buffer.CopyTexture(cam.targets.gbufferIndex[0], 0, 0, ShaderIDs._BackupAlbedoMap, 0, 0); decalTargets[0] = cam.targets.gbufferIndex[0]; decalTargets[1] = cam.targets.gbufferIndex[2]; buffer.SetRenderTarget(colors: decalTargets, depth: ShaderIDs._DepthBufferTexture); DecalData *resulPtr = decalCullResults.Ptr(); for (int i = 0; i < cullJob.count; ++i) { ref DecalData decal = ref resulPtr[i]; DecalBase dec = MUnsafeUtility.GetObject <DecalBase>(decal.comp); dec.DrawDecal(buffer); }
public override void PreRenderFrame(PipelineCamera cam, ref PipelineCommandData data) { if (!cam.cam.TryGetCullingParameters(out cullParams)) { return; } data.buffer.SetInvertCulling(cam.inverseRender); cullParams.reflectionProbeSortingCriteria = ReflectionProbeSortingCriteria.ImportanceThenSize; cullParams.cullingOptions = CullingOptions.NeedsLighting | CullingOptions.NeedsReflectionProbes; if (cam.cam.useOcclusionCulling) { cullParams.cullingOptions |= CullingOptions.OcclusionCull; } cullResults = data.context.Cull(ref cullParams); for (int i = 0; i < frustumPlanes.Length; ++i) { Plane p = cullParams.GetCullingPlane(i); //GPU Driven RP's frustum plane is inverse from SRP's frustum plane frustumPlanes[i] = new Vector4(-p.normal.x, -p.normal.y, -p.normal.z, -p.distance); } PipelineFunctions.InitRenderTarget(ref cam.targets, cam.cam, data.buffer); lastData = IPerCameraData.GetProperty(cam, getLastVP); calculateJob = new CalculateMatrixJob { isD3D = GraphicsUtility.platformIsD3D, nonJitterP = cam.cam.nonJitteredProjectionMatrix, worldToView = cam.cam.worldToCameraMatrix, lastVP = lastData.lastVP, rand = (Random *)UnsafeUtility.AddressOf(ref rand), p = cam.cam.projectionMatrix, VP = (float4x4 *)UnsafeUtility.AddressOf(ref VP), inverseVP = (float4x4 *)UnsafeUtility.AddressOf(ref inverseVP) }; handle = calculateJob.ScheduleRefBurst(); customRendererCulledResult = new NativeList <int>(CustomDrawRequest.AllEvents.Count, Unity.Collections.Allocator.Temp); cdrCullHandle = new CustomRendererCullJob { cullResult = customRendererCulledResult, frustumPlanes = (float4 *)frustumPlanes.Ptr() }.Schedule(CustomDrawRequest.AllEvents.Count, 8); }