Mindgames/Library/PackageCache/com.unity.render-pipelines.high-definition@6.9.0-preview/Runtime/Material/Decal/DecalProjectorComponent.cs

   1 using System;
   2 using UnityEditor;
   3 using UnityEngine;
   4 using UnityEngine.Rendering;
   5
   6 namespace UnityEngine.Experimental.Rendering.HDPipeline
   7 {
   8     [ExecuteAlways]
   9 #if UNITY_EDITOR
  10     [CanEditMultipleObjects]
  11 #endif
  12     public partial class DecalProjectorComponent : MonoBehaviour
  13     {
  14         internal static readonly Quaternion k_MinusYtoZRotation = Quaternion.Euler(-90, 0, 0);
  15
  16         [SerializeField]
  17         private Material m_Material = null;
  18         public Material material
  19         {
  20             get
  21             {
  22                 return m_Material;
  23             }
  24             set
  25             {
  26                 m_Material = value;
  27                 OnValidate();
  28             }
  29         }
  30
  31         [SerializeField]
  32         private float m_DrawDistance = 1000.0f;
  33         public float drawDistance
  34         {
  35             get
  36             {
  37                 return m_DrawDistance;
  38             }
  39             set
  40             {
  41                 m_DrawDistance = Mathf.Max(0f, value);
  42                 OnValidate();
  43             }
  44         }
  45
  46         [SerializeField]
  47         [Range(0,1)]
  48         private float m_FadeScale = 0.9f;
  49         public float fadeScale
  50         {
  51             get
  52             {
  53                 return m_FadeScale;
  54             }
  55             set
  56             {
  57                 m_FadeScale = Mathf.Clamp01(value);
  58                 OnValidate();
  59             }
  60         }
  61
  62         [SerializeField]
  63         private Vector2 m_UVScale = new Vector2(1, 1);
  64         public Vector2 uvScale
  65         {
  66             get
  67             {
  68                 return m_UVScale;
  69             }
  70             set
  71             {
  72                 m_UVScale = value;
  73                 OnValidate();
  74             }
  75         }
  76
  77         [SerializeField]
  78         private Vector2 m_UVBias = new Vector2(0, 0);
  79         public Vector2 uvBias
  80         {
  81             get
  82             {
  83                 return m_UVBias;
  84             }
  85             set
  86             {
  87                 m_UVBias = value;
  88                 OnValidate();
  89             }
  90         }
  91
  92         [SerializeField]
  93         private bool m_AffectsTransparency = false;
  94         public bool affectsTransparency
  95         {
  96             get
  97             {
  98                 return m_AffectsTransparency;
  99             }
 100             set
 101             {
 102                 m_AffectsTransparency = value;
 103                 OnValidate();
 104             }
 105         }
 106
 107         [SerializeField]
 108         private Vector3 m_Offset = new Vector3(0, -0.5f, 0);
 109         public Vector3 offset
 110         {
 111             get
 112             {
 113                 return m_Offset;
 114             }
 115             set
 116             {
 117                 m_Offset = value;
 118                 OnValidate();
 119             }
 120         }
 121
 122         [SerializeField]
 123         Vector3 m_Size = new Vector3(1, 1, 1);
 124         public Vector3 size
 125         {
 126             get
 127             {
 128                 return m_Size;
 129             }
 130             set
 131             {
 132                 m_Size = value;
 133                 OnValidate();
 134             }
 135         }
 136
 137         [SerializeField]
 138         [Range(0, 1)]
 139         private float m_FadeFactor = 1.0f;
 140         public float fadeFactor
 141         {
 142             get
 143             {
 144                 return m_FadeFactor;
 145             }
 146             set
 147             {
 148                 m_FadeFactor = Mathf.Clamp01(value);
 149                 OnValidate();
 150             }
 151         }
 152
 153         private Material m_OldMaterial = null;
 154         private DecalSystem.DecalHandle m_Handle = null;
 155
 156
 157         /// <summary>current rotation in a way the DecalSystem will be able to use it</summary>
 158         internal Quaternion rotation => transform.rotation * k_MinusYtoZRotation;
 159         /// <summary>current position in a way the DecalSystem will be able to use it</summary>
 160         internal Vector3 position => transform.position;
 161         /// <summary>current size in a way the DecalSystem will be able to use it</summary>
 162         internal Vector3 decalSize => new Vector3(m_Size.x, m_Size.z, m_Size.y);
 163         /// <summary>current size in a way the DecalSystem will be able to use it</summary>
 164         internal Vector3 decalOffset => new Vector3(m_Offset.x, -m_Offset.z, m_Offset.y);
 165         /// <summary>current uv parameters in a way the DecalSystem will be able to use it</summary>
 166         internal Vector4 uvScaleBias => new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
 167
 168         public DecalSystem.DecalHandle Handle
 169         {
 170             get
 171             {
 172                 return this.m_Handle;
 173             }
 174             set
 175             {
 176                 this.m_Handle = value;
 177             }
 178         }
 179
 180         public void OnEnable()
 181         {
 182             if (m_Material == null)
 183             {
 184 #if UNITY_EDITOR
 185                 var hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
 186                 m_Material = hdrp != null ? hdrp.GetDefaultDecalMaterial() : null;
 187 #else
 188                 m_Material = null;
 189 #endif
 190             }
 191
 192             if (m_Handle != null)
 193             {
 194                 DecalSystem.instance.RemoveDecal(m_Handle);
 195                 m_Handle = null;
 196             }
 197
 198             Matrix4x4 sizeOffset = Matrix4x4.Translate(decalOffset) * Matrix4x4.Scale(decalSize);
 199             m_Handle = DecalSystem.instance.AddDecal(position, rotation, Vector3.one, sizeOffset, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Material, gameObject.layer, m_FadeFactor);
 200         }
 201
 202         public void OnDisable()
 203         {
 204             if (m_Handle != null)
 205             {
 206                 DecalSystem.instance.RemoveDecal(m_Handle);
 207                 m_Handle = null;
 208             }
 209         }
 210
 211         // Declare the method signature of the delegate to call.
 212         public delegate void OnMaterialChangeDelegate();
 213
 214         // Declare the event to which editor code will hook itself.
 215         public event OnMaterialChangeDelegate OnMaterialChange;
 216
 217         public void OnValidate()
 218         {
 219             if (m_Handle != null) // don't do anything if OnEnable hasn't been called yet when scene is loading.
 220             {
 221                 Matrix4x4 sizeOffset = Matrix4x4.Translate(decalOffset) * Matrix4x4.Scale(decalSize);
 222                 // handle material changes, because decals are stored as sets sorted by material, if material changes decal needs to be removed and re-added to that it goes into correct set
 223                 if (m_OldMaterial != m_Material)
 224                 {
 225                     DecalSystem.instance.RemoveDecal(m_Handle);
 226                     m_Handle = DecalSystem.instance.AddDecal(position, rotation, Vector3.one, sizeOffset, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Material, gameObject.layer, m_FadeFactor);
 227                     m_OldMaterial = m_Material;
 228
 229                     if (!DecalSystem.IsHDRenderPipelineDecal(m_Material.shader.name)) // non HDRP/decal shaders such as shader graph decal do not affect transparency
 230                     {
 231                         m_AffectsTransparency = false;
 232                     }
 233
 234                     // notify the editor that material has changed so it can update the shader foldout
 235                     if (OnMaterialChange != null)
 236                     {
 237                         OnMaterialChange();
 238                     }
 239                 }
 240                 else // no material change, just update whatever else changed
 241                 {
 242                     DecalSystem.instance.UpdateCachedData(position, rotation, sizeOffset, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle, gameObject.layer, m_FadeFactor);
 243                 }
 244             }
 245         }
 246
 247         public void LateUpdate()
 248         {
 249             if (m_Handle != null)
 250             {
 251                 if (transform.hasChanged == true)
 252                 {
 253                     Matrix4x4 sizeOffset = Matrix4x4.Translate(decalOffset) * Matrix4x4.Scale(decalSize);
 254                     DecalSystem.instance.UpdateCachedData(position, rotation, sizeOffset, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle, gameObject.layer, m_FadeFactor);
 255                     transform.hasChanged = false;
 256                 }
 257             }
 258         }
 259
 260         public bool IsValid()
 261         {
 262             // don't draw if no material or if material is the default decal material (empty)
 263             if (m_Material == null)
 264                 return false;
 265
 266 #if UNITY_EDITOR
 267             var hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
 268             if ((hdrp != null) && (m_Material == hdrp.GetDefaultDecalMaterial()))
 269                 return false;
 270 #endif
 271
 272             return true;
 273         }
 274     }
 275 }