public RenderObjectsToTexturePass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags, RenderQueueType renderQueueType, int layerMask, RenderObjectsToTexture.CustomCameraSettings cameraSettings)
{
m_ProfilerTag = profilerTag;
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
// Copy depth buffer material
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/Lightweight Render Pipeline/CopyDepth"));
}
public static RenderQueueType GetOpaqueEquivalent(RenderQueueType type)
{
switch (type)
{
case RenderQueueType.PreRefraction:
case RenderQueueType.Transparent:
case RenderQueueType.LowTransparent:
return(RenderQueueType.Opaque);
case RenderQueueType.AfterPostprocessTransparent:
return(RenderQueueType.AfterPostProcessOpaque);
#if ENABLE_RAYTRACING
case RenderQueueType.RaytracingTransparent:
return(RenderQueueType.RaytracingOpaque);
#else
case RenderQueueType.RaytracingTransparent:
case RenderQueueType.RaytracingOpaque:
return(RenderQueueType.Opaque);
#endif
default:
//keep opaque mapped to opaque
return(type);
case RenderQueueType.Overlay:
case RenderQueueType.Background:
throw new ArgumentException("Unknow RenderQueueType conversion to opaque equivalent, was " + type);
}
}
internal static RenderQueueType MigrateRenderQueueToHDRP10(RenderQueueType renderQueue)
{
switch ((int)renderQueue)
{
case 0: return(RenderQueueType.Background); // Background
case 1: return(RenderQueueType.Opaque); // Opaque
case 2: return(RenderQueueType.AfterPostProcessOpaque); // AfterPostProcessOpaque
case 3: return(RenderQueueType.Opaque); // RaytracingOpaque
case 4: return(RenderQueueType.PreRefraction); // PreRefraction
case 5: return(RenderQueueType.Transparent); // Transparent
case 6: return(RenderQueueType.LowTransparent); // LowTransparent
case 7: return(RenderQueueType.AfterPostprocessTransparent); // AfterPostprocessTransparent
case 8: return(RenderQueueType.Transparent); // RaytracingTransparent
case 9: return(RenderQueueType.Overlay); // Overlay
default:
case 10: return(RenderQueueType.Unknown); // Unknown
}
}
public RenderObjectsPass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags, RenderQueueType renderQueueType, int layerMask, RenderObjects.CustomCameraSettings cameraSettings)
{
m_ProfilerTag = profilerTag;
m_ProfilingSampler = new ProfilingSampler(profilerTag);
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
m_ShaderTagIdList.Add(new ShaderTagId("UniversalForward"));
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
}
public static int ChangeType(RenderQueueType targetType, int offset = 0, bool alphaClip = false)
{
if (offset < -k_TransparentPriorityQueueRange || offset > k_TransparentPriorityQueueRange)
{
throw new ArgumentException("Out of bounds offset, was " + offset);
}
switch (targetType)
{
case RenderQueueType.BackgroundOpaque:
return(alphaClip ? (int)Priority.BackgroundOpaqueAlphaTest : (int)Priority.BackgroundOpaque);
case RenderQueueType.BackgroundTransparent:
return((int)Priority.BackgroundTransparent + offset);
case RenderQueueType.MainOpaque:
return(alphaClip ? (int)Priority.MainOpaqueAlphaTest : (int)Priority.MainOpaque);
case RenderQueueType.MainTransparent:
return((int)Priority.MainTransparent + offset);
case RenderQueueType.UIOverlayOpaque:
return(alphaClip ? (int)Priority.UIOverlayOpaqueAlphaTest : (int)Priority.UIOverlayOpaque);
case RenderQueueType.UIOverlayTransparent:
return((int)Priority.UIOverlayTransparent + offset);
default:
throw new ArgumentException("Unknown RenderQueueType, was " + targetType);
}
}
public static int ChangeType(RenderQueueType targetType, int offset = 0, bool alphaTest = false, bool receiveDecal = false)
{
switch (targetType)
{
case RenderQueueType.Background:
return((int)Priority.Background);
case RenderQueueType.Opaque:
return(alphaTest ?
(receiveDecal ? (int)Priority.OpaqueDecalAlphaTest : (int)Priority.OpaqueAlphaTest) :
(receiveDecal ? (int)Priority.OpaqueDecal : (int)Priority.Opaque));
case RenderQueueType.AfterPostProcessOpaque:
return(alphaTest ? (int)Priority.AfterPostprocessOpaqueAlphaTest : (int)Priority.AfterPostprocessOpaque);
case RenderQueueType.PreRefraction:
return((int)Priority.PreRefraction + offset);
case RenderQueueType.Transparent:
return((int)Priority.Transparent + offset);
case RenderQueueType.LowTransparent:
return((int)Priority.LowTransparent + offset);
case RenderQueueType.AfterPostprocessTransparent:
return((int)Priority.AfterPostprocessTransparent + offset);
case RenderQueueType.Overlay:
return((int)Priority.Overlay);
default:
throw new ArgumentException("Unknown RenderQueueType, was " + targetType);
}
}
public Render2DObjectPass(Renderer2DData rendererData, RenderPassEvent renderPassEvent, string[] lightModeTags, RenderQueueType renderQueueType, int layerMask, RenderObjects.CustomCameraSettings cameraSettings)
{
renderFeaturePassTag = "RenderFeature " + lightModeTags[0];
//Draw setting 相关流程
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent) ? RenderQueueRange.transparent : RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (s_SortingLayers == null)
{
s_SortingLayers = SortingLayer.layers;
}
this.m_CameraSettings = cameraSettings;
//Tag
for (int i = 0; i < lightModeTags.Length; i++)
{
var tag = lightModeTags[i];
ShaderTagId sid = new ShaderTagId(tag);
k_ShaderTags.Add(sid);
}
//
m_Renderer2DData = rendererData;
}
public RenderMetaballsDepthPass(string profilerTag, RenderPassEvent renderPassEvent,
string[] shaderTags, RenderQueueType renderQueueType, int layerMask)
{
profilingSampler = new ProfilingSampler(nameof(RenderObjectsPass));
_profilingSampler = new ProfilingSampler(profilerTag);
this.renderPassEvent = renderPassEvent;
this._renderQueueType = renderQueueType;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
_filteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
_shaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
_shaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
_shaderTagIdList.Add(new ShaderTagId("UniversalForward"));
_shaderTagIdList.Add(new ShaderTagId("UniversalForwardOnly"));
_shaderTagIdList.Add(new ShaderTagId("LightweightForward"));
}
_renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
}
public ClipSphereRenderPass(int layerMask, RenderQueueType queue)
{
if (queue == RenderQueueType.Opaque)
{
filterSettings = new FilteringSettings(RenderQueueRange.opaque, layerMask);
}
else
{
filterSettings = new FilteringSettings(RenderQueueRange.transparent, layerMask);
}
renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
}
public static OpaqueRenderQueue ConvertToOpaqueRenderQueue(RenderQueueType renderQueue)
{
switch (renderQueue)
{
case RenderQueueType.Opaque:
return(OpaqueRenderQueue.Default);
case RenderQueueType.AfterPostProcessOpaque:
return(OpaqueRenderQueue.AfterPostProcessing);
default:
throw new ArgumentException("Cannot map to OpaqueRenderQueue, was " + renderQueue);
}
}
/// <summary>
/// Create a Custom Pass to render objects
/// </summary>
/// <param name="queue">The render queue filter to select which object will be rendered</param>
/// <param name="mask">The layer mask to select which layer(s) will be rendered</param>
/// <param name="overrideMaterial">The replacement material to use when renering objects</param>
/// <param name="overrideMaterialPassIndex">The pass to use in the override material</param>
/// <param name="sorting">Sorting options when rendering objects</param>
/// <param name="clearFlags">Clear options when the target buffers are bound. Before executing the pass</param>
/// <param name="targetColorBuffer">Target Color buffer</param>
/// <param name="targetDepthBuffer">Target Depth buffer. Note: It's also the buffer which will do the Depth Test</param>
/// <returns></returns>
public static CustomPass CreateDrawRenderersPass(RenderQueueType queue, LayerMask mask,
Material overrideMaterial, int overrideMaterialPassIndex = 0, SortingCriteria sorting = SortingCriteria.CommonOpaque,
ClearFlag clearFlags = ClearFlag.None, TargetBuffer targetColorBuffer = TargetBuffer.Camera,
TargetBuffer targetDepthBuffer = TargetBuffer.Camera)
{
return(new DrawRenderersCustomPass()
{
name = "DrawRenderers Pass",
renderQueueType = queue,
layerMask = mask,
overrideMaterial = overrideMaterial,
overrideMaterialPassIndex = overrideMaterialPassIndex,
sortingCriteria = sorting,
clearFlags = clearFlags,
targetColorBuffer = targetColorBuffer,
targetDepthBuffer = targetDepthBuffer,
});
}
public static RenderQueueType GetTransparentEquivalent(RenderQueueType type)
{
switch (type)
{
case RenderQueueType.Opaque:
return(RenderQueueType.Transparent);
case RenderQueueType.AfterPostProcessOpaque:
return(RenderQueueType.AfterPostprocessTransparent);
default:
//keep transparent mapped to transparent
return(type);
case RenderQueueType.Overlay:
case RenderQueueType.Background:
throw new ArgumentException("Unknow RenderQueueType conversion to transparent equivalent, was " + type);
}
}
public static TransparentRenderQueue ConvertToTransparentRenderQueue(RenderQueueType renderQueue)
{
switch (renderQueue)
{
case RenderQueueType.PreRefraction:
return(TransparentRenderQueue.BeforeRefraction);
case RenderQueueType.Transparent:
return(TransparentRenderQueue.Default);
case RenderQueueType.LowTransparent:
return(TransparentRenderQueue.LowResolution);
case RenderQueueType.AfterPostprocessTransparent:
return(TransparentRenderQueue.AfterPostProcessing);
default:
throw new ArgumentException("Cannot map to TransparentRenderQueue, was " + renderQueue);
}
}
public FurRenderPass(PassSettings setting, FurRenderFeature render, FilterSettings filterSettings)
{
m_ProfilerTag = setting.passTag;
string[] shaderTags = filterSettings.PassNames;
this.settings = setting;
this.renderQueueType = filterSettings.RenderQueueType;
furRenderFeature = render;
//过滤设定
RenderQueueRange queue = new RenderQueueRange();
queue.lowerBound = setting.QueueMin;
queue.upperBound = setting.QueueMax;
filter = new FilteringSettings(queue, filterSettings.LayerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
}
public static RenderQueueType GetTransparentEquivalent(RenderQueueType type)
{
switch (type)
{
case RenderQueueType.Opaque:
return(RenderQueueType.Transparent);
case RenderQueueType.AfterPostProcessOpaque:
return(RenderQueueType.AfterPostprocessTransparent);
case RenderQueueType.LowTransparent:
return(RenderQueueType.LowTransparent);
case RenderQueueType.RaytracingOpaque:
{
if ((RenderPipelineManager.currentPipeline as HDRenderPipeline).rayTracingSupported)
{
return(RenderQueueType.RaytracingTransparent);
}
return(RenderQueueType.Transparent);
}
case RenderQueueType.RaytracingTransparent:
{
if (!(RenderPipelineManager.currentPipeline as HDRenderPipeline).rayTracingSupported)
{
return(RenderQueueType.Transparent);
}
return(RenderQueueType.RaytracingTransparent);
}
default:
//keep transparent mapped to transparent
return(type);
case RenderQueueType.Overlay:
case RenderQueueType.Background:
throw new ArgumentException("Unknow RenderQueueType conversion to transparent equivalent, was " + type);
}
}
public RenderMetaballsPass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags,
RenderQueueType renderQueueType, int layerMask, RenderObjects.CustomCameraSettings cameraSettings, int downsamplingAmount)
{
profilingSampler = new ProfilingSampler(nameof(RenderObjectsPass));
m_ProfilingSampler = new ProfilingSampler(profilerTag);
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
m_ShaderTagIdList.Add(new ShaderTagId("UniversalForward"));
m_ShaderTagIdList.Add(new ShaderTagId("UniversalForwardOnly"));
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
BlitCopyDepthMaterial = new Material(Shader.Find("Hidden/BlitToDepth"));
BlurMaterial = new Material(Shader.Find("Hidden/KawaseBlur"));
_downsamplingAmount = downsamplingAmount;
}
public RenderObjectsToRTPass(string profilerTag,
RenderPassEvent renderPassEvent,
string[] shaderTags,
RenderQueueType renderQueueType,
int layerMask,
uint renderLayerMask,
RenderObjectsToRT.CustomCameraSettingsRT cameraSettings)
{
m_ColorTextureHandle.Init("_CameraColorTexture");
m_DepthAttachmentTextureHandle.Init("_CameraDepthAttachment");
m_ProfilerTag = profilerTag;
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask, renderLayerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
}
public MyRenderObjectsPass(RenderObjectsSettings settings)
{
var filterSettings = settings.filterSettings;
profilerTag = settings.passTag;
profilingSampler = new ProfilingSampler(profilerTag);
renderPassEvent = settings.renderPassEvent;
renderQueueType = filterSettings.renderQueueType;
overrideMaterial = null;
overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
filteringSettings = new FilteringSettings(renderQueueRange, filterSettings.layerMask,
(uint)Mathf.Pow(2, filterSettings.renderingLayerMask));
var shaderTags = filterSettings.shaderTags;
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var tag in shaderTags)
{
shaderTagIdList.Add(new ShaderTagId(tag));
}
}
else
{
shaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
shaderTagIdList.Add(new ShaderTagId("UniversalForward"));
shaderTagIdList.Add(new ShaderTagId("LightweightForward"));
}
renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
cameraSettings = settings.cameraSettings;
}
public FilterSettings()
{
RenderQueueType = RenderQueueType.Opaque;
LayerMask = 0;
}
public FilterSettings()
{
RenderQueueType = RenderQueueType.Opaque;
LayerMask = ~0;
PassNames = new string[] { "FurRendererBase", "FurRendererLayer" };
}
public FilterSettings()
{
renderQueueType = RenderQueueType.Opaque;
layerMask = 0;
renderingLayerMask = 0;
}
internal RenderObjectsPass(URPProfileId profileId, RenderPassEvent renderPassEvent, string[] shaderTags, RenderQueueType renderQueueType, int layerMask, RenderObjects.CustomCameraSettings cameraSettings)
: this(profileId.GetType().Name, renderPassEvent, shaderTags, renderQueueType, layerMask, cameraSettings)
{
m_ProfilingSampler = ProfilingSampler.Get(profileId);
}
void Reset()
{
queue = RenderQueueType.GEOMETRY;
}
public FilterSettingsRT()
{
RenderQueueType = RenderQueueType.Opaque;
LayerMask = 0;
RenderingLayerMask = UInt32.MaxValue;
}
