public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
{
foreach (var i in beforeRenderFrame)
{
i.func(i.obj);
}
beforeRenderFrame.Clear();
SceneController.SetState();
foreach (var cam in cameras)
{
PipelineCamera pipelineCam = cam.GetComponent <PipelineCamera>();
if (!pipelineCam)
{
pipelineCam = Camera.main.GetComponent <PipelineCamera>();
if (!pipelineCam)
{
continue;
}
}
Render(pipelineCam, BuiltinRenderTextureType.CameraTarget, ref renderContext, cam);
PipelineFunctions.ReleaseRenderTarget(data.buffer, ref pipelineCam.targets);
renderContext.Submit();
}
foreach (var i in afterRenderFrame)
{
i.func(i.obj);
}
afterRenderFrame.Clear();
}
private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (RenderPipeline.singleton)
{
PipelineFunctions.InitRenderTarget(ref targets, cam, temporaryTextures);
RenderPipeline.singleton.Render(renderingPath, this, destination);
PipelineFunctions.ReleaseRenderTarget(temporaryTextures);
}
else
{
Graphics.Blit(source, destination);
}
}
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data, CommandBuffer 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);
}
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();
}
}
public void RenderSRP(RenderTargetIdentifier destination, ref ScriptableRenderContext context)
{
RenderPipeline.current.Render(renderingPath, this, destination, ref context);
PipelineFunctions.ReleaseRenderTarget(temporaryTextures);
}
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
{
bool *propertyCheckedFlags = stackalloc bool[]
{
false,
false,
false
};
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, new RenderTargetIdentifier(pair.tempTex), ref renderContext, pipelineCam.cam, propertyCheckedFlags);
PipelineFunctions.ReleaseRenderTarget(data.buffer, ref pipelineCam.targets);
data.buffer.CopyTexture(pair.tempTex, 0, pair.texArray, i);
data.ExecuteCommandBuffer();
}
pair.worldToCamera.Dispose();
pair.projection.Dispose();
renderContext.ExecuteCommandBuffer(pair.buffer);
pair.buffer.Clear();
renderContext.Submit();
}
bakeList.Clear();
#endif
foreach (var cam in cameras)
{
PipelineCamera pipelineCam = cam.GetComponent <PipelineCamera>();
if (!pipelineCam)
{
pipelineCam = Camera.main.GetComponent <PipelineCamera>();
if (!pipelineCam)
{
continue;
}
}
Render(pipelineCam, BuiltinRenderTextureType.CameraTarget, 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 UNITY_EDITOR
foreach (var i in bufferAfterFrame)
{
renderContext.ExecuteCommandBuffer(i);
i.Clear();
}
bufferAfterFrame.Clear();
renderContext.Submit();
#endif
}
