Beautify addon
This commit is contained in:
Williams
@@ -0,0 +1,600 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Experimental.Rendering;
|
||||
using UnityEngine.Rendering;
|
||||
using UnityEngine.Rendering.Universal;
|
||||
|
||||
namespace EdgeFusion {
|
||||
|
||||
// -------------------------------------------------------------------------------------------
|
||||
// PORT NOTES (Unity 2022.3 LTS / URP 14 - classic ScriptableRenderPass API)
|
||||
// -------------------------------------------------------------------------------------------
|
||||
// The original (Unity 6 / URP 17) implementation is built entirely on the Render Graph API
|
||||
// (RecordRenderGraph / TextureHandle / RasterGraphContext). URP 14 does not have Render Graph,
|
||||
// so this version uses the classic Execute(ScriptableRenderContext, ref RenderingData) API with
|
||||
// manually managed RTHandles, matching the same pass structure and shader contract 1:1:
|
||||
// 1) ObjectID pass -> objectID RT (+ its own depth RT if the camera uses MSAA)
|
||||
// 2) Special-group pass -> customGroup RT (only if a special group is configured)
|
||||
// 3) Fill ObjectID pass -> objectIDFilled RT (only if needed, same condition as original)
|
||||
// 4) Blend pass -> compare RT (if comparing) or camera color
|
||||
// 5) Compare pass -> camera color (if comparing)
|
||||
// 6) Debug pass -> camera color (if a debug mode is active and not comparing)
|
||||
// 7) Copy-back -> not needed here, see note at the bottom of Execute()
|
||||
//
|
||||
// Differences from the Unity 6 version worth knowing about:
|
||||
// - RTHandles are allocated once and reused/reallocated on demand (RenderingUtils.ReAllocateIfNeeded)
|
||||
// instead of being requested fresh from the render graph every frame.
|
||||
// - `Object.FindObjectsByType` (used in the original for id-exclusion lookup) does not exist in
|
||||
// 2022.3; this file uses the classic `Object.FindObjectsOfType<Volume>()` instead.
|
||||
// - The classic renderer exposes `ScriptableRenderer.cameraColorTargetHandle` /
|
||||
// `cameraDepthTargetHandle` directly; there is no `UniversalResourceData`/`UniversalCameraData`
|
||||
// frame-data container to reroute.
|
||||
// - Camera-stack detection uses the same UniversalAdditionalCameraData.cameraStack check as the
|
||||
// original, kept here for parity/documentation even though the classic renderer doesn't need an
|
||||
// explicit copy-back step (see the note at the end of Execute()).
|
||||
//
|
||||
// This file has been ported by careful, line-by-line reading of the Unity 6 implementation and the
|
||||
// URP 14 classic API; it has not been compiled/run inside the Editor. Please test in your 2022.3
|
||||
// project (single camera, stacked cameras, MSAA on/off, and XR if you use it) before shipping.
|
||||
// -------------------------------------------------------------------------------------------
|
||||
|
||||
public class EdgeFusionRenderPass : ScriptableRenderPass {
|
||||
|
||||
// Shader names
|
||||
const string OBJECT_ID_SHADER_PATH = "Kronnect/EdgeFusion/ObjectID";
|
||||
const string FUSION_SHADER_PATH = "Hidden/Kronnect/EdgeFusion/EdgeFusion";
|
||||
const string FUSION_FILL_SHADER_PATH = "Hidden/Kronnect/EdgeFusion/EdgeFusionFill";
|
||||
|
||||
// Texture names
|
||||
const string OBJECT_ID_TEXTURE_NAME = "EdgeFusion_ObjectID";
|
||||
const string OBJECT_ID_FILLED_TEXTURE_NAME = "EdgeFusion_ObjectID_Filled";
|
||||
const string OBJECT_ID_DEPTH_TEXTURE_NAME = "EdgeFusion_ObjectID_Depth";
|
||||
const string CUSTOM_GROUP_TEXTURE_NAME = "EdgeFusion_CustomGroups";
|
||||
const string CAMERA_COLOR_TEXTURE_NAME = "EdgeFusion_CameraColor";
|
||||
const string COMPARE_TEXTURE_NAME = "EdgeFusion_CompareTex";
|
||||
|
||||
// Profiling / pass name
|
||||
const string PROFILING_NAME = "Edge Fusion";
|
||||
|
||||
static readonly ProfilingSampler profilingSampler = new ProfilingSampler(PROFILING_NAME);
|
||||
|
||||
EdgeFusionRenderFeature feature;
|
||||
Material objectIDMaterial;
|
||||
Material fusionMaterial;
|
||||
Material fusionFillMaterial;
|
||||
readonly List<ShaderTagId> shaderTags;
|
||||
GraphicsFormat objectIdTextureFormat;
|
||||
Texture3D noiseTex;
|
||||
static readonly float[] exclusionMask = new float[32];
|
||||
static readonly uint[] exclusionMaskBits = new uint[32];
|
||||
static Volume cachedExclusionVolume;
|
||||
static EdgeFusion cachedEdgeFusion;
|
||||
|
||||
// RTHandles reused/reallocated across frames
|
||||
RTHandle objectIDHandle;
|
||||
RTHandle objectIDFilledHandle;
|
||||
RTHandle objectIDDepthHandle;
|
||||
RTHandle customGroupHandle;
|
||||
RTHandle compareHandle;
|
||||
RTHandle cameraColorCopyHandle; // holds the pre-effect camera color (blend source & compare source)
|
||||
|
||||
static bool CanStoreMaskValue (uint value) {
|
||||
return (uint)(float)value == value;
|
||||
}
|
||||
|
||||
public EdgeFusionRenderPass (EdgeFusionRenderFeature feature) {
|
||||
this.feature = feature;
|
||||
shaderTags = new List<ShaderTagId> {
|
||||
new ShaderTagId("SRPDefaultUnlit"),
|
||||
new ShaderTagId("UniversalForward"),
|
||||
new ShaderTagId("UniversalForwardOnly"),
|
||||
new ShaderTagId("LightweightForward")
|
||||
};
|
||||
|
||||
var rg32Format = GraphicsFormat.R32G32_SFloat;
|
||||
bool canUseRG32Format = SystemInfo.IsFormatSupported(rg32Format, FormatUsage.Render);
|
||||
objectIdTextureFormat = canUseRG32Format ? rg32Format : GraphicsFormat.R32G32B32A32_SFloat;
|
||||
|
||||
InitializeMaterials();
|
||||
}
|
||||
|
||||
public void UpdateInputRequirement (EdgeFusion settings) {
|
||||
ConfigureInput(ScriptableRenderPassInput.Depth);
|
||||
}
|
||||
|
||||
void InitializeMaterials () {
|
||||
if (objectIDMaterial == null) {
|
||||
var shader = Shader.Find(OBJECT_ID_SHADER_PATH);
|
||||
if (shader != null) objectIDMaterial = CoreUtils.CreateEngineMaterial(shader);
|
||||
if (objectIDMaterial != null) objectIDMaterial.enableInstancing = true;
|
||||
}
|
||||
|
||||
if (fusionMaterial == null) {
|
||||
var shader = Shader.Find(FUSION_SHADER_PATH);
|
||||
if (shader != null) fusionMaterial = CoreUtils.CreateEngineMaterial(shader);
|
||||
}
|
||||
|
||||
if (fusionFillMaterial == null) {
|
||||
var shader = Shader.Find(FUSION_FILL_SHADER_PATH);
|
||||
if (shader != null) fusionFillMaterial = CoreUtils.CreateEngineMaterial(shader);
|
||||
}
|
||||
|
||||
noiseTex = Resources.Load<Texture3D>("EdgeFusion/Textures/NoiseTex3D");
|
||||
}
|
||||
|
||||
void UpdateMaterialProperties (EdgeFusion settings, bool taa, float effectiveMaxBlendDistance, bool cameraUsesMsaa, bool specialGroupActive) {
|
||||
|
||||
float mappedNoiseContrast = Mathf.Lerp(0.5f, 0.01f, settings.noiseContrast.value);
|
||||
|
||||
Vector4 blendData1 = new Vector4(
|
||||
settings.intensity.value, // x: GlobalIntensity
|
||||
effectiveMaxBlendDistance, // y: MaxBlendDistance
|
||||
settings.normalThreshold.value, // z: NormalThreshold
|
||||
mappedNoiseContrast // w: NoiseContrast
|
||||
);
|
||||
|
||||
Vector4 blendData2 = new Vector4(
|
||||
settings.maxScreenRadius.value, // x: MaxScreenRadius
|
||||
settings.shadowProtection.value, // y: ShadowProtection
|
||||
settings.noiseIntensity.value, // z: NoiseIntensity
|
||||
settings.noiseScale.value // w: NoiseScale
|
||||
);
|
||||
|
||||
float radiusScale = Mathf.Max(1f, settings.radius.value / 0.89f);
|
||||
|
||||
fusionMaterial.SetVector(ShaderParams.BlendData1, blendData1);
|
||||
fusionMaterial.SetVector(ShaderParams.BlendData2, blendData2);
|
||||
fusionMaterial.SetFloat(ShaderParams.DefaultRadiusWorld, settings.radius.value);
|
||||
fusionMaterial.SetFloat(ShaderParams.RadiusScale, radiusScale);
|
||||
fusionMaterial.SetFloat(ShaderParams.DistanceCompensation, settings.distanceCompensation.value);
|
||||
fusionMaterial.SetInt(ShaderParams.SampleCount, settings.sampleCount.value);
|
||||
fusionMaterial.SetInt(ShaderParams.BinarySearchSteps, settings.binarySearchSteps.value);
|
||||
fusionMaterial.SetInt(ShaderParams.EarlyExitHits, settings.earlyExitHits.value);
|
||||
if (settings.antiFlicker.value) {
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_ANTI_FLICKER);
|
||||
}
|
||||
else {
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_ANTI_FLICKER);
|
||||
}
|
||||
fusionMaterial.SetTexture(ShaderParams.NoiseTex3D, noiseTex);
|
||||
|
||||
fusionFillMaterial.SetVector(ShaderParams.BlendData1, blendData1);
|
||||
fusionFillMaterial.SetVector(ShaderParams.BlendData2, blendData2);
|
||||
fusionFillMaterial.SetFloat(ShaderParams.DefaultRadiusWorld, settings.radius.value);
|
||||
fusionFillMaterial.SetFloat(ShaderParams.RadiusScale, radiusScale);
|
||||
fusionFillMaterial.SetFloat(ShaderParams.DistanceCompensation, settings.distanceCompensation.value);
|
||||
|
||||
float msaaFixPower = settings.msaaEdgeFixPower.value;
|
||||
if (cameraUsesMsaa && msaaFixPower > 0f) {
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_MSAA_EDGE_FIX);
|
||||
fusionMaterial.SetFloat(ShaderParams.MsaaFixPower, msaaFixPower);
|
||||
}
|
||||
else {
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_MSAA_EDGE_FIX);
|
||||
}
|
||||
|
||||
// ObjectID material setup
|
||||
objectIDMaterial.SetFloat(ShaderParams.MaxBlendDistance, effectiveMaxBlendDistance);
|
||||
objectIDMaterial.SetFloat(ShaderParams.DefaultRadiusWorld, settings.radius.value);
|
||||
objectIDMaterial.SetFloat(ShaderParams.RadiusScale, radiusScale);
|
||||
objectIDMaterial.SetFloat(ShaderParams.DistanceCompensation, settings.distanceCompensation.value);
|
||||
objectIDMaterial.SetVector(ShaderParams.BlendData2, blendData2);
|
||||
objectIDMaterial.SetInt(ShaderParams.ZWrite, cameraUsesMsaa ? 1 : 0);
|
||||
objectIDMaterial.SetInt(ShaderParams.ZTest, cameraUsesMsaa ? (int)CompareFunction.LessEqual : (int)CompareFunction.Equal);
|
||||
objectIDMaterial.SetFloat(ShaderParams.DisallowIntraFusion, settings.intraObjectFusionPerObject.value ? 1f : 0f);
|
||||
|
||||
if (cameraUsesMsaa) {
|
||||
objectIDMaterial.EnableKeyword(ShaderParams.SKW_MSAA_ON);
|
||||
}
|
||||
else {
|
||||
objectIDMaterial.DisableKeyword(ShaderParams.SKW_MSAA_ON);
|
||||
}
|
||||
|
||||
DebugMode debugMode = settings.debugMode.value;
|
||||
if (debugMode == DebugMode.SpecialGroup && !specialGroupActive) debugMode = DebugMode.None;
|
||||
fusionMaterial.SetInt(ShaderParams.DebugMode, (int)debugMode);
|
||||
fusionMaterial.SetFloat(ShaderParams.DepthDebugMultiplier, settings.depthDebugMultiplier.value);
|
||||
|
||||
bool normalsDebug = debugMode == DebugMode.Normals;
|
||||
if (normalsDebug) {
|
||||
objectIDMaterial.EnableKeyword(ShaderParams.SKW_DEBUG_BLEND_NORMALS);
|
||||
fusionFillMaterial.EnableKeyword(ShaderParams.SKW_DEBUG_BLEND_NORMALS);
|
||||
}
|
||||
else {
|
||||
objectIDMaterial.DisableKeyword(ShaderParams.SKW_DEBUG_BLEND_NORMALS);
|
||||
fusionFillMaterial.DisableKeyword(ShaderParams.SKW_DEBUG_BLEND_NORMALS);
|
||||
}
|
||||
|
||||
// Jitter keyword toggle
|
||||
if (settings.jitter.value) {
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_ENABLE_JITTER);
|
||||
fusionMaterial.SetFloat(ShaderParams.JitterFrame, taa ? Time.frameCount : 0);
|
||||
}
|
||||
else {
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_ENABLE_JITTER);
|
||||
}
|
||||
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_INTRA_OBJECT_FUSION);
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_CONCAVE_ONLY);
|
||||
objectIDMaterial.DisableKeyword(ShaderParams.SKW_INTRA_OBJECT_FUSION);
|
||||
objectIDMaterial.DisableKeyword(ShaderParams.SKW_CONCAVE_ONLY);
|
||||
fusionFillMaterial.DisableKeyword(ShaderParams.SKW_INTRA_OBJECT_FUSION);
|
||||
fusionFillMaterial.DisableKeyword(ShaderParams.SKW_CONCAVE_ONLY);
|
||||
bool intraObjectFusionPerObject = settings.intraObjectFusionPerObject.value;
|
||||
if (settings.enableIntraObjectFusion.value) {
|
||||
if (settings.concavityTest.value) {
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_CONCAVE_ONLY);
|
||||
objectIDMaterial.EnableKeyword(ShaderParams.SKW_CONCAVE_ONLY);
|
||||
if (!intraObjectFusionPerObject) {
|
||||
fusionFillMaterial.EnableKeyword(ShaderParams.SKW_CONCAVE_ONLY);
|
||||
}
|
||||
}
|
||||
else {
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_INTRA_OBJECT_FUSION);
|
||||
objectIDMaterial.EnableKeyword(ShaderParams.SKW_INTRA_OBJECT_FUSION);
|
||||
if (!intraObjectFusionPerObject) {
|
||||
fusionFillMaterial.EnableKeyword(ShaderParams.SKW_INTRA_OBJECT_FUSION);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (settings.noiseIntensity.value > 0.0f) {
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_NOISE);
|
||||
}
|
||||
else {
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_NOISE);
|
||||
}
|
||||
|
||||
if (specialGroupActive) {
|
||||
fusionFillMaterial.EnableKeyword(ShaderParams.SKW_SPECIAL_GROUP);
|
||||
}
|
||||
else {
|
||||
fusionFillMaterial.DisableKeyword(ShaderParams.SKW_SPECIAL_GROUP);
|
||||
}
|
||||
|
||||
var exclusionPairs = GetActiveExclusionPairs();
|
||||
if (exclusionPairs != null && exclusionPairs.Length > 0) {
|
||||
System.Array.Clear(exclusionMask, 0, 32);
|
||||
System.Array.Clear(exclusionMaskBits, 0, 32);
|
||||
bool hasEnabledPairs = false;
|
||||
int exclusionPairCount = exclusionPairs.Length;
|
||||
for (int i = 0; i < exclusionPairCount; i++) {
|
||||
var pair = exclusionPairs[i];
|
||||
if (!pair.enabled) continue;
|
||||
|
||||
hasEnabledPairs = true;
|
||||
int a = Mathf.Clamp(pair.idA, 1, 32) - 1;
|
||||
int b = Mathf.Clamp(pair.idB, 1, 32) - 1;
|
||||
uint bitForA = 1u << b;
|
||||
uint bitForB = 1u << a;
|
||||
|
||||
if (a == b) {
|
||||
uint candidate = exclusionMaskBits[a] | bitForA;
|
||||
if (CanStoreMaskValue(candidate)) {
|
||||
exclusionMaskBits[a] = candidate;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
uint candidateA = exclusionMaskBits[a] | bitForA;
|
||||
uint candidateB = exclusionMaskBits[b] | bitForB;
|
||||
|
||||
bool canA = CanStoreMaskValue(candidateA);
|
||||
bool canB = CanStoreMaskValue(candidateB);
|
||||
|
||||
if (canA && (!canB || candidateA <= candidateB)) {
|
||||
exclusionMaskBits[a] = candidateA;
|
||||
}
|
||||
else if (canB) {
|
||||
exclusionMaskBits[b] = candidateB;
|
||||
}
|
||||
}
|
||||
|
||||
if (hasEnabledPairs) {
|
||||
for (int i = 0; i < 32; i++) {
|
||||
uint maskValue = exclusionMaskBits[i];
|
||||
exclusionMask[i] = maskValue;
|
||||
}
|
||||
fusionMaterial.EnableKeyword(ShaderParams.SKW_ID_EXCLUSION);
|
||||
fusionMaterial.SetFloatArray(ShaderParams.ExclusionMask, exclusionMask);
|
||||
}
|
||||
else {
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_ID_EXCLUSION);
|
||||
}
|
||||
|
||||
}
|
||||
else {
|
||||
fusionMaterial.DisableKeyword(ShaderParams.SKW_ID_EXCLUSION);
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------
|
||||
// Classic execution
|
||||
// -----------------------------------------------------------------------------------
|
||||
|
||||
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
||||
|
||||
if (feature == null) return;
|
||||
var settings = VolumeManager.instance.stack.GetComponent<EdgeFusion>();
|
||||
if (settings == null || !settings.IsActive()) return;
|
||||
|
||||
if (objectIDMaterial == null || fusionMaterial == null || fusionFillMaterial == null) {
|
||||
InitializeMaterials();
|
||||
if (objectIDMaterial == null || fusionMaterial == null || fusionFillMaterial == null) return;
|
||||
}
|
||||
|
||||
ref var cameraData = ref renderingData.cameraData;
|
||||
if (EdgeFusionRenderFeature.IsDepthOnlyTarget(cameraData.cameraTargetDescriptor)) return;
|
||||
|
||||
var renderer = cameraData.renderer;
|
||||
RTHandle cameraColorTargetHandle = renderer.cameraColorTargetHandle;
|
||||
RTHandle cameraDepthTargetHandle = renderer.cameraDepthTargetHandle;
|
||||
if (cameraColorTargetHandle == null) return;
|
||||
|
||||
CommandBuffer cmd = CommandBufferPool.Get(PROFILING_NAME);
|
||||
using (new ProfilingScope(cmd, profilingSampler)) {
|
||||
|
||||
bool cameraUsesMsaa = cameraData.cameraTargetDescriptor.msaaSamples > 1;
|
||||
bool taa = cameraData.antialiasing == AntialiasingMode.TemporalAntiAliasing && !cameraUsesMsaa;
|
||||
|
||||
int cameraCullingMask = cameraData.camera.cullingMask;
|
||||
int effectiveBlendLayers = settings.blendLayers.value & cameraCullingMask;
|
||||
int effectiveDoubleSided = settings.doubleSidedLayers.value & cameraCullingMask;
|
||||
int effectiveSpecialGroup = settings.specialGroupLayers.value & cameraCullingMask;
|
||||
|
||||
uint rlMaskSingle = settings.renderingLayerFilter.value;
|
||||
uint rlMaskDouble = settings.doubleSidedRenderingLayerFilter.value;
|
||||
uint rlMaskSpecial = settings.specialGroupRenderingLayerFilter.value;
|
||||
|
||||
int ssMask = effectiveBlendLayers;
|
||||
int dsMask = effectiveDoubleSided;
|
||||
int specialMask = effectiveSpecialGroup;
|
||||
|
||||
if ((dsMask & specialMask) != 0 && RenderingLayersOverlap(rlMaskSpecial, rlMaskDouble)) {
|
||||
dsMask &= ~specialMask;
|
||||
}
|
||||
if ((ssMask & specialMask) != 0 && RenderingLayersOverlap(rlMaskSpecial, rlMaskSingle)) {
|
||||
ssMask &= ~specialMask;
|
||||
}
|
||||
if ((ssMask & dsMask) != 0 && RenderingLayersOverlap(rlMaskDouble, rlMaskSingle)) {
|
||||
ssMask &= ~dsMask;
|
||||
}
|
||||
|
||||
bool hasSingleSided = ssMask != 0 && rlMaskSingle != 0u;
|
||||
bool hasDoubleSided = dsMask != 0 && rlMaskDouble != 0u;
|
||||
bool hasSpecialGroup = specialMask != 0 && rlMaskSpecial != 0u;
|
||||
uint specialGroupCombined = hasSpecialGroup ? rlMaskSpecial : 0u;
|
||||
|
||||
if (!hasSingleSided && !hasDoubleSided && !hasSpecialGroup) {
|
||||
CommandBufferPool.Release(cmd);
|
||||
return;
|
||||
}
|
||||
|
||||
float effectiveMaxBlendDistance = settings.maxBlendDistance.value;
|
||||
if (cameraData.camera.orthographic) {
|
||||
effectiveMaxBlendDistance = 1e10f;
|
||||
}
|
||||
|
||||
UpdateMaterialProperties(settings, taa, effectiveMaxBlendDistance, cameraUsesMsaa, hasSpecialGroup);
|
||||
|
||||
var baseDesc = cameraData.cameraTargetDescriptor;
|
||||
|
||||
// Kept for parity/documentation with the original camera-stack handling; the classic
|
||||
// renderer already shares cameraColorTargetHandle between base and overlay cameras, so no
|
||||
// extra copy-back is required (see the note at the bottom of this method).
|
||||
bool isStackedBase = cameraData.camera.TryGetComponent(out UniversalAdditionalCameraData additionalCameraData)
|
||||
&& additionalCameraData.cameraStack != null && additionalCameraData.cameraStack.Count > 0;
|
||||
|
||||
// ---- Working copy of the pre-effect camera color (blend/compare source) ----
|
||||
var colorCopyDesc = baseDesc;
|
||||
colorCopyDesc.depthBufferBits = 0;
|
||||
colorCopyDesc.msaaSamples = 1;
|
||||
RenderingUtils.ReAllocateIfNeeded(ref cameraColorCopyHandle, colorCopyDesc, name: CAMERA_COLOR_TEXTURE_NAME);
|
||||
Blitter.BlitCameraTexture(cmd, cameraColorTargetHandle, cameraColorCopyHandle);
|
||||
|
||||
RTHandle colorTarget = cameraColorTargetHandle;
|
||||
|
||||
// ---- ObjectID texture ----
|
||||
var objIdDesc = baseDesc;
|
||||
bool forcedRGBA32F = settings.enableIntraObjectFusion.value || settings.debugMode.value == DebugMode.Normals;
|
||||
objIdDesc.graphicsFormat = forcedRGBA32F ? GraphicsFormat.R32G32B32A32_SFloat : objectIdTextureFormat;
|
||||
objIdDesc.depthBufferBits = 0;
|
||||
objIdDesc.msaaSamples = 1;
|
||||
RenderingUtils.ReAllocateIfNeeded(ref objectIDHandle, objIdDesc, name: OBJECT_ID_TEXTURE_NAME);
|
||||
|
||||
Color clearColor = SystemInfo.usesReversedZBuffer ? Color.clear : new Color(0, 1, 0, 0);
|
||||
|
||||
// ---- Special-group marker texture ----
|
||||
bool useCustomGroups = hasSpecialGroup;
|
||||
if (useCustomGroups) {
|
||||
var customDesc = objIdDesc;
|
||||
RenderingUtils.ReAllocateIfNeeded(ref customGroupHandle, customDesc, name: CUSTOM_GROUP_TEXTURE_NAME);
|
||||
}
|
||||
|
||||
// ---- Depth used while filling the ObjectID buffer ----
|
||||
RTHandle depthForObjectID;
|
||||
if (cameraUsesMsaa) {
|
||||
var objIdDepthDesc = baseDesc;
|
||||
objIdDepthDesc.msaaSamples = 1;
|
||||
objIdDepthDesc.graphicsFormat = GraphicsFormat.None;
|
||||
objIdDepthDesc.depthBufferBits = 24;
|
||||
RenderingUtils.ReAllocateIfNeeded(ref objectIDDepthHandle, objIdDepthDesc, name: OBJECT_ID_DEPTH_TEXTURE_NAME);
|
||||
depthForObjectID = objectIDDepthHandle;
|
||||
}
|
||||
else {
|
||||
// No MSAA: reuse camera depth directly (read/testable, matches original ZTest.Equal setup)
|
||||
depthForObjectID = cameraDepthTargetHandle != null ? cameraDepthTargetHandle : objectIDDepthHandle;
|
||||
}
|
||||
|
||||
// =========================== 1) ObjectID pass ===========================
|
||||
// Only clear depth when we own a dedicated depth buffer (MSAA path). In the non-MSAA
|
||||
// path depthForObjectID is the camera's shared depth target, already populated by the
|
||||
// opaque pass and needed as-is for the ZTest.Equal comparison below (and by later passes
|
||||
// that sample _CameraDepthTexture) - clearing it here would corrupt it for the rest of the frame.
|
||||
ClearFlag objectIdClearFlag = cameraUsesMsaa ? ClearFlag.All : ClearFlag.Color;
|
||||
CoreUtils.SetRenderTarget(cmd, objectIDHandle, depthForObjectID, objectIdClearFlag, clearColor);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
|
||||
var drawSettingsObjId = CreateDrawingSettings(shaderTags, ref renderingData, SortingCriteria.CommonOpaque);
|
||||
drawSettingsObjId.overrideMaterial = objectIDMaterial;
|
||||
drawSettingsObjId.overrideMaterialPassIndex = 0;
|
||||
drawSettingsObjId.perObjectData = PerObjectData.None;
|
||||
drawSettingsObjId.enableInstancing = true;
|
||||
|
||||
if (hasSingleSided) {
|
||||
cmd.SetGlobalInt(ShaderParams.Cull, (int)CullMode.Back);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
var filterSingle = new FilteringSettings(RenderQueueRange.opaque, ssMask, rlMaskSingle);
|
||||
context.DrawRenderers(renderingData.cullResults, ref drawSettingsObjId, ref filterSingle);
|
||||
}
|
||||
if (hasDoubleSided) {
|
||||
cmd.SetGlobalInt(ShaderParams.Cull, (int)CullMode.Off);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
var filterDouble = new FilteringSettings(RenderQueueRange.opaque, dsMask, rlMaskDouble);
|
||||
context.DrawRenderers(renderingData.cullResults, ref drawSettingsObjId, ref filterDouble);
|
||||
cmd.SetGlobalInt(ShaderParams.Cull, (int)CullMode.Back);
|
||||
}
|
||||
|
||||
// =========================== 2) Special-group pass ===========================
|
||||
if (useCustomGroups) {
|
||||
CoreUtils.SetRenderTarget(cmd, customGroupHandle, depthForObjectID, ClearFlag.Color, Color.black);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
|
||||
var drawSettingsSpecial = CreateDrawingSettings(shaderTags, ref renderingData, SortingCriteria.CommonOpaque);
|
||||
drawSettingsSpecial.overrideMaterial = null; // use original materials to preserve displacement
|
||||
drawSettingsSpecial.enableInstancing = true;
|
||||
|
||||
var filterCustom = new FilteringSettings(RenderQueueRange.opaque, specialMask, specialGroupCombined);
|
||||
context.DrawRenderers(renderingData.cullResults, ref drawSettingsSpecial, ref filterCustom);
|
||||
}
|
||||
|
||||
// =========================== 3) Fill ObjectID pass ===========================
|
||||
int layerUnion = ssMask | dsMask;
|
||||
bool layersExcluded = layerUnion != cameraCullingMask;
|
||||
bool renderingLayersExcluded = (rlMaskSingle != uint.MaxValue) || (rlMaskDouble != uint.MaxValue) || (rlMaskSpecial != uint.MaxValue);
|
||||
bool needsOthersFill = (layersExcluded || renderingLayersExcluded) && settings.blendWithOthers.value;
|
||||
|
||||
RTHandle objectIDForBlend = objectIDHandle;
|
||||
if (useCustomGroups || needsOthersFill) {
|
||||
fusionFillMaterial.SetFloat(ShaderParams.TerrainObjectId, settings.blendWithOthers.value ? 31f : 0f);
|
||||
|
||||
RenderingUtils.ReAllocateIfNeeded(ref objectIDFilledHandle, objIdDesc, name: OBJECT_ID_FILLED_TEXTURE_NAME);
|
||||
|
||||
cmd.SetGlobalTexture(ShaderParams.ObjectIDTexture, objectIDHandle);
|
||||
if (useCustomGroups) {
|
||||
cmd.SetGlobalTexture(ShaderParams.CustomGroupTexture, customGroupHandle);
|
||||
}
|
||||
CoreUtils.SetRenderTarget(cmd, objectIDFilledHandle, ClearFlag.None, Color.clear);
|
||||
CoreUtils.DrawFullScreen(cmd, fusionFillMaterial, null, ShaderParams.FillPassIndex);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
|
||||
objectIDForBlend = objectIDFilledHandle;
|
||||
}
|
||||
|
||||
// =========================== 4) Blend pass ===========================
|
||||
bool compareActive = settings.compareMode.value && settings.debugMode.value == DebugMode.None;
|
||||
if (compareActive) {
|
||||
RenderingUtils.ReAllocateIfNeeded(ref compareHandle, colorCopyDesc, name: COMPARE_TEXTURE_NAME);
|
||||
}
|
||||
|
||||
cmd.SetGlobalTexture(ShaderParams.SrcColorTexture, cameraColorCopyHandle);
|
||||
cmd.SetGlobalTexture(ShaderParams.ObjectIDTexture, objectIDForBlend);
|
||||
|
||||
RTHandle blendDestination = (compareActive && compareHandle != null) ? compareHandle : colorTarget;
|
||||
CoreUtils.SetRenderTarget(cmd, blendDestination, ClearFlag.None, Color.clear);
|
||||
CoreUtils.DrawFullScreen(cmd, fusionMaterial, null, (int)ShaderParams.Passes.Blend);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
|
||||
// =========================== 5) Compare pass ===========================
|
||||
if (compareActive && compareHandle != null) {
|
||||
float angle = settings.compareSameSide.value ? Mathf.PI * 0.5f : settings.compareLineAngle.value;
|
||||
Vector4 compareParamsValue = new Vector4(Mathf.Cos(angle), Mathf.Sin(angle), settings.compareSameSide.value ? settings.comparePanning.value : -10f, settings.compareLineWidth.value);
|
||||
Color lineColor = settings.compareLineColor.value;
|
||||
Vector4 compareLineColor = new Vector4(lineColor.r, lineColor.g, lineColor.b, lineColor.a);
|
||||
|
||||
cmd.SetGlobalTexture(ShaderParams.SrcColorTexture, cameraColorCopyHandle);
|
||||
cmd.SetGlobalTexture(ShaderParams.CompareTex, compareHandle);
|
||||
cmd.SetGlobalVector(ShaderParams.CompareParams, compareParamsValue);
|
||||
cmd.SetGlobalVector(ShaderParams.CompareLineColor, compareLineColor);
|
||||
|
||||
CoreUtils.SetRenderTarget(cmd, colorTarget, ClearFlag.None, Color.clear);
|
||||
CoreUtils.DrawFullScreen(cmd, fusionMaterial, null, (int)ShaderParams.Passes.Compare);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
}
|
||||
|
||||
// =========================== 6) Debug pass ===========================
|
||||
if (!compareActive && settings.debugMode.value != DebugMode.None) {
|
||||
cmd.SetGlobalTexture(ShaderParams.ObjectIDTexture, objectIDForBlend);
|
||||
CoreUtils.SetRenderTarget(cmd, colorTarget, ClearFlag.None, Color.clear);
|
||||
CoreUtils.DrawFullScreen(cmd, fusionMaterial, null, (int)ShaderParams.Passes.Debug);
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
}
|
||||
|
||||
// NOTE on camera stacking: the Unity 6 / Render Graph version has to reroute
|
||||
// resourceData.cameraColor to a fresh texture and then copy it back into the shared stack
|
||||
// color at the end, because render-graph resources are re-requested every frame. The
|
||||
// classic (2022.3) renderer already gives base and overlay cameras the SAME persistent
|
||||
// cameraColorTargetHandle, and every pass above wrote directly into `colorTarget`
|
||||
// (== cameraColorTargetHandle), so overlay cameras in the stack already see the result -
|
||||
// no extra copy-back blit is needed here. `isStackedBase` is kept above only for
|
||||
// documentation / in case you need to special-case stacked cameras later.
|
||||
_ = isStackedBase;
|
||||
}
|
||||
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
cmd.Clear();
|
||||
CommandBufferPool.Release(cmd);
|
||||
}
|
||||
|
||||
static bool RenderingLayersOverlap (uint maskA, uint maskB) {
|
||||
if (maskA == 0u || maskB == 0u) return false;
|
||||
if (maskA == uint.MaxValue || maskB == uint.MaxValue) return true;
|
||||
return (maskA & maskB) != 0u;
|
||||
}
|
||||
|
||||
static IdExclusionPair[] GetActiveExclusionPairs () {
|
||||
if (cachedExclusionVolume != null && cachedExclusionVolume.isActiveAndEnabled && cachedEdgeFusion != null) {
|
||||
return cachedEdgeFusion.idExclusionPairs;
|
||||
}
|
||||
cachedExclusionVolume = null;
|
||||
cachedEdgeFusion = null;
|
||||
|
||||
// Unity 2022.3: Object.FindObjectsByType does not exist yet - use the classic (obsolete but
|
||||
// functional) FindObjectsOfType instead of the Unity 6 FindObjectsByType overload.
|
||||
var volumes = Object.FindObjectsOfType<Volume>();
|
||||
int volumeCount = volumes.Length;
|
||||
for (int i = 0; i < volumeCount; i++) {
|
||||
var volume = volumes[i];
|
||||
if (volume == null || !volume.isActiveAndEnabled || volume.sharedProfile == null) continue;
|
||||
if (!volume.sharedProfile.TryGet<EdgeFusion>(out var ef)) continue;
|
||||
if (ef.idExclusionPairs != null) {
|
||||
cachedExclusionVolume = volume;
|
||||
cachedEdgeFusion = ef;
|
||||
return cachedEdgeFusion.idExclusionPairs;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public void Cleanup () {
|
||||
CoreUtils.Destroy(objectIDMaterial);
|
||||
CoreUtils.Destroy(fusionMaterial);
|
||||
CoreUtils.Destroy(fusionFillMaterial);
|
||||
objectIDHandle?.Release();
|
||||
objectIDFilledHandle?.Release();
|
||||
objectIDDepthHandle?.Release();
|
||||
customGroupHandle?.Release();
|
||||
compareHandle?.Release();
|
||||
cameraColorCopyHandle?.Release();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user