/// <summary> /// Execute the pass. This is where custom rendering occurs. Specific details are left to the implementation /// </summary> /// <param name="renderer">The currently executing renderer. Contains configuration for the current execute call.</param> /// <param name="context">Use this render context to issue any draw commands during execution</param> /// <param name="renderingData">Current rendering state information</param> public abstract void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData);
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_OpaquePostProcessTag);
RenderTargetIdentifier source = colorAttachmentHandle.Identifier();
renderer.RenderPostProcess(cmd, ref renderingData.cameraData, descriptor.colorFormat, source, colorAttachmentHandle.Identifier(), true);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderOpaquesTag);
using (new ProfilingSample(cmd, k_RenderOpaquesTag))
{
// When ClearFlag.None that means this is not the first render pass to write to camera target.
// In that case we set loadOp for both color and depth as RenderBufferLoadAction.Load
RenderBufferLoadAction loadOp = clearFlag != ClearFlag.None ? RenderBufferLoadAction.DontCare : RenderBufferLoadAction.Load;
RenderBufferStoreAction storeOp = RenderBufferStoreAction.Store;
SetRenderTarget(cmd, colorAttachmentHandle.Identifier(), loadOp, storeOp,
depthAttachmentHandle.Identifier(), loadOp, storeOp, clearFlag, clearColor, descriptor.dimension);
// TODO: We need a proper way to handle multiple camera/ camera stack. Issue is: multiple cameras can share a same RT
// (e.g, split screen games). However devs have to be dilligent with it and know when to clear/preserve color.
// For now we make it consistent by resolving viewport with a RT until we can have a proper camera management system
//if (colorAttachmentHandle == -1 && !cameraData.isDefaultViewport)
// cmd.SetViewport(camera.pixelRect);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Camera camera = renderingData.cameraData.camera;
XRUtils.DrawOcclusionMesh(cmd, camera, renderingData.cameraData.isStereoEnabled);
var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
var drawSettings = CreateDrawRendererSettings(camera, sortFlags, rendererConfiguration, renderingData.supportsDynamicBatching);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, m_OpaqueFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, m_OpaqueFilterSettings, SortFlags.None);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
CommandBuffer cmd = CommandBufferPool.Get(k_CopyColorTag);
Downsampling downsampling = renderingData.cameraData.opaqueTextureDownsampling;
float opaqueScaler = m_OpaqueScalerValues[(int)downsampling];
RenderTextureDescriptor opaqueDesc = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData, opaqueScaler);
RenderTargetIdentifier colorRT = source.Identifier();
RenderTargetIdentifier opaqueColorRT = destination.Identifier();
cmd.GetTemporaryRT(destination.id, opaqueDesc, renderingData.cameraData.opaqueTextureDownsampling == Downsampling.None ? FilterMode.Point : FilterMode.Bilinear);
switch (downsampling)
{
case Downsampling.None:
cmd.Blit(colorRT, opaqueColorRT);
break;
case Downsampling._2xBilinear:
cmd.Blit(colorRT, opaqueColorRT);
break;
case Downsampling._4xBox:
Material samplingMaterial = renderer.GetMaterial(MaterialHandle.Sampling);
samplingMaterial.SetFloat(m_SampleOffsetShaderHandle, 2);
cmd.Blit(colorRT, opaqueColorRT, samplingMaterial, 0);
break;
case Downsampling._4xBilinear:
cmd.Blit(colorRT, opaqueColorRT);
break;
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (renderingData.shadowData.supportsAdditionalLightShadows)
{
RenderAdditionalShadowmapAtlas(ref context, ref renderingData.cullResults, ref renderingData.lightData, ref renderingData.shadowData);
}
}
public bool Setup(RenderTargetHandle destination, ref RenderingData renderingData, int maxVisibleAdditinalLights)
{
Clear();
this.destination = destination;
if (m_AdditionalLightShadowMatrices.Length != maxVisibleAdditinalLights)
{
m_AdditionalLightShadowMatrices = new Matrix4x4[maxVisibleAdditinalLights];
m_AdditionalLightSlices = new ShadowSliceData[maxVisibleAdditinalLights];
m_AdditionalLightsShadowStrength = new float[maxVisibleAdditinalLights];
}
m_AdditionalShadowCastingLightIndices.Clear();
Bounds bounds;
List <VisibleLight> visibleLights = renderingData.lightData.visibleLights;
int additionalLightsCount = renderingData.lightData.additionalLightsCount;
for (int i = 0; i < visibleLights.Count && m_AdditionalShadowCastingLightIndices.Count < additionalLightsCount; ++i)
{
if (i == renderingData.lightData.mainLightIndex)
{
continue;
}
VisibleLight shadowLight = visibleLights[i];
Light light = shadowLight.light;
if (shadowLight.lightType == LightType.Spot && light != null && light.shadows != LightShadows.None)
{
if (renderingData.cullResults.GetShadowCasterBounds(i, out bounds))
{
m_AdditionalShadowCastingLightIndices.Add(i);
}
}
}
int shadowCastingLightsCount = m_AdditionalShadowCastingLightIndices.Count;
if (shadowCastingLightsCount == 0)
{
return(false);
}
// TODO: Add support to point light shadows. We make a simplification here that only works
// for spot lights and with max spot shadows per pass.
int atlasWidth = renderingData.shadowData.additionalLightsShadowmapWidth;
int atlasHeight = renderingData.shadowData.additionalLightsShadowmapHeight;
int sliceResolution = ShadowUtils.GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
bool anyShadows = false;
int shadowSlicesPerRow = (atlasWidth / sliceResolution);
for (int i = 0; i < shadowCastingLightsCount; ++i)
{
int shadowLightIndex = m_AdditionalShadowCastingLightIndices[i];
VisibleLight shadowLight = visibleLights[shadowLightIndex];
// Currently Only Spot Lights are supported in additional lights
Debug.Assert(shadowLight.lightType == LightType.Spot);
Matrix4x4 shadowTransform;
bool success = ShadowUtils.ExtractSpotLightMatrix(ref renderingData.cullResults, ref renderingData.shadowData,
shadowLightIndex, out shadowTransform, out m_AdditionalLightSlices[i].viewMatrix, out m_AdditionalLightSlices[i].projectionMatrix);
if (success)
{
// TODO: We need to pass bias and scale list to shader to be able to support multiple
// shadow casting additional lights.
m_AdditionalLightSlices[i].offsetX = (i % shadowSlicesPerRow) * sliceResolution;
m_AdditionalLightSlices[i].offsetY = (i / shadowSlicesPerRow) * sliceResolution;
m_AdditionalLightSlices[i].resolution = sliceResolution;
m_AdditionalLightSlices[i].shadowTransform = shadowTransform;
m_AdditionalLightsShadowStrength[i] = shadowLight.light.shadowStrength;
anyShadows = true;
}
else
{
m_AdditionalShadowCastingLightIndices.RemoveAt(i--);
}
}
return(anyShadows);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
// Restore Render target for additional editor rendering.
// Note: Scene view camera always perform depth prepass
CommandBuffer cmd = CommandBufferPool.Get(k_CopyDepthToCameraTag);
CoreUtils.SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.Blit(source.Identifier(), BuiltinRenderTextureType.CameraTarget, renderer.GetMaterial(MaterialHandle.CopyDepth));
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_DepthPrepassTag);
using (new ProfilingSample(cmd, k_DepthPrepassTag))
{
cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
SetRenderTarget(
cmd,
depthAttachmentHandle.Identifier(),
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.Depth,
Color.black,
descriptor.dimension);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
var drawSettings = CreateDrawRendererSettings(renderingData.cameraData.camera, sortFlags, RendererConfiguration.None, renderingData.supportsDynamicBatching);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, opaqueFilterSettings);
context.StopMultiEye(camera);
}
else
{
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, opaqueFilterSettings);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
int w = drawInfo.renderTargetW / drawInfo.tileX;
int h = drawInfo.renderTargetH / drawInfo.tileY;
RenderTextureDescriptor renderTextureDesc = new RenderTextureDescriptor(w, h, RenderTextureFormat.ARGB32, 16);
RenderTexture tempRenderTexture = RenderTexture.GetTemporary(renderTextureDesc);
Camera camera = renderingData.cameraData.camera;
LookingGlassUtil.SetupCameraInfo(camera, perCameraInfo.fov, perCameraInfo.size, perCameraInfo.nearClipFactor, perCameraInfo.farClipFactor);
var opaqueSortFlag = renderingData.cameraData.defaultOpaqueSortFlags;
var opaquedrawSettings = CreateDrawRendererSettings(camera, opaqueSortFlag, rendererConfiguration, renderingData.supportsDynamicBatching);
var transDrawSettings = CreateDrawRendererSettings(camera, SortFlags.CommonTransparent, rendererConfiguration, renderingData.supportsDynamicBatching);
// clear Tile Texture
commandBuffer.SetRenderTarget(dstTiledTexture);
commandBuffer.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(commandBuffer);
context.Submit();
commandBuffer.Clear();
var tileSize = new Vector2(w, h);
int counter = 0;
int tileNum = drawInfo.tileX * drawInfo.tileY;
for (int i = 0; i < drawInfo.tileY; ++i)
{
for (int j = 0; j < drawInfo.tileX; ++j)
{
SetupVPMatrices(context, commandBuffer, camera, counter, tileNum);
commandBuffer.SetRenderTarget(tempRenderTexture);
commandBuffer.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(commandBuffer);
commandBuffer.Clear();
// opaque renderer draw
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref opaquedrawSettings, m_OpaqueFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, m_OpaqueFilterSettings, SortFlags.None);
// transparent renderer Draw
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref transDrawSettings, m_TransparentFilterSettings);
commandBuffer.CopyTexture(tempRenderTexture, 0, 0, 0, 0, tempRenderTexture.width, tempRenderTexture.height,
dstTiledTexture, 0, 0, j * w, i * h);
context.ExecuteCommandBuffer(commandBuffer);
context.Submit();
++counter;
}
}
commandBuffer.Clear();
RenderTexture.ReleaseTemporary(tempRenderTexture);
}
static void InitializeRenderingData(PipelineSettings settings, ref CameraData cameraData, ref CullResults cullResults,
int maxVisibleAdditionalLights, int maxPerObjectAdditionalLights, out RenderingData renderingData)
{
List <VisibleLight> visibleLights = cullResults.visibleLights;
int mainLightIndex = GetMainLight(settings, visibleLights);
bool mainLightCastShadows = false;
bool additionalLightsCastShadows = false;
if (cameraData.maxShadowDistance > 0.0f)
{
mainLightCastShadows = (mainLightIndex != -1 && visibleLights[mainLightIndex].light != null &&
visibleLights[mainLightIndex].light.shadows != LightShadows.None);
// If additional lights are shaded per-pixel they cannot cast shadows
if (settings.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
for (int i = 0; i < visibleLights.Count; ++i)
{
if (i == mainLightIndex)
{
continue;
}
Light light = visibleLights[i].light;
// LWRP doesn't support additional directional lights or point light shadows yet
if (visibleLights[i].lightType == LightType.Spot && light != null && light.shadows != LightShadows.None)
{
additionalLightsCastShadows = true;
break;
}
}
}
}
renderingData.cullResults = cullResults;
renderingData.cameraData = cameraData;
InitializeLightData(settings, visibleLights, mainLightIndex, maxVisibleAdditionalLights, maxPerObjectAdditionalLights, out renderingData.lightData);
InitializeShadowData(settings, visibleLights, mainLightCastShadows, additionalLightsCastShadows && !renderingData.lightData.shadeAdditionalLightsPerVertex, out renderingData.shadowData);
renderingData.supportsDynamicBatching = settings.supportsDynamicBatching;
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (lenticularMat == null)
{
lenticularMat = new Material(Shader.Find("HoloPlay/Lenticular"));
}
PassConfigToMaterial();
lenticularMat.mainTexture = tiledTexture;
CommandBuffer cmd = CommandBufferPool.Get(k_FinalBlitTag);
SetRenderTarget(
cmd,
BuiltinRenderTextureType.CameraTarget,
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.None,
Color.black,
TextureDimension.Tex2D);
cmd.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
cmd.SetViewport(renderingData.cameraData.camera.pixelRect);
ScriptableRenderer.RenderFullscreenQuad(cmd, lenticularMat);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
