557 lines
21 KiB
C#
557 lines
21 KiB
C#
|
#if DEBUG
|
|||
|
|
//#define DEBUG_SHOW_MESH_NORMALS
|
|||
|
|
#endif
|
|||
|
|
#define FORCE_CURRENT_CAMERA_DEPTH_TEXTURE_MODE
|
|||
|
|
|
|||
|
|
#if UNITY_2018_1_OR_NEWER
|
|||
|
|
#define VLB_SRP_SUPPORT // Comment this to disable SRP support
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
using UnityEngine;
|
|||
|
|
using System.Collections;
|
|||
|
|
|
|||
|
|
#pragma warning disable 0429, 0162 // Unreachable expression code detected (because of Noise3D.isSupported on mobile)
|
|||
|
|
|
|||
|
|
namespace VLB
|
|||
|
|
{
|
|||
|
|
[AddComponentMenu("")] // hide it from Component search
|
|||
|
|
[ExecuteInEditMode]
|
|||
|
|
[HelpURL(Consts.Help.HD.UrlBeam)]
|
|||
|
|
public class BeamGeometryHD : BeamGeometryAbstractBase
|
|||
|
|
{
|
|||
|
|
VolumetricLightBeamHD m_Master = null;
|
|||
|
|
VolumetricCookieHD m_Cookie = null;
|
|||
|
|
VolumetricShadowHD m_Shadow = null;
|
|||
|
|
|
|||
|
|
protected override VolumetricLightBeamAbstractBase GetMaster() { return m_Master; }
|
|||
|
|
|
|||
|
|
public bool visible
|
|||
|
|
{
|
|||
|
|
set { if (meshRenderer) meshRenderer.enabled = value; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public int sortingLayerID
|
|||
|
|
{
|
|||
|
|
set { if (meshRenderer) meshRenderer.sortingLayerID = value; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public int sortingOrder
|
|||
|
|
{
|
|||
|
|
set { if(meshRenderer) meshRenderer.sortingOrder = value; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if VLB_SRP_SUPPORT
|
|||
|
|
Camera m_CurrentCameraRenderingSRP = null;
|
|||
|
|
|
|||
|
|
void OnDisable()
|
|||
|
|
{
|
|||
|
|
SRPHelper.UnregisterOnBeginCameraRendering(OnBeginCameraRenderingSRP);
|
|||
|
|
m_CurrentCameraRenderingSRP = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static bool isCustomRenderPipelineSupported { get { return true; } }
|
|||
|
|
#else
|
|||
|
|
public static bool isCustomRenderPipelineSupported { get { return false; } }
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
bool shouldUseGPUInstancedMaterial
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
if (Config.Instance.GetActualRenderingMode(ShaderMode.HD) == RenderingMode.GPUInstancing)
|
|||
|
|
{
|
|||
|
|
return m_Cookie == null && m_Shadow == null; // sampler cannot be passed to shader as instanced property
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void OnEnable()
|
|||
|
|
{
|
|||
|
|
#if VLB_SRP_SUPPORT
|
|||
|
|
SRPHelper.RegisterOnBeginCameraRendering(OnBeginCameraRenderingSRP);
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void Initialize(VolumetricLightBeamHD master)
|
|||
|
|
{
|
|||
|
|
Debug.Assert(master != null);
|
|||
|
|
|
|||
|
|
var customHideFlags = Consts.Internal.ProceduralObjectsHideFlags;
|
|||
|
|
m_Master = master;
|
|||
|
|
|
|||
|
|
transform.SetParent(master.transform, false);
|
|||
|
|
|
|||
|
|
meshRenderer = gameObject.GetOrAddComponent<MeshRenderer>();
|
|||
|
|
meshRenderer.hideFlags = customHideFlags;
|
|||
|
|
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
|
|||
|
|
meshRenderer.receiveShadows = false;
|
|||
|
|
meshRenderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off; // different reflection probes could break batching with GPU Instancing
|
|||
|
|
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
|
|||
|
|
|
|||
|
|
m_Cookie = m_Master.GetAdditionalComponentCookie();
|
|||
|
|
m_Shadow = m_Master.GetAdditionalComponentShadow();
|
|||
|
|
|
|||
|
|
if (!shouldUseGPUInstancedMaterial)
|
|||
|
|
{
|
|||
|
|
m_CustomMaterial = Config.Instance.NewMaterialTransient(ShaderMode.HD, gpuInstanced:false);
|
|||
|
|
ApplyMaterial();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_Master.DoesSupportSorting2D())
|
|||
|
|
{
|
|||
|
|
if (SortingLayer.IsValid(m_Master.GetSortingLayerID()))
|
|||
|
|
sortingLayerID = m_Master.GetSortingLayerID();
|
|||
|
|
else
|
|||
|
|
Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.GetSortingLayerID()));
|
|||
|
|
|
|||
|
|
sortingOrder = m_Master.GetSortingOrder();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
meshFilter = gameObject.GetOrAddComponent<MeshFilter>();
|
|||
|
|
meshFilter.hideFlags = customHideFlags;
|
|||
|
|
|
|||
|
|
gameObject.hideFlags = customHideFlags;
|
|||
|
|
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
UnityEditor.GameObjectUtility.SetStaticEditorFlags(gameObject, master.GetStaticEditorFlagsForSubObjects());
|
|||
|
|
gameObject.SetSameSceneVisibilityStatesThan(master.gameObject);
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Generate the cone mesh and calls UpdateMaterialAndBounds.
|
|||
|
|
/// Since this process involves recreating a new mesh, make sure to not call it at every frame during playtime.
|
|||
|
|
/// </summary>
|
|||
|
|
public void RegenerateMesh()
|
|||
|
|
{
|
|||
|
|
Debug.Assert(m_Master);
|
|||
|
|
|
|||
|
|
if (Config.Instance.geometryOverrideLayer)
|
|||
|
|
gameObject.layer = Config.Instance.geometryLayerID;
|
|||
|
|
else
|
|||
|
|
gameObject.layer = m_Master.gameObject.layer;
|
|||
|
|
|
|||
|
|
gameObject.tag = Config.Instance.geometryTag;
|
|||
|
|
|
|||
|
|
coneMesh = GlobalMeshHD.Get();
|
|||
|
|
meshFilter.sharedMesh = coneMesh;
|
|||
|
|
|
|||
|
|
UpdateMaterialAndBounds();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Vector3 ComputeLocalMatrix()
|
|||
|
|
{
|
|||
|
|
// In the VS, we compute the vertices so the whole beam fits into a fixed 2x2x1 box.
|
|||
|
|
// We have to apply some scaling to get the proper beam size.
|
|||
|
|
// This way we have the proper bounds without having to recompute specific bounds foreach beam.
|
|||
|
|
var maxRadius = Mathf.Max(m_Master.coneRadiusStart, m_Master.coneRadiusEnd);
|
|||
|
|
|
|||
|
|
var localScale = new Vector3(maxRadius, maxRadius, m_Master.maxGeometryDistance);
|
|||
|
|
if (!m_Master.scalable)
|
|||
|
|
localScale = localScale.Divide(m_Master.GetLossyScale());
|
|||
|
|
|
|||
|
|
transform.localScale = localScale;
|
|||
|
|
transform.localRotation = m_Master.beamInternalLocalRotation;
|
|||
|
|
|
|||
|
|
return localScale;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool isNoiseEnabled { get { return m_Master.isNoiseEnabled && m_Master.noiseIntensity > 0f && Noise3D.isSupported; } } // test Noise3D.isSupported the last
|
|||
|
|
|
|||
|
|
MaterialManager.StaticPropertiesHD ComputeMaterialStaticProperties()
|
|||
|
|
{
|
|||
|
|
var colorGradient = MaterialManager.ColorGradient.Off;
|
|||
|
|
if (m_Master.colorMode == ColorMode.Gradient)
|
|||
|
|
{
|
|||
|
|
var precision = Utils.GetFloatPackingPrecision();
|
|||
|
|
colorGradient = precision == Utils.FloatPackingPrecision.High ? MaterialManager.ColorGradient.MatrixHigh : MaterialManager.ColorGradient.MatrixLow;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Debug.Assert((int)BlendingMode.Additive == (int)MaterialManager.BlendingMode.Additive);
|
|||
|
|
Debug.Assert((int)BlendingMode.SoftAdditive == (int)MaterialManager.BlendingMode.SoftAdditive);
|
|||
|
|
Debug.Assert((int)BlendingMode.TraditionalTransparency == (int)MaterialManager.BlendingMode.TraditionalTransparency);
|
|||
|
|
|
|||
|
|
return new MaterialManager.StaticPropertiesHD
|
|||
|
|
{
|
|||
|
|
blendingMode = (MaterialManager.BlendingMode)m_Master.blendingMode,
|
|||
|
|
attenuation = m_Master.attenuationEquation == AttenuationEquationHD.Linear ? MaterialManager.HD.Attenuation.Linear : MaterialManager.HD.Attenuation.Quadratic,
|
|||
|
|
noise3D = isNoiseEnabled ? MaterialManager.Noise3D.On : MaterialManager.Noise3D.Off,
|
|||
|
|
colorGradient = colorGradient,
|
|||
|
|
shadow = m_Shadow != null ? MaterialManager.HD.Shadow.On : MaterialManager.HD.Shadow.Off,
|
|||
|
|
cookie = (m_Cookie != null ? (m_Cookie.channel == CookieChannel.RGBA ? MaterialManager.HD.Cookie.RGBA : MaterialManager.HD.Cookie.SingleChannel) : MaterialManager.HD.Cookie.Off),
|
|||
|
|
raymarchingQualityIndex = m_Master.raymarchingQualityIndex
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool ApplyMaterial()
|
|||
|
|
{
|
|||
|
|
var staticProps = ComputeMaterialStaticProperties();
|
|||
|
|
|
|||
|
|
Material mat = null;
|
|||
|
|
if (!shouldUseGPUInstancedMaterial)
|
|||
|
|
{
|
|||
|
|
mat = m_CustomMaterial;
|
|||
|
|
if(mat)
|
|||
|
|
staticProps.ApplyToMaterial(mat);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
mat = MaterialManager.GetInstancedMaterial(m_Master._INTERNAL_InstancedMaterialGroupID, ref staticProps);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
meshRenderer.material = mat;
|
|||
|
|
return mat != null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if DEBUG
|
|||
|
|
bool m_CanChangePropertyBlock = false;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
public void SetMaterialProp(int nameID, float value)
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial)
|
|||
|
|
m_CustomMaterial.SetFloat(nameID, value);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
#if DEBUG
|
|||
|
|
Debug.Assert(m_CanChangePropertyBlock == true);
|
|||
|
|
#endif
|
|||
|
|
MaterialManager.materialPropertyBlock.SetFloat(nameID, value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetMaterialProp(int nameID, Vector4 value)
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial)
|
|||
|
|
m_CustomMaterial.SetVector(nameID, value);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
#if DEBUG
|
|||
|
|
Debug.Assert(m_CanChangePropertyBlock == true);
|
|||
|
|
#endif
|
|||
|
|
MaterialManager.materialPropertyBlock.SetVector(nameID, value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetMaterialProp(int nameID, Color value)
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial)
|
|||
|
|
m_CustomMaterial.SetColor(nameID, value);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
#if DEBUG
|
|||
|
|
Debug.Assert(m_CanChangePropertyBlock == true);
|
|||
|
|
#endif
|
|||
|
|
MaterialManager.materialPropertyBlock.SetColor(nameID, value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetMaterialProp(int nameID, Matrix4x4 value)
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial)
|
|||
|
|
m_CustomMaterial.SetMatrix(nameID, value);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
#if DEBUG
|
|||
|
|
Debug.Assert(m_CanChangePropertyBlock == true);
|
|||
|
|
#endif
|
|||
|
|
MaterialManager.materialPropertyBlock.SetMatrix(nameID, value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetMaterialProp(int nameID, Texture value)
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial)
|
|||
|
|
m_CustomMaterial.SetTexture(nameID, value);
|
|||
|
|
#if DEBUG
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Debug.Assert(m_CanChangePropertyBlock == true);
|
|||
|
|
Debug.LogErrorFormat(m_Master, "Setting a Texture property to a GPU instanced material is not supported: '{0}'", m_Master);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public enum InvalidTexture
|
|||
|
|
{
|
|||
|
|
Null,
|
|||
|
|
NoDepth
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetMaterialProp(int nameID, InvalidTexture invalidTexture)
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial)
|
|||
|
|
{
|
|||
|
|
Texture tex = null;
|
|||
|
|
if (invalidTexture == InvalidTexture.NoDepth)
|
|||
|
|
tex = SystemInfo.usesReversedZBuffer? Texture2D.blackTexture: Texture2D.whiteTexture;
|
|||
|
|
|
|||
|
|
m_CustomMaterial.SetTexture(nameID, tex);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void MaterialChangeStart()
|
|||
|
|
{
|
|||
|
|
if (m_CustomMaterial == null)
|
|||
|
|
meshRenderer.GetPropertyBlock(MaterialManager.materialPropertyBlock);
|
|||
|
|
#if DEBUG
|
|||
|
|
m_CanChangePropertyBlock = true;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void MaterialChangeStop()
|
|||
|
|
{
|
|||
|
|
#if DEBUG
|
|||
|
|
m_CanChangePropertyBlock = false;
|
|||
|
|
#endif
|
|||
|
|
if (m_CustomMaterial == null)
|
|||
|
|
meshRenderer.SetPropertyBlock(MaterialManager.materialPropertyBlock);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
////////////////////////
|
|||
|
|
/// DIRTY PROPERTIES
|
|||
|
|
////////////////////////
|
|||
|
|
DirtyProps m_DirtyProps = DirtyProps.None;
|
|||
|
|
|
|||
|
|
public void SetPropertyDirty(DirtyProps prop)
|
|||
|
|
{
|
|||
|
|
m_DirtyProps |= prop;
|
|||
|
|
|
|||
|
|
if(prop.HasAtLeastOneFlag(DirtyProps.OnlyMaterialChangeOnly))
|
|||
|
|
{
|
|||
|
|
UpdateMaterialAndBounds(); // need to change material variant
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void UpdateMaterialAndBounds()
|
|||
|
|
{
|
|||
|
|
Debug.Assert(m_Master);
|
|||
|
|
|
|||
|
|
if (ApplyMaterial() == false)
|
|||
|
|
{
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
MaterialChangeStart();
|
|||
|
|
{
|
|||
|
|
m_DirtyProps = DirtyProps.All; // make sure all props will be updated on next camera render
|
|||
|
|
|
|||
|
|
if (isNoiseEnabled)
|
|||
|
|
{
|
|||
|
|
Noise3D.LoadIfNeeded();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// make sure the bounds are good from the startup
|
|||
|
|
ComputeLocalMatrix(); // compute matrix before sending it to the shader
|
|||
|
|
|
|||
|
|
#if VLB_SRP_SUPPORT
|
|||
|
|
// This update is to make QA test 'ReflectionObliqueProjection' pass
|
|||
|
|
UpdateMatricesPropertiesForGPUInstancingSRP();
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
MaterialChangeStop();
|
|||
|
|
|
|||
|
|
#if DEBUG_SHOW_MESH_NORMALS
|
|||
|
|
for (int vertexInd = 0; vertexInd < coneMesh.vertexCount; vertexInd++)
|
|||
|
|
{
|
|||
|
|
var vertex = coneMesh.vertices[vertexInd];
|
|||
|
|
|
|||
|
|
// apply modification done inside VS
|
|||
|
|
vertex.x *= Mathf.Lerp(coneRadius.x, coneRadius.y, vertex.z);
|
|||
|
|
vertex.y *= Mathf.Lerp(coneRadius.x, coneRadius.y, vertex.z);
|
|||
|
|
vertex.z *= m_Master.fallOffEnd;
|
|||
|
|
|
|||
|
|
var cosSinFlat = new Vector2(vertex.x, vertex.y).normalized;
|
|||
|
|
var normal = new Vector3(cosSinFlat.x * Mathf.Cos(slopeRad), cosSinFlat.y * Mathf.Cos(slopeRad), -Mathf.Sin(slopeRad)).normalized;
|
|||
|
|
|
|||
|
|
vertex = transform.TransformPoint(vertex);
|
|||
|
|
normal = transform.TransformDirection(normal);
|
|||
|
|
Debug.DrawRay(vertex, normal * 0.25f);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if VLB_SRP_SUPPORT
|
|||
|
|
void UpdateMatricesPropertiesForGPUInstancingSRP()
|
|||
|
|
{
|
|||
|
|
if (SRPHelper.IsUsingCustomRenderPipeline() && Config.Instance.GetActualRenderingMode(ShaderMode.HD) == RenderingMode.GPUInstancing)
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.LocalToWorldMatrix, transform.localToWorldMatrix);
|
|||
|
|
SetMaterialProp(ShaderProperties.WorldToLocalMatrix, transform.worldToLocalMatrix);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if UNITY_2019_1_OR_NEWER
|
|||
|
|
void OnBeginCameraRenderingSRP(UnityEngine.Rendering.ScriptableRenderContext context, Camera cam)
|
|||
|
|
#else
|
|||
|
|
void OnBeginCameraRenderingSRP(Camera cam)
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
m_CurrentCameraRenderingSRP = cam;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
void OnWillRenderObject()
|
|||
|
|
{
|
|||
|
|
Camera currentCam = null;
|
|||
|
|
|
|||
|
|
#if VLB_SRP_SUPPORT
|
|||
|
|
if (SRPHelper.IsUsingCustomRenderPipeline())
|
|||
|
|
{
|
|||
|
|
currentCam = m_CurrentCameraRenderingSRP;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
currentCam = Camera.current;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
OnWillCameraRenderThisBeam(currentCam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void OnWillCameraRenderThisBeam(Camera cam)
|
|||
|
|
{
|
|||
|
|
if (m_Master && cam)
|
|||
|
|
{
|
|||
|
|
if (
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
Utils.IsEditorCamera(cam) || // make sure to call UpdateCameraRelatedProperties for editor scene camera
|
|||
|
|
#endif
|
|||
|
|
cam.enabled) // prevent from doing stuff when we render from a previous DynamicOcclusionDepthBuffer's DepthCamera, because the DepthCamera are disabled
|
|||
|
|
{
|
|||
|
|
Debug.Assert(cam.GetComponentInParent<VolumetricLightBeamHD>() == null);
|
|||
|
|
UpdateMaterialPropertiesForCamera(cam);
|
|||
|
|
|
|||
|
|
if (m_Shadow)
|
|||
|
|
m_Shadow.OnWillCameraRenderThisBeam(cam, this);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void UpdateDirtyMaterialProperties()
|
|||
|
|
{
|
|||
|
|
if (m_DirtyProps != DirtyProps.None)
|
|||
|
|
{
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.Intensity))
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.HD.Intensity, m_Master.intensity);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.HDRPExposureWeight) && Config.Instance.isHDRPExposureWeightSupported)
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.HDRPExposureWeight, m_Master.hdrpExposureWeight);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.SideSoftness))
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.HD.SideSoftness, m_Master.sideSoftness);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.Color))
|
|||
|
|
{
|
|||
|
|
if (m_Master.colorMode == ColorMode.Flat)
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.ColorFlat, m_Master.colorFlat);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
var precision = Utils.GetFloatPackingPrecision();
|
|||
|
|
m_ColorGradientMatrix = m_Master.colorGradient.SampleInMatrix((int)precision);
|
|||
|
|
// pass the gradient matrix in OnWillRenderObject()
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.Cone))
|
|||
|
|
{
|
|||
|
|
// kMinRadius and kMinApexOffset prevents artifacts when fresnel computation is done in the vertex shader
|
|||
|
|
const float kMinRadius = 0.0001f;
|
|||
|
|
var coneRadius = new Vector2(Mathf.Max(m_Master.coneRadiusStart, kMinRadius), Mathf.Max(m_Master.coneRadiusEnd, kMinRadius));
|
|||
|
|
SetMaterialProp(ShaderProperties.ConeRadius, coneRadius);
|
|||
|
|
|
|||
|
|
const float kMinApexOffset = 0.0001f;
|
|||
|
|
float apexOffsetZ = m_Master.GetConeApexOffsetZ(false);
|
|||
|
|
float nonNullApex = Mathf.Sign(apexOffsetZ) * Mathf.Max(Mathf.Abs(apexOffsetZ), kMinApexOffset);
|
|||
|
|
SetMaterialProp(ShaderProperties.ConeGeomProps, new Vector2(nonNullApex, Config.Instance.sharedMeshSides));
|
|||
|
|
|
|||
|
|
SetMaterialProp(ShaderProperties.DistanceFallOff, new Vector3(m_Master.fallOffStart, m_Master.fallOffEnd, m_Master.maxGeometryDistance));
|
|||
|
|
|
|||
|
|
ComputeLocalMatrix(); // compute matrix before sending it to the shader
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.Jittering))
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.HD.Jittering, new Vector4(m_Master.jitteringFactor, m_Master.jitteringFrameRate, m_Master.jitteringLerpRange.minValue, m_Master.jitteringLerpRange.maxValue));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (isNoiseEnabled)
|
|||
|
|
{
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.NoiseMode) || m_DirtyProps.HasFlag(DirtyProps.NoiseIntensity))
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.NoiseParam, new Vector2(
|
|||
|
|
m_Master.noiseIntensity,
|
|||
|
|
m_Master.noiseMode == NoiseMode.WorldSpace ? 0f : 1f));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.NoiseVelocityAndScale))
|
|||
|
|
{
|
|||
|
|
var noiseVelocity = m_Master.noiseVelocityUseGlobal ? Config.Instance.globalNoiseVelocity : m_Master.noiseVelocityLocal;
|
|||
|
|
var noiseScale = m_Master.noiseScaleUseGlobal ? Config.Instance.globalNoiseScale : m_Master.noiseScaleLocal;
|
|||
|
|
|
|||
|
|
SetMaterialProp(ShaderProperties.NoiseVelocityAndScale, new Vector4(
|
|||
|
|
noiseVelocity.x,
|
|||
|
|
noiseVelocity.y,
|
|||
|
|
noiseVelocity.z,
|
|||
|
|
noiseScale));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.CookieProps))
|
|||
|
|
VolumetricCookieHD.ApplyMaterialProperties(m_Cookie, this);
|
|||
|
|
|
|||
|
|
if (m_DirtyProps.HasFlag(DirtyProps.ShadowProps))
|
|||
|
|
VolumetricShadowHD.ApplyMaterialProperties(m_Shadow, this);
|
|||
|
|
|
|||
|
|
m_DirtyProps = DirtyProps.None;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void UpdateMaterialPropertiesForCamera(Camera cam)
|
|||
|
|
{
|
|||
|
|
if (cam && m_Master)
|
|||
|
|
{
|
|||
|
|
MaterialChangeStart();
|
|||
|
|
{
|
|||
|
|
SetMaterialProp(ShaderProperties.HD.TransformScale, m_Master.scalable ? m_Master.GetLossyScale() : Vector3.one);
|
|||
|
|
|
|||
|
|
var camForwardVectorOSN = transform.InverseTransformDirection(cam.transform.forward).normalized;
|
|||
|
|
SetMaterialProp(ShaderProperties.HD.CameraForwardOS, camForwardVectorOSN);
|
|||
|
|
SetMaterialProp(ShaderProperties.HD.CameraForwardWS, cam.transform.forward);
|
|||
|
|
|
|||
|
|
UpdateDirtyMaterialProperties();
|
|||
|
|
|
|||
|
|
if (m_Master.colorMode == ColorMode.Gradient)
|
|||
|
|
{
|
|||
|
|
// Send the gradient matrix every frame since it's not a shader's property
|
|||
|
|
SetMaterialProp(ShaderProperties.ColorGradientMatrix, m_ColorGradientMatrix);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if VLB_SRP_SUPPORT
|
|||
|
|
// This update is to be able to move beams without trackChangesDuringPlaytime enabled with SRP & GPU Instancing
|
|||
|
|
UpdateMatricesPropertiesForGPUInstancingSRP();
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
MaterialChangeStop();
|
|||
|
|
|
|||
|
|
#if FORCE_CURRENT_CAMERA_DEPTH_TEXTURE_MODE
|
|||
|
|
cam.depthTextureMode |= DepthTextureMode.Depth;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
public int _EDITOR_InstancedMaterialID { get { return ComputeMaterialStaticProperties().GetMaterialID(); } }
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|