protected override void Dispose(bool disposing) { base.Dispose(disposing); if (current == this) { current = null; } iRunnableObjects.Dispose(); CustomDrawRequest.Dispose(); if (m_afterFrameBuffer != null) { m_afterFrameBuffer.Dispose(); m_afterFrameBuffer = null; } if (m_beforeFrameBuffer != null) { m_beforeFrameBuffer.Dispose(); m_beforeFrameBuffer = null; } try { eventsGuideBook.Dispose(); waitReleaseRT.Dispose(); } catch { } SceneController.Dispose(resources); resources.loadingThread.Dispose(); data.buffer.Dispose(); var allEvents = resources.allEvents; for (int i = 0; i < resources.availiableEvents.Length; ++i) { resources.availiableEvents[i].DisposeEvent(); } for (int i = 0; i < resources.availiableEvents.Length; ++i) { resources.availiableEvents[i].DisposeDependEventsList(); } foreach (var camPtr in PipelineCamera.CameraSearchDict) { PipelineCamera cam = MUnsafeUtility.GetObject <PipelineCamera>((void *)camPtr.value); if (cam.allDatas.isCreated) { foreach (var i in cam.allDatas) { IPerCameraData data = ((IPerCameraData)MUnsafeUtility.GetHookedObject(i.value)); data.DisposeProperty(); MUnsafeUtility.RemoveHookedObject(i.value); } cam.allDatas.Dispose(); } } if (motionVectorMatricesBuffer != null) { motionVectorMatricesBuffer.Dispose(); } MotionVectorDrawer.Dispose(); }
protected override void Dispose(bool disposing) { eventsGuideBook.Dispose(); waitReleaseRT.Dispose(); base.Dispose(disposing); if (current == this) { current = null; } data.buffer.Dispose(); var allEvents = resources.allEvents; for (int i = 0; i < resources.availiableEvents.Length; ++i) { resources.availiableEvents[i].DisposeEvent(); } for (int i = 0; i < resources.availiableEvents.Length; ++i) { resources.availiableEvents[i].DisposeDependEventsList(); } if (PipelineCamera.allCamera.isCreated) { foreach (var i in PipelineCamera.allCamera) { PipelineCamera cam = MUnsafeUtility.GetObject <PipelineCamera>(i.value.ToPointer()); var values = cam.allDatas.Values; foreach (var j in values) { j.DisposeProperty(); } cam.allDatas.Clear(); } } }
private void OnDisable() { allProbe[index] = allProbe[allProbe.Length - 1]; AOProbe prb = MUnsafeUtility.GetObject <AOProbe>(allProbe[index].ToPointer()); prb.index = index; }
public void Execute() { List <MLight> allSpotLight = MLight.avaliableSpotShadowIndices; List <MLight> allPointLight = MLight.avaliableCubemapIndices; UIntPtr * allPtr = stackalloc UIntPtr[max(spotExists ? allSpotLight.Count : 0, pointExists ? allPointLight.Count : 0)]; int ptrCount = 0; if (spotExists) { for (int i = 0; i < allSpotLight.Count; ++i) { ref Cone c = ref allSpotLightPosition[i]; float3 dir = c.vertex - cameraPos; if (!MathLib.ConeIntersect(allSpotLightPosition[i], MathLib.GetPlane(dir, cameraPos + dir * shadowDistance))) { allPtr[ptrCount] = new UIntPtr(MUnsafeUtility.GetManagedPtr(allSpotLight[i])); ptrCount++; } } for (int i = 0; i < ptrCount; ++i) { MLight ml = MUnsafeUtility.GetObject <MLight>(allPtr[i].ToPointer()); ml.RemoveLightFromAtlas(false); ml.updateShadowCache = true; } }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (current != this) { return; } current = null; data.buffer.Dispose(); var allEvents = resources.allEvents; foreach (var i in allEvents) { if (i != null) { foreach (var j in i) { j.DisposeEvent(); } } } foreach (var i in PipelineCamera.allCamera) { PipelineCamera cam = MUnsafeUtility.GetObject <PipelineCamera>(i.ToPointer()); var values = cam.allDatas.Values; foreach (var j in values) { j.DisposeProperty(); } cam.allDatas.Clear(); } }
private void PointLight(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; VoxelLightCommonData(buffer, cam.cam); lightingHandle.Complete(); foreach (var i in addMLightCommandList) { MLight.AddMLight(i); } addMLightCommandList.Clear(); int count = Mathf.Min(cubemapVPMatrices.Length, CBDRSharedData.MAXIMUMPOINTLIGHTCOUNT); cbdr.pointshadowCount = count; if (LightFilter.pointLightCount > 0) { if (count > 0) { var cullShader = data.resources.shaders.gpuFrustumCulling; buffer.SetGlobalTexture(ShaderIDs._CubeShadowMapArray, cbdr.cubeArrayMap); NativeArray <VisibleLight> allLights = data.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); if (light.useShadowCache) { light.UpdateShadowCacheType(true); if (light.updateShadowCache) { light.updateShadowCache = false; SceneController.DrawPointLight(light, shadowLayer, ref pointLightPtr[lightIndex.x], cubeDepthMaterial, buffer, cullShader, i, ref data, cubemapVPMatrices.unsafePtr, cbdr.cubeArrayMap, cam.inverseRender); int offset = i * 6; for (int a = 0; a < 6; ++a) { buffer.CopyTexture(cbdr.cubeArrayMap, offset + a, light.shadowMap, a); } } else { PipelineFunctions.CopyToCubeMap(cbdr.cubeArrayMap, light.shadowMap, buffer, i); } } else { SceneController.DrawPointLight(light, shadowLayer, ref pointLightPtr[lightIndex.x], cubeDepthMaterial, buffer, cullShader, i, ref data, cubemapVPMatrices.unsafePtr, cbdr.cubeArrayMap, cam.inverseRender); } //TODO //Multi frame shadowmap } } SetPointLightBuffer(pointLightArray, LightFilter.pointLightCount); buffer.EnableShaderKeyword("POINTLIGHT"); cbdr.lightFlag |= 1; }
private void OnDestroy() { Decal lastDec = MUnsafeUtility.GetObject <Decal>(decalDatas[decalDatas.Length - 1].comp); lastDec.index = index; decalDatas[index] = decalDatas[decalDatas.Length - 1]; decalDatas.RemoveLast(); }
private void OnDisable() { AreaVolumeProbe lastProbe = MUnsafeUtility.GetObject <AreaVolumeProbe>(allAreaLight[allAreaLight.Length - 1].componentPtr); lastProbe.index = index; allAreaLight[index] = allAreaLight[allAreaLight.Length - 1]; allAreaLight.RemoveLast(); }
private void OnDisable() { *container = allVolumes[allVolumes.Length - 1]; FogVolumeComponent lastComp = MUnsafeUtility.GetObject <FogVolumeComponent>(container->light); lastComp.container = container; allVolumes.RemoveLast(); }
private void OnDisable() { allVolumes[index] = allVolumes[allVolumes.Length - 1]; FogVolumeComponent lastComp = MUnsafeUtility.GetObject <FogVolumeComponent>(allVolumes[index].light); lastComp.index = index; allVolumes.RemoveLast(); }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { if (!enabledPost || !cam.postProfile) { 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 NativeDictionary <ulong, ulong, PtrEqual> allSettings = new NativeDictionary <ulong, ulong, PtrEqual>(allPostEffects.Count, Unity.Collections.Allocator.Temp, new PtrEqual()); foreach (var i in cam.postProfile.settings) { allSettings.Add((ulong)MUnsafeUtility.GetManagedPtr(i.GetType()), (ulong)MUnsafeUtility.GetManagedPtr(i)); } 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); cyberGlitch.Render(data.buffer, ref cam.targets); foreach (var i in allPostEffects) { ulong settingsPtr; if (allSettings.Get((ulong)MUnsafeUtility.GetManagedPtr(i.type), out settingsPtr)) { PostProcessEffectSettings setting = MUnsafeUtility.GetObject <PostProcessEffectSettings>((void *)settingsPtr); 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); } } ; allSettings.Dispose(); // data.buffer.Blit(ShaderIDs._CameraMotionVectorsTexture, cam.cameraTarget); // data.buffer.BlitSRT(cam.cameraTarget, debugMat, 0); data.buffer.BlitSRT(cam.targets.renderTargetIdentifier, cam.cameraTarget, postContext.uberSheet.material, 0, postContext.uberSheet.properties); if (postContext.bloomBufferNameID > -1) { data.buffer.ReleaseTemporaryRT(postContext.bloomBufferNameID); } }
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 pointLightCustomCullHandle.Complete(); 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, cullShader, ref data, ref vpMatrices, cbdr.cubeArrayMap, cam.inverseRender, proper.overrideOpaqueMaterial); } vpMatrices.customCulledResult.Dispose(); if (vpMatrices.frustumPlanes != null) { UnsafeUtility.Free(vpMatrices.frustumPlanes, Allocator.TempJob); } ptLitStr.shadowIndex = light.ShadowIndex; //TODO //Multi frame shadowmap } }
private void PointLight(PipelineCamera cam, ref PipelineCommandData data) { CommandBuffer buffer = data.buffer; pointLightMaterial.SetBuffer(ShaderIDs.verticesBuffer, sphereBuffer); VoxelLightCommonData(buffer, cam.cam); ClearDispatch(buffer); lightingHandle.Complete(); foreach (var i in addMLightCommandList) { MLight.AddMLight(i); } addMLightCommandList.Clear(); cbdr.pointshadowCount = cubemapVPMatrices.Length; if (LightFilter.pointLightCount > 0) { if (cubemapVPMatrices.Length > 0) { var cullShader = data.resources.gpuFrustumCulling; buffer.SetGlobalTexture(ShaderIDs._CubeShadowMapArray, cbdr.cubeArrayMap); RenderClusterOptions opts = new RenderClusterOptions { cullingShader = cullShader, command = buffer, frustumPlanes = null, isOrtho = false }; List <VisibleLight> allLights = data.cullResults.visibleLights; PointLightStruct * pointLightPtr = pointLightArray.Ptr(); for (int i = 0; i < cubemapVPMatrices.Length; ++i) { ref CubemapViewProjMatrix vpMatrices = ref cubemapVPMatrices[i]; int2 lightIndex = vpMatrices.index; Light lt = allLights[lightIndex.y].light; MLight light = MUnsafeUtility.GetObject <MLight>(vpMatrices.mLightPtr); if (light.updateShadowmap) { light.UpdateShadowCacheType(true); SceneController.DrawPointLight(light, ref pointLightPtr[lightIndex.x], cubeDepthMaterial, ref opts, i, light.shadowMap, ref data, cubemapVPMatrices.unsafePtr, cbdr.cubeArrayMap); } else { PipelineFunctions.CopyToCubeMap(cbdr.cubeArrayMap, light.shadowMap, buffer, i); } //TODO //Multi frame shadowmap } } SetPointLightBuffer(pointLightArray, LightFilter.pointLightCount, buffer); buffer.EnableShaderKeyword("POINTLIGHT"); cbdr.lightFlag |= 1; }
public V this[K key] { get { Func <K, K, bool> equalsFunc = MUnsafeUtility.GetObject <Func <K, K, bool> >(this.equalsFunc); int index = Mathf.Abs(key.GetHashCode()) % data->capacity; K **currentPos = GetK(index); while ((*currentPos) != null) { if (equalsFunc(**currentPos, key)) { return(*GetV(*currentPos)); } currentPos = GetNextPtr(*currentPos); } return(default);
public bool Contains(K key) { Func <K, K, bool> equalsFunc = MUnsafeUtility.GetObject <Func <K, K, bool> >(this.equalsFunc); int index = Mathf.Abs(key.GetHashCode()) % data->capacity; K **currentPos = GetK(index); while ((*currentPos) != null) { if (equalsFunc(**currentPos, key)) { return(true); } currentPos = GetNextPtr(*currentPos); } return(false); }
public void SetRenderingPath() { NativeArray <UIntPtr> allCollection = GetAllPath(); allEvents = new PipelineEvent[allCollection.Length][]; Dictionary <Type, PipelineEvent> evtDict = new Dictionary <Type, PipelineEvent>(availiableEvents.Length); foreach (var i in availiableEvents) { evtDict.Add(i.GetType(), i); } for (int i = 0; i < allCollection.Length; ++i) { FieldInfo tp = MUnsafeUtility.GetObject <FieldInfo>(allCollection[i].ToPointer()); Type[] tt = tp.GetValue(null) as Type[]; allEvents[i] = GetAllEvents(tt, evtDict); } }
public void InitEvent(PipelineResources resources) { if (initialized) { return; } initialized = true; Init(resources); if (enabled) { if (dependingEvents.isCreated) { foreach (var i in dependingEvents) { PipelineEvent evt = MUnsafeUtility.GetObject <PipelineEvent>(i.ToPointer()); if (!evt.enabled) { Enabled = false; return; } } } } else { if (dependedEvents.isCreated) { foreach (var i in dependedEvents) { PipelineEvent evt = MUnsafeUtility.GetObject <PipelineEvent>(i.ToPointer()); evt.Enabled = false; } } } if (Enabled) { OnEnable(); } else { OnDisable(); } }
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 void Remove(K key) { Func <K, K, bool> equalsFunc = MUnsafeUtility.GetObject <Func <K, K, bool> >(this.equalsFunc); int index = Mathf.Abs(key.GetHashCode()) % data->capacity; K **currentPtr = GetK(index); while ((*currentPtr) != null) { K **next = GetNextPtr(*currentPtr); if (equalsFunc(**currentPtr, key)) { K *prev = *currentPtr; *currentPtr = *next; UnsafeUtility.Free(prev, data->alloc); data->length--; return; } else { currentPtr = next; } } }
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras) { bool *propertyCheckedFlags = stackalloc bool[] { false, false, false }; GraphicsSettings.useScriptableRenderPipelineBatching = resources.useSRPBatcher; foreach (var i in beforeRenderFrame) { i.func(i.obj); } beforeRenderFrame.Clear(); SceneController.SetState(); #if UNITY_EDITOR foreach (var pair in bakeList) { PipelineCamera pipelineCam = pair.pipelineCamera; for (int i = 0; i < pair.worldToCamera.Length; ++i) { pipelineCam.cam.worldToCameraMatrix = pair.worldToCamera[i]; pipelineCam.cam.projectionMatrix = pair.projection[i]; Render(pipelineCam, ref renderContext, pipelineCam.cam, propertyCheckedFlags); data.buffer.Blit(pipelineCam.targets.renderTargetIdentifier, pair.tempTex); PipelineFunctions.ReleaseRenderTarget(data.buffer, ref pipelineCam.targets); data.buffer.CopyTexture(pair.tempTex, 0, 0, pair.texArray, i, 0); data.ExecuteCommandBuffer(); renderContext.Submit(); } pair.worldToCamera.Dispose(); pair.projection.Dispose(); renderContext.ExecuteCommandBuffer(pair.buffer); pair.buffer.Clear(); renderContext.Submit(); } bakeList.Clear(); #endif if (!PipelineCamera.allCamera.isCreated) { return; } foreach (var cam in cameras) { PipelineCamera pipelineCam; UIntPtr pipelineCamPtr; if (!PipelineCamera.allCamera.Get(cam.gameObject.GetInstanceID(), out pipelineCamPtr)) { #if UNITY_EDITOR renderingEditor = true; if (!PipelineCamera.allCamera.Get(Camera.main.gameObject.GetInstanceID(), out pipelineCamPtr)) { continue; } #else continue; #endif } else { renderingEditor = false; } pipelineCam = MUnsafeUtility.GetObject <PipelineCamera>(pipelineCamPtr.ToPointer()); Render(pipelineCam, ref renderContext, cam, propertyCheckedFlags); PipelineFunctions.ReleaseRenderTarget(data.buffer, ref pipelineCam.targets); data.ExecuteCommandBuffer(); renderContext.Submit(); } foreach (var i in afterRenderFrame) { i.func(i.obj); } afterRenderFrame.Clear(); if (bufferAfterFrame.Count > 0) { foreach (var i in bufferAfterFrame) { i(data.buffer); } data.ExecuteCommandBuffer(); bufferAfterFrame.Clear(); renderContext.Submit(); } }
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras) { bool *propertyCheckedFlags = stackalloc bool[resources.allEvents.Length]; UnsafeUtility.MemClear(propertyCheckedFlags, resources.allEvents.Length); GraphicsSettings.useScriptableRenderPipelineBatching = resources.useSRPBatcher; SceneController.SetState(); #if UNITY_EDITOR int tempID = Shader.PropertyToID("_TempRT"); foreach (var pair in bakeList) { PipelineCamera pipelineCam = pair.pipelineCamera; for (int i = 0; i < pair.worldToCamera.Length; ++i) { pipelineCam.cam.worldToCameraMatrix = pair.worldToCamera[i]; pipelineCam.cam.projectionMatrix = pair.projection[i]; pipelineCam.cameraTarget = tempID; data.buffer.GetTemporaryRT(tempID, pair.texArray.width, pair.texArray.height, pair.texArray.depth, FilterMode.Point, pair.texArray.format, RenderTextureReadWrite.Linear); Render(pipelineCam, ref renderContext, pipelineCam.cam, propertyCheckedFlags); data.buffer.CopyTexture(tempID, 0, 0, pair.texArray, i, 0); data.buffer.ReleaseTemporaryRT(tempID); data.ExecuteCommandBuffer(); renderContext.Submit(); } pair.worldToCamera.Dispose(); pair.projection.Dispose(); renderContext.ExecuteCommandBuffer(pair.buffer); pair.buffer.Clear(); renderContext.Submit(); } bakeList.Clear(); #endif if (PipelineCamera.allCamera.isCreated) { foreach (var cam in cameras) { PipelineCamera pipelineCam; UIntPtr pipelineCamPtr; if (!PipelineCamera.allCamera.Get(cam.gameObject.GetInstanceID(), out pipelineCamPtr)) { #if UNITY_EDITOR renderingEditor = true; var pos = cam.transform.eulerAngles; pos.z = 0; cam.transform.eulerAngles = pos; if (!PipelineCamera.allCamera.Get(Camera.main.gameObject.GetInstanceID(), out pipelineCamPtr)) { continue; } #else continue; #endif } else { renderingEditor = false; } pipelineCam = MUnsafeUtility.GetObject <PipelineCamera>(pipelineCamPtr.ToPointer()); Render(pipelineCam, ref renderContext, cam, propertyCheckedFlags); data.ExecuteCommandBuffer(); renderContext.Submit(); } if (bufferAfterFrame.Count > 0) { foreach (var i in bufferAfterFrame) { i(data.buffer); } data.ExecuteCommandBuffer(); bufferAfterFrame.Clear(); renderContext.Submit(); } } else { if (bufferAfterFrame.Count > 0) { foreach (var i in bufferAfterFrame) { i(data.buffer); } Graphics.ExecuteCommandBuffer(data.buffer); bufferAfterFrame.Clear(); } } }
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras) { bool *propertyCheckedFlags = stackalloc bool[resources.allEvents.Length]; bool needSubmit = false; UnsafeUtility.MemClear(propertyCheckedFlags, resources.allEvents.Length); GraphicsSettings.useScriptableRenderPipelineBatching = resources.useSRPBatcher; SceneController.SetState(); data.context = renderContext; data.resources = resources; #if UNITY_EDITOR int tempID = Shader.PropertyToID("_TempRT"); foreach (var pair in bakeList) { PipelineCamera pipelineCam = pair.pipelineCamera; for (int i = 0; i < pair.worldToCamera.Length; ++i) { pipelineCam.cam.worldToCameraMatrix = pair.worldToCamera[i]; pipelineCam.cam.projectionMatrix = pair.projection[i]; pipelineCam.cameraTarget = tempID; data.buffer.GetTemporaryRT(tempID, pair.texArray.width, pair.texArray.height, pair.texArray.depth, FilterMode.Point, pair.texArray.format, RenderTextureReadWrite.Linear); Render(pipelineCam, ref renderContext, pipelineCam.cam, propertyCheckedFlags); data.buffer.CopyTexture(tempID, 0, 0, pair.texArray, i, 0); data.buffer.ReleaseTemporaryRT(tempID); data.ExecuteCommandBuffer(); renderContext.Submit(); needSubmit = false; } pair.worldToCamera.Dispose(); pair.projection.Dispose(); renderContext.ExecuteCommandBuffer(pair.buffer); pair.buffer.Clear(); renderContext.Submit(); needSubmit = false; } bakeList.Clear(); #endif foreach (var cam in preFrameRenderCamera) { Render(cam, ref renderContext, cam.cam, propertyCheckedFlags); data.ExecuteCommandBuffer(); renderContext.Submit(); needSubmit = false; } preFrameRenderCamera.Clear(); if (CustomDrawRequest.AllEvents.Count > 0 || JobProcessEvent.allEvents.Count > 0) { foreach (var i in CustomDrawRequest.AllEvents) { i.PrepareJob(resources); } foreach (var i in JobProcessEvent.allEvents) { i.PrepareJob(); } JobHandle.ScheduleBatchedJobs(); foreach (var i in CustomDrawRequest.AllEvents) { i.FinishJob(); } foreach (var i in JobProcessEvent.allEvents) { i.FinishJob(); } } if (useBeforeFrameBuffer) { renderContext.ExecuteCommandBuffer(m_beforeFrameBuffer); m_beforeFrameBuffer.Clear(); needSubmit = true; useBeforeFrameBuffer = false; } if (PipelineCamera.allCamera.isCreated) { foreach (var cam in cameras) { PipelineCamera pipelineCam; UIntPtr pipelineCamPtr; if (!PipelineCamera.allCamera.Get(cam.gameObject.GetInstanceID(), out pipelineCamPtr)) { #if UNITY_EDITOR renderingEditor = true; var pos = cam.transform.eulerAngles; pos.z = 0; cam.transform.eulerAngles = pos; if (!PipelineCamera.allCamera.Get(Camera.main.gameObject.GetInstanceID(), out pipelineCamPtr)) { continue; } #else continue; #endif } else { renderingEditor = false; } pipelineCam = MUnsafeUtility.GetObject <PipelineCamera>(pipelineCamPtr.ToPointer()); Render(pipelineCam, ref renderContext, cam, propertyCheckedFlags); data.ExecuteCommandBuffer(); #if UNITY_EDITOR if (renderingEditor) { renderContext.DrawGizmos(cam, GizmoSubset.PostImageEffects); } #endif renderContext.Submit(); needSubmit = false; } } if (useAfterFrameBuffer) { renderContext.ExecuteCommandBuffer(m_afterFrameBuffer); m_afterFrameBuffer.Clear(); needSubmit = true; useAfterFrameBuffer = false; } if (needSubmit) { renderContext.Submit(); } }
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras) { currentFrameCamera.Clear(); PipelineCamera.InitializeDict(); foreach (var cam in cameras) { CameraSetting csg; ulong pipelineCamPtr; if (!PipelineCamera.CameraSearchDict.Get(cam.gameObject.GetInstanceID(), out pipelineCamPtr)) { if (!cam.TryGetComponent(out csg.pipeCam)) { #if UNITY_EDITOR if (cam.cameraType == CameraType.SceneView) { csg.isRenderingEditor = true; var pos = cam.transform.eulerAngles; pos.z = 0; cam.transform.eulerAngles = pos; if (!Camera.main || !(csg.pipeCam = Camera.main.GetComponent <PipelineCamera>())) { continue; } } else if (cam.cameraType == CameraType.Game) { csg.isRenderingEditor = false; csg.pipeCam = cam.gameObject.AddComponent <PipelineCamera>(); } else { continue; } #else csg.isRenderingEditor = false; csg.pipeCam = cam.gameObject.AddComponent <PipelineCamera>(); #endif } else { csg.isRenderingEditor = false; csg.pipeCam.AddToDict(); } } else { csg.isRenderingEditor = false; csg.pipeCam = MUnsafeUtility.GetObject <PipelineCamera>((void *)pipelineCamPtr); } csg.cam = cam; csg.pipeCam.cam = cam; csg.pipeCam.BeforeFrameRendering(); currentFrameCamera.Add(csg); } bool *propertyCheckedFlags = stackalloc bool[resources.allEvents.Length]; bool needSubmit = false; CustomDrawRequest.Initialize(); UnsafeUtility.MemClear(propertyCheckedFlags, resources.allEvents.Length); SceneController.SetState(); data.context = renderContext; data.resources = resources; if (motionVectorMatricesBuffer == null || !motionVectorMatricesBuffer.IsValid()) { motionVectorMatricesBuffer = new ComputeBuffer(MotionVectorDrawer.Capacity, sizeof(float3x4)); } else if (motionVectorMatricesBuffer.count < MotionVectorDrawer.Capacity) { motionVectorMatricesBuffer.Dispose(); motionVectorMatricesBuffer = new ComputeBuffer(MotionVectorDrawer.Capacity, sizeof(float3x4)); } MotionVectorDrawer.ExecuteBeforeFrame(motionVectorMatricesBuffer); data.buffer.SetGlobalBuffer(ShaderIDs._LastFrameModel, motionVectorMatricesBuffer); #if UNITY_EDITOR int tempID = Shader.PropertyToID("_TempRT"); foreach (var pair in bakeList) { PipelineCamera pipelineCam = pair.pipelineCamera; for (int i = 0; i < pair.worldToCamera.Length; ++i) { pipelineCam.cam.worldToCameraMatrix = pair.worldToCamera[i]; pipelineCam.cam.projectionMatrix = pair.projection[i]; pipelineCam.cameraTarget = tempID; data.buffer.GetTemporaryRT(tempID, pair.texArray.width, pair.texArray.height, pair.texArray.depth, FilterMode.Point, pair.texArray.format, RenderTextureReadWrite.Linear); Render(pipelineCam, ref renderContext, pipelineCam.cam, propertyCheckedFlags); data.buffer.CopyTexture(tempID, 0, 0, pair.texArray, i, 0); data.buffer.ReleaseTemporaryRT(tempID); data.ExecuteCommandBuffer(); renderContext.Submit(); needSubmit = false; } pair.worldToCamera.Dispose(); pair.projection.Dispose(); renderContext.ExecuteCommandBuffer(pair.buffer); pair.buffer.Clear(); renderContext.Submit(); needSubmit = false; } bakeList.Clear(); #endif foreach (var cam in preFrameRenderCamera) { Render(cam, ref renderContext, cam.cam, propertyCheckedFlags); data.ExecuteCommandBuffer(); renderContext.Submit(); needSubmit = false; } preFrameRenderCamera.Clear(); if (CustomDrawRequest.allEvents.Count > 0 || JobProcessEvent.allEvents.Count > 0) { foreach (var i in CustomDrawRequest.allEvents) { i.PrepareJob(resources); } foreach (var i in JobProcessEvent.allEvents) { i.PrepareJob(); } JobHandle.ScheduleBatchedJobs(); foreach (var i in CustomDrawRequest.allEvents) { i.FinishJob(); } foreach (var i in JobProcessEvent.allEvents) { i.FinishJob(); } } if (Application.isPlaying && resources.clusterResources) { resources.clusterResources.UpdateData(data.buffer, resources); } resources.loadingThread.Update(); if (useBeforeFrameBuffer) { renderContext.ExecuteCommandBuffer(m_beforeFrameBuffer); m_beforeFrameBuffer.Clear(); needSubmit = true; useBeforeFrameBuffer = false; } if (iRunnableObjects.isCreated) { foreach (var i in iRunnableObjects) { IPipelineRunnable func = MUnsafeUtility.GetObject <IPipelineRunnable>((void *)i.value); func.PipelineUpdate(ref data); } } if (cameras.Length > 0) { data.buffer.SetGlobalVector(ShaderIDs._SceneOffset, new float4(sceneOffset, 1)); } foreach (var cam in currentFrameCamera) { renderingEditor = cam.isRenderingEditor; Render(cam.pipeCam, ref renderContext, cam.cam, propertyCheckedFlags); data.ExecuteCommandBuffer(); #if UNITY_EDITOR if (renderingEditor) { renderContext.DrawGizmos(cam.cam, GizmoSubset.PostImageEffects); ScriptableRenderContext.EmitWorldGeometryForSceneView(cam.cam); } #endif renderContext.Submit(); needSubmit = false; } if (useAfterFrameBuffer) { renderContext.ExecuteCommandBuffer(m_afterFrameBuffer); m_afterFrameBuffer.Clear(); needSubmit = true; useAfterFrameBuffer = false; } if (needSubmit) { renderContext.Submit(); } MotionVectorDrawer.ExecuteAfterFrame(); sceneOffset = 0; foreach (var cam in currentFrameCamera) { cam.pipeCam.cam = cam.cam; cam.pipeCam.AfterFrameRendering(); } }