private void Render(PipelineCamera pipelineCam, ref ScriptableRenderContext context, Camera cam, bool *pipelineChecked)
{
PipelineResources.CameraRenderingPath path = pipelineCam.renderingPath;
currentPath = path;
pipelineCam.cam = cam;
pipelineCam.EnableThis(resources);
if (!cam.TryGetCullingParameters(out data.cullParams))
{
return;
}
context.SetupCameraProperties(cam);
//Set Global Data
data.context = context;
data.cullParams.reflectionProbeSortingCriteria = ReflectionProbeSortingCriteria.ImportanceThenSize;
data.cullResults = context.Cull(ref data.cullParams);
PipelineFunctions.InitRenderTarget(ref pipelineCam.targets, cam, data.buffer);
data.resources = resources;
PipelineFunctions.GetViewProjectMatrix(cam, out data.vp, out data.inverseVP);
for (int i = 0; i < data.frustumPlanes.Length; ++i)
{
Plane p = data.cullParams.GetCullingPlane(i);
//GPU Driven RP's frustum plane is inverse from SRP's frustum plane
data.frustumPlanes[i] = new Vector4(-p.normal.x, -p.normal.y, -p.normal.z, -p.distance);
}
var allEvents = resources.allEvents;
var collect = allEvents[(int)path];
#if UNITY_EDITOR
//Need only check for Unity Editor's bug!
if (!pipelineChecked[(int)path])
{
pipelineChecked[(int)path] = true;
foreach (var e in collect)
{
if (!e.CheckProperty())
{
e.CheckInit(resources);
}
}
}
#endif
data.buffer.SetInvertCulling(pipelineCam.inverseRender);
foreach (var e in collect)
{
if (e.Enabled)
{
e.PreRenderFrame(pipelineCam, ref data);
}
}
JobHandle.ScheduleBatchedJobs();
foreach (var e in collect)
{
if (e.Enabled)
{
e.FrameUpdate(pipelineCam, ref data);
}
}
data.buffer.SetInvertCulling(false);
}
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();
}
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.isD3D = GraphicsUtility.platformIsD3D;
calculateJob.nonJitterP = cam.cam.nonJitteredProjectionMatrix;
calculateJob.worldToView = cam.cam.worldToCameraMatrix;
calculateJob.lastVP = lastData.lastVP;
calculateJob.rand = (Random *)UnsafeUtility.AddressOf(ref rand);
calculateJob.p = cam.cam.projectionMatrix;
calculateJob.VP = (float4x4 *)UnsafeUtility.AddressOf(ref VP);
calculateJob.inverseVP = (float4x4 *)UnsafeUtility.AddressOf(ref inverseVP);
Transform camTrans = cam.cam.transform;
perspCam.forward = camTrans.forward;
perspCam.up = camTrans.up;
perspCam.right = camTrans.right;
perspCam.position = camTrans.position;
perspCam.nearClipPlane = cam.cam.nearClipPlane;
perspCam.farClipPlane = cam.cam.farClipPlane;
perspCam.aspect = cam.cam.aspect;
perspCam.fov = cam.cam.fieldOfView;
float3 *corners = stackalloc float3[8];
PipelineFunctions.GetFrustumCorner(ref perspCam, corners);
frustumMinPoint = corners[0];
frustumMaxPoint = corners[0];
for (int i = 1; i < 8; ++i)
{
frustumMinPoint = min(frustumMinPoint, corners[i]);
frustumMaxPoint = max(frustumMaxPoint, corners[i]);
}
handle = calculateJob.ScheduleRefBurst();
}
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);
}
}
private void Render(PipelineCamera pipelineCam, RenderTargetIdentifier dest, ref ScriptableRenderContext context, Camera cam)
{
CameraRenderingPath path = pipelineCam.renderingPath;
pipelineCam.cam = cam;
pipelineCam.EnableThis();
if (!CullResults.GetCullingParameters(cam, out data.cullParams))
{
return;
}
context.SetupCameraProperties(cam);
//Set Global Data
data.defaultDrawSettings = new DrawRendererSettings(cam, new ShaderPassName(""));
data.context = context;
data.cullResults = CullResults.Cull(ref data.cullParams, context);
PipelineFunctions.InitRenderTarget(ref pipelineCam.targets, cam, data.buffer);
data.resources = resources;
PipelineFunctions.GetViewProjectMatrix(cam, out data.vp, out data.inverseVP);
for (int i = 0; i < data.frustumPlanes.Length; ++i)
{
Plane p = data.cullParams.GetCullingPlane(i);
//GPU Driven RP's frustum plane is inverse from SRP's frustum plane
data.frustumPlanes[i] = new Vector4(-p.normal.x, -p.normal.y, -p.normal.z, -p.distance);
}
PipelineEvent[] events = null;
switch (pipelineCam.renderingPath)
{
case CameraRenderingPath.GPUDeferred:
events = gpurpEvents;
break;
}
currentRenderingPath = pipelineCam.renderingPath;
foreach (var e in events)
{
if (e.enabled && e.preEnable)
{
e.PreRenderFrame(pipelineCam, ref data);
}
}
JobHandle.ScheduleBatchedJobs();
foreach (var e in events)
{
if (e.enabled && e.postEnable)
{
e.FrameUpdate(pipelineCam, ref data);
}
}
data.buffer.Blit(pipelineCam.targets.renderTargetIdentifier, dest);
}
private void Render(PipelineCamera pipelineCam, RenderTargetIdentifier dest, ref ScriptableRenderContext context, Camera cam)
{
CameraRenderingPath path = pipelineCam.renderingPath;
pipelineCam.cam = cam;
pipelineCam.EnableThis();
if (!CullResults.GetCullingParameters(cam, out data.cullParams))
{
return;
}
context.SetupCameraProperties(cam);
//Set Global Data
data.defaultDrawSettings = new DrawRendererSettings(cam, new ShaderPassName(""));
data.context = context;
data.cullResults = CullResults.Cull(ref data.cullParams, context);
PipelineFunctions.InitRenderTarget(ref pipelineCam.targets, cam, data.buffer);
data.resources = resources;
PipelineFunctions.GetViewProjectMatrix(cam, out data.vp, out data.inverseVP);
for (int i = 0; i < data.frustumPlanes.Length; ++i)
{
Plane p = data.cullParams.GetCullingPlane(i);
//GPU Driven RP's frustum plane is inverse from SRP's frustum plane
data.frustumPlanes[i] = new Vector4(-p.normal.x, -p.normal.y, -p.normal.z, -p.distance);
}
DrawEvent evt;
if (allDrawEvents.TryGetValue(path, out evt))
{
//Pre Calculate Events
foreach (var i in evt.preRenderEvents)
{
i.PreRenderFrame(pipelineCam, ref data);
}
//Run job system together
JobHandle.ScheduleBatchedJobs();
//Start Prepare Render Targets
//Frame Update Events
foreach (var i in evt.drawEvents)
{
i.FrameUpdate(pipelineCam, ref data);
}
}
data.buffer.Blit(pipelineCam.targets.renderTargetIdentifier, dest);
data.ExecuteCommandBuffer();
}
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)
{
frustumPlanes[i] = cam.frustumArray[i];
}
PipelineFunctions.InitRenderTarget(ref cam.targets, cam.cam, data.buffer);
var getter = new LastVPData.GetLastVPData
{
c = cam.cam
};
lastData = IPerCameraData.GetProperty <LastVPData, LastVPData.GetLastVPData>(cam, getter);
calculateJob.isD3D = GraphicsUtility.platformIsD3D;
calculateJob.nonJitterP = cam.cam.nonJitteredProjectionMatrix;
calculateJob.worldToView = cam.cam.worldToCameraMatrix;
//TODO
//Set Camera
calculateJob.lastCameraLocalToWorld = lastData.camlocalToWorld;
calculateJob.lastP = lastData.lastP;
calculateJob.sceneOffset = RenderPipeline.sceneOffset;
calculateJob.rand = (Random *)UnsafeUtility.AddressOf(ref rand);
calculateJob.p = cam.cam.projectionMatrix;
calculateJob.VP = (float4x4 *)UnsafeUtility.AddressOf(ref VP);
calculateJob.inverseVP = (float4x4 *)UnsafeUtility.AddressOf(ref inverseVP);
handle = calculateJob.ScheduleRefBurst();
}
