public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle depthAttachmentHandle)
{
this.depthAttachmentHandle = depthAttachmentHandle;
baseDescriptor.colorFormat = RenderTextureFormat.ARGB32;
baseDescriptor.depthBufferBits = kDepthBufferBits;
descriptor = baseDescriptor;
}
//
// ----------------------------------------------------------------
//
public void Setup(RenderTextureDescriptor baseDesc, RenderTargetHandle targetHandle)
{
this.targetHandle = targetHandle;
baseDesc.colorFormat = RenderTextureFormat.ARGB32;
baseDesc.depthBufferBits = kDepthBufferBits;
descriptor = baseDesc;
}
public GrabPassImpl(Material blurMaterial, Vector2 blurAmount, Material blitMaterial, RenderTargetHandle colorHandle)
{
m_BlurMaterial = blurMaterial;
m_ColorHandle = colorHandle;
m_BlitMaterial = blitMaterial;
m_BlurAmount = blurAmount;
}
public override void Update(GameTime gameTime)
{
if (this.GameState.StereoMode != (this.DrawOrder == 1002))
{
this.DrawOrder = this.GameState.StereoMode ? 1002 : 1001;
this.OnDrawOrderChanged((object)this, EventArgs.Empty);
}
if (this.Visible)
{
if (this.GameState.StereoMode && this.rth == null)
{
this.rth = this.TargetRenderer.TakeTarget();
this.TargetRenderer.ScheduleHook(this.DrawOrder, this.rth.Target);
}
else if (this.rth != null && !this.GameState.StereoMode)
{
this.TargetRenderer.ReturnTarget(this.rth);
this.rth = (RenderTargetHandle)null;
}
}
if (this.Visible || this.rth == null)
{
return;
}
this.TargetRenderer.ReturnTarget(this.rth);
this.rth = (RenderTargetHandle)null;
}
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
{
Init();
renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
renderer.EnqueuePass(m_SetupForwardRenderingPass);
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
Camera camera = renderingData.cameraData.camera;
var rendererConfiguration = ScriptableRenderer.GetRendererConfiguration(renderingData.lightData.additionalLightsCount);
m_SetupLightweightConstants.Setup(renderer.maxVisibleAdditionalLights, renderer.perObjectLightIndices);
renderer.EnqueuePass(m_SetupLightweightConstants);
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ScriptableRenderer.GetCameraClearFlag(camera), camera.backgroundColor, rendererConfiguration);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
}
public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle mainLightShadowmapHandle)
{
if (null == _Compute)
{
_Enabled = false;
return;
}
//_KernelFiltering = _Compute.FindKernel(_KernelFilteringName);
_KernelFirstFiltering = _Compute.FindKernel(_KernelFirstFilteringName);
_Compute.GetKernelThreadGroupSizes(_KernelFirstFiltering, out _NumThreadX, out _NumThreadY, out _NumThreadZ);
if (_ShadowMapsPrecision == ShadowMapsPrecision.Half)
{
_SMFormat = RenderTextureFormat.ARGBHalf;
}
else
{
_SMFormat = RenderTextureFormat.ARGBFloat;
}
baseDescriptor.depthBufferBits = 0;
baseDescriptor.colorFormat = _SMFormat;
bool useMipmaps = _UseMipmaps;
baseDescriptor.autoGenerateMips = useMipmaps;
baseDescriptor.useMipMap = useMipmaps;
baseDescriptor.enableRandomWrite = true;
_MainLightFilteredSMDescriptor = baseDescriptor;
}
/// <summary>
/// Configure the pass with the source and destination to execute on.
/// </summary>
/// <param name="source">Source Render Target</param>
/// <param name="destination">Destination Render Target</param>
public void Setup(RenderTargetHandle source, RenderTargetHandle destination, float samplerScale)
{
this.m_Source = source;
this.m_Destination = destination;
this.m_SamplerScale = samplerScale;
}
public override void FrameCleanup(CommandBuffer cmd)
{
if (depthNormalsHandle != RenderTargetHandle.CameraTarget)
{
cmd.ReleaseTemporaryRT(depthNormalsHandle.id);
depthNormalsHandle = RenderTargetHandle.CameraTarget;
}
}
public void Setup(RenderPassEvent @event, RenderTargetIdentifier source, RenderTargetHandle destination, RayMarchingProcessData data)
{
m_Data = data;
renderPassEvent = @event;
m_ColorAttachment = source;
m_Destination = destination;
m_Materials = new MaterialLibrary(data);
}
/// <summary>
/// Configure the pass
/// </summary>
/// <param name="baseDescriptor"></param>
/// <param name="colorHandle"></param>
/// <param name="clearBlitTarget"></param>
/// <param name="pixelRect"></param>
public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle, bool clearBlitTarget = false, Rect pixelRect = new Rect())
{
m_Source = colorHandle;
m_TargetDimension = baseDescriptor.dimension;
m_ClearBlitTarget = clearBlitTarget;
m_IsMobileOrSwitch = Application.isMobilePlatform || Application.platform == RuntimePlatform.Switch;
m_PixelRect = pixelRect;
}
public GrabBlurPassImpl(RenderTargetHandle colorHandle)
{
m_ColorHandle = colorHandle;
m_Blur = new CommandBufferBlur();
m_BlurTemp1 = Shader.PropertyToID("_Temp1");
m_BlurTemp2 = Shader.PropertyToID("_Temp2");
}
ScriptableRenderPass IAfterTransparentPass.GetPassToEnqueue(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle,
RenderTargetHandle depthHandle)
{
var pass = new CopyColorPass(m_SamplingMaterial);
pass.Setup(colorHandle, afterTransparent);
return(pass);
}
ScriptableRenderPass IAfterSkyboxPass.GetPassToEnqueue(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle,
RenderTargetHandle depthHandle)
{
var pass = new CopyColorPass();
pass.Setup(colorHandle, afterSkybox);
return(pass);
}
public override void FrameCleanup(CommandBuffer cmd)
{
if (m_Target != RenderTargetHandle.CameraTarget)
{
cmd.ReleaseTemporaryRT(m_Target.id);
m_Target = RenderTargetHandle.CameraTarget;
}
}
ScriptableRenderPass IAfterOpaquePass.GetPassToEnqueue(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle)
{
var pass = new CopyColorPass();
pass.Setup(colorAttachmentHandle, afterOpaque);
return(pass);
}
public void Setup(ScriptableRenderer renderer, RenderTargetHandle dst)
{
_renderer = renderer;
_destination = dst;
#if UNITY_2020_3_OR_NEWER
ConfigureInput(ScriptableRenderPassInput.Depth);
#endif
}
public static RenderTargetIdentifier Request(CommandBuffer cmd, RenderTextureDescriptor renderTextureDescriptor, FilterMode filterMode = FilterMode.Point)
{
var handle = new RenderTargetHandle();
handle.Init("_POST_PROCESSING_TEMP_" + _tempIndex++);
cmd.GetTemporaryRT(handle.id, renderTextureDescriptor, filterMode);
_usingTempRTs.Add(handle.Identifier(), handle);
return(handle.Identifier());
}
public FarawayTransition(Game game)
: base(game)
{
this.DrawOrder = 1;
ITargetRenderingManager renderingManager = ServiceHelper.Get <ITargetRenderingManager>();
this.SkyRt = renderingManager.TakeTarget();
renderingManager.ScheduleHook(this.DrawOrder, this.SkyRt.Target);
}
public void Setup(RenderTargetIdentifier source, RenderTargetHandle destination)
{
this.source = source;
this.destination = destination;
m_Blur = new CommandBufferBlur();
m_BlurTemp1 = Shader.PropertyToID("_Temp1");
m_BlurTemp2 = Shader.PropertyToID("_Temp2");
}
public MyRenderObjectsPass(RenderTargetHandle destination, int layerMask, Material overrideMaterial)
{
_destination = destination;
_overrideMaterial = overrideMaterial;
_filteringSettings = new FilteringSettings(RenderQueueRange.opaque, layerMask);
_renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
}
/// <summary>
/// Configure the pass with the source and destination to execute on.
/// </summary>
/// <param name="source">Source Render Target</param>
/// <param name="destination">Destination Render Targt</param>
public void Setup(RenderTargetHandle source, RenderTargetHandle destination, bool outline = false)
{
this.source = source;
this.destination = destination;
PersistentRenderTexture.Init();
this.outlineRT = outline;
this.outlineRTH.Init("_MaskDepthTexture");
this.blitMat = AssetDatabase.LoadAssetAtPath <Material>("Assets/ShaderLab/9.Outline/_aterial.mat");
}
/// <summary>
/// Create, setup and return a ScriptableRenderPass that will blit the pass-thru video when this GameObject is rendered.
/// </summary>
/// <param name="baseDescriptor">RenderTextureDescriptor for this pass. </param>
/// <param name="colorHandle">RenderTargetHandle for color buffer.</param>
/// <param name="depthHandle">RenderTargetHandle for depth buffer.</param>
/// <param name="clearFlag">ClearFlag used for rendering.</param>
/// <returns></returns>
public ScriptableRenderPass GetPassToEnqueue(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle,
RenderTargetHandle depthHandle, ClearFlag clearFlag)
{
var lwrpBackgroundRenderPass = new LWRPBackgroundRenderPass();
lwrpBackgroundRenderPass.Setup(blitMaterial, colorHandle.Identifier(), depthHandle.Identifier(),
baseDescriptor);
return(lwrpBackgroundRenderPass);
}
void CreateRenderTextures(
ref CameraData cameraData,
bool forceCreateColorTexture,
FilterMode colorTextureFilterMode,
CommandBuffer cmd,
out RenderTargetHandle colorTargetHandle,
out RenderTargetHandle depthTargetHandle)
{
ref var cameraTargetDescriptor = ref cameraData.cameraTargetDescriptor;
public BlurPass(RenderTargetIdentifier source, RenderTargetHandle destination, Material blurMaterial, int downSample, int passesCount)
{
_source = source;
_destination = destination;
_blurMaterial = blurMaterial;
_downSample = downSample;
_passesCount = passesCount;
}
