Added Dohya

Assets/Plugins/VolumetricLightBeam/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 8a7200d4febf3cd4f9371a4dccc14775
+folderAsset: yes
+timeCreated: 1504689318
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/ConfigEditor.cs

@@ -0,0 +1,361 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(Config))]
+    public class ConfigEditor : EditorCommon
+    {
+        SerializedProperty geometryOverrideLayer = null, geometryLayerID = null, geometryTag = null, geometryRenderQueue = null, renderPipeline = null, renderingMode = null;
+        SerializedProperty sharedMeshSides = null, sharedMeshSegments = null;
+        SerializedProperty globalNoiseScale = null, globalNoiseVelocity = null;
+        SerializedProperty fadeOutCameraTag = null;
+        SerializedProperty noiseTexture3D = null;
+        SerializedProperty dustParticlesPrefab = null;
+        SerializedProperty ditheringFactor = null, ditheringNoiseTexture = null;
+        SerializedProperty featureEnabledColorGradient = null, featureEnabledDepthBlend = null, featureEnabledNoise3D = null, featureEnabledDynamicOcclusion = null, featureEnabledMeshSkewing = null, featureEnabledShaderAccuracyHigh = null;
+        bool isRenderQueueCustom = false;
+        Config m_TargetConfig = null;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            RenderQueueGUIInit();
+
+            Noise3D.LoadIfNeeded(); // Try to load Noise3D, maybe for the 1st time
+
+            m_TargetConfig = this.target as Config;
+        }
+
+        void RenderQueueGUIInit()
+        {
+            isRenderQueueCustom = true;
+            foreach (RenderQueue rq in System.Enum.GetValues(typeof(RenderQueue)))
+            {
+                if (rq != RenderQueue.Custom && geometryRenderQueue.intValue == (int)rq)
+                {
+                    isRenderQueueCustom = false;
+                    break;
+                }
+            }
+        }
+
+        void RenderQueueGUIDraw()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUI.BeginChangeCheck();
+                {
+                    EditorGUI.BeginChangeCheck();
+                    RenderQueue rq = isRenderQueueCustom ? RenderQueue.Custom : (RenderQueue)geometryRenderQueue.intValue;
+                    rq = (RenderQueue)EditorGUILayout.EnumPopup(EditorStrings.Config.GeometryRenderQueue, rq);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        isRenderQueueCustom = (rq == RenderQueue.Custom);
+
+                        if (!isRenderQueueCustom)
+                            geometryRenderQueue.intValue = (int)rq;
+                    }
+
+                    EditorGUI.BeginDisabledGroup(!isRenderQueueCustom);
+                    {
+                        geometryRenderQueue.intValue = EditorGUILayout.IntField(geometryRenderQueue.intValue, GUILayout.MaxWidth(65.0f));
+                    }
+                    EditorGUI.EndDisabledGroup();
+                }
+                if (EditorGUI.EndChangeCheck())
+                {
+                    SetDirty(DirtyFlags.AllBeamGeom);
+                }
+            }
+        }
+
+        protected override void OnHeaderGUI()
+        {
+            GUILayout.BeginVertical("In BigTitle");
+            EditorGUILayout.Separator();
+
+            var title = string.Format("Volumetric Light Beam - Plugin Configuration");
+            EditorGUILayout.LabelField(title, EditorStyles.boldLabel);
+            EditorGUILayout.LabelField(string.Format("Current Version: {0}", Version.Current), EditorStyles.miniBoldLabel);
+            EditorGUILayout.Separator();
+            GUILayout.EndVertical();
+        }
+
+        void OnAddConfigPerPlatform(object platform)
+        {
+            var p = (RuntimePlatform)platform;
+            var clone = Object.Instantiate(m_TargetConfig);
+            Debug.Assert(clone);
+            var path = AssetDatabase.GetAssetPath(m_TargetConfig).Replace(m_TargetConfig.name + ".asset", "");
+            ConfigOverride.CreateAsset(clone, path + ConfigOverride.kAssetName + p.ToString() + ".asset");
+            Selection.activeObject = clone;
+        }
+
+        [System.Flags]
+        enum DirtyFlags
+        {
+            Target = 1 << 1,
+            Shader = 1 << 2,
+            Noise = 1 << 3,
+            GlobalMesh = 1 << 4,
+            AllBeamGeom = 1 << 5,
+            AllMeshes = 1 << 6
+        }
+
+        void SetDirty(DirtyFlags flags)
+        {
+            if (m_IsUsedInstance)
+            {
+                if (flags.HasFlag(DirtyFlags.Target)) EditorUtility.SetDirty(target);
+                if (flags.HasFlag(DirtyFlags.Shader)) m_NeedToRefreshShader = true;
+                if (flags.HasFlag(DirtyFlags.Noise)) m_NeedToReloadNoise = true;
+                if (flags.HasFlag(DirtyFlags.GlobalMesh)) GlobalMesh.Destroy();
+                if (flags.HasFlag(DirtyFlags.AllBeamGeom)) VolumetricLightBeam._EditorSetAllBeamGeomDirty();
+                if (flags.HasFlag(DirtyFlags.AllMeshes)) VolumetricLightBeam._EditorSetAllMeshesDirty();
+            }
+        }
+
+        bool m_NeedToReloadNoise = false;
+        bool m_NeedToRefreshShader = false;
+        bool m_IsUsedInstance = false;
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            Debug.Assert(m_TargetConfig != null);
+
+            m_NeedToReloadNoise = false;
+            m_NeedToRefreshShader = false;
+            m_IsUsedInstance = m_TargetConfig.IsCurrentlyUsedInstance();
+
+            // Config per plaftorm
+#if UNITY_2018_1_OR_NEWER
+            {
+                bool hasValidName = m_TargetConfig.HasValidAssetName();
+                bool isCurrentPlatformSuffix = m_TargetConfig.GetAssetSuffix() == PlatformHelper.GetCurrentPlatformSuffix();
+
+                var platformSuffix = m_TargetConfig.GetAssetSuffix();
+                string platformStr = "Default Config asset";
+                if(!string.IsNullOrEmpty(platformSuffix))
+                    platformStr = string.Format("Config asset for platform '{0}'", m_TargetConfig.GetAssetSuffix());
+                if (!hasValidName)
+                    platformStr += " (INVALID)";
+                EditorGUILayout.LabelField(platformStr, EditorStyles.boldLabel);
+
+                if (GUILayout.Button(EditorStrings.Beam.ButtonCreateOverridePerPlatform, EditorStyles.miniButton))
+                {
+                    var menu = new GenericMenu();
+                    foreach (var platform in System.Enum.GetValues(typeof(RuntimePlatform)))
+                        menu.AddItem(new GUIContent(platform.ToString()), false, OnAddConfigPerPlatform, platform);
+                    menu.ShowAsContext();
+                }
+
+                if (!hasValidName)
+                {
+                    EditorGUILayout.Separator();
+                    EditorGUILayout.HelpBox(EditorStrings.Config.InvalidPlatformOverride, MessageType.Error);
+                    ButtonOpenConfig();
+                }
+                else if (!m_IsUsedInstance)
+                {
+                    EditorGUILayout.Separator();
+
+                    if (isCurrentPlatformSuffix)
+                        EditorGUILayout.HelpBox(EditorStrings.Config.WrongAssetLocation, MessageType.Error);
+                    else
+                        EditorGUILayout.HelpBox(EditorStrings.Config.NotCurrentAssetInUse, MessageType.Warning);
+
+                    ButtonOpenConfig();
+                }
+
+                DrawLineSeparator();
+            }
+#endif
+
+            {
+                EditorGUI.BeginChangeCheck();
+                {
+                    if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderBeamGeometry))
+                    {
+                        using (new EditorGUILayout.HorizontalScope())
+                        {
+                            geometryOverrideLayer.boolValue = EditorGUILayout.Toggle(EditorStrings.Config.GeometryOverrideLayer, geometryOverrideLayer.boolValue);
+                            using (new EditorGUI.DisabledGroupScope(!geometryOverrideLayer.boolValue))
+                            {
+                                geometryLayerID.intValue = EditorGUILayout.LayerField(geometryLayerID.intValue);
+                            }
+                        }
+
+                        geometryTag.stringValue = EditorGUILayout.TagField(EditorStrings.Config.GeometryTag, geometryTag.stringValue);
+                    }
+                    FoldableHeader.End();
+
+                    if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderRendering))
+                    {
+                        RenderQueueGUIDraw();
+
+                        if (BeamGeometry.isCustomRenderPipelineSupported)
+                        {
+                            EditorGUI.BeginChangeCheck();
+                            {
+                                renderPipeline.CustomEnum<RenderPipeline>(EditorStrings.Config.GeometryRenderPipeline, EditorStrings.Config.GeometryRenderPipelineEnumDescriptions);
+                            }
+                            if (EditorGUI.EndChangeCheck())
+                            {
+                                SetDirty(DirtyFlags.AllBeamGeom | DirtyFlags.Shader); // need to fully reset the BeamGeom to update the shader
+                            }
+                        }
+
+                        if (m_TargetConfig.hasRenderPipelineMismatch)
+                            EditorGUILayout.HelpBox(EditorStrings.Config.ErrorRenderPipelineMismatch, MessageType.Error);
+
+                        EditorGUI.BeginChangeCheck();
+                        {
+                            EditorGUILayout.PropertyField(renderingMode, EditorStrings.Config.GeometryRenderingMode);
+
+                            if (renderPipeline.enumValueIndex == (int)RenderPipeline.BuiltIn)
+                            {
+                                if (renderingMode.enumValueIndex == (int)RenderingMode.SRPBatcher)
+                                    EditorGUILayout.HelpBox(EditorStrings.Config.ErrorSrpBatcherOnlyCompatibleWithSrp, MessageType.Error);
+                            }
+                            else
+                            {
+                                if (renderingMode.enumValueIndex == (int)RenderingMode.SRPBatcher && SRPHelper.renderPipelineType == SRPHelper.RenderPipeline.LWRP)
+                                    EditorGUILayout.HelpBox(EditorStrings.Config.ErrorSrpBatcherNotCompatibleWithLWRP, MessageType.Error);
+
+                                if (renderingMode.enumValueIndex == (int)RenderingMode.MultiPass)
+                                    EditorGUILayout.HelpBox(EditorStrings.Config.ErrorSrpAndMultiPassNotCompatible, MessageType.Error);
+                            }
+
+#pragma warning disable 0162 // warning CS0162: Unreachable code detected
+                            if (renderingMode.enumValueIndex == (int)RenderingMode.GPUInstancing && !BatchingHelper.isGpuInstancingSupported)
+                                EditorGUILayout.HelpBox(EditorStrings.Config.ErrorGeometryGpuInstancingNotSupported, MessageType.Error);
+#pragma warning restore 0162
+                        }
+                        if (EditorGUI.EndChangeCheck())
+                        {
+                            SetDirty(DirtyFlags.AllBeamGeom | DirtyFlags.GlobalMesh | DirtyFlags.Shader); // need to fully reset the BeamGeom to update the shader
+                        }
+
+                        if (m_TargetConfig.beamShader == null)
+                            EditorGUILayout.HelpBox(EditorStrings.Config.GetErrorInvalidShader(), MessageType.Error);
+
+                        if (ditheringFactor.FloatSlider(EditorStrings.Config.DitheringFactor, 0.0f, 1.0f))
+                        {
+                            SetDirty(DirtyFlags.Shader);
+                        }
+                    }
+                    FoldableHeader.End();
+                }
+                if (EditorGUI.EndChangeCheck())
+                {
+                    VolumetricLightBeam._EditorSetAllMeshesDirty();
+                }
+
+                if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderSharedMesh))
+                {
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.PropertyField(sharedMeshSides, EditorStrings.Config.SharedMeshSides);
+                    EditorGUILayout.PropertyField(sharedMeshSegments, EditorStrings.Config.SharedMeshSegments);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        SetDirty(DirtyFlags.GlobalMesh | DirtyFlags.AllMeshes);
+                    }
+
+                    var meshInfo = "These properties will change the mesh tessellation of each Volumetric Light Beam with 'Shared' MeshType.\nAdjust them carefully since they could impact performance.";
+                    meshInfo += string.Format("\nShared Mesh stats: {0} vertices, {1} triangles", MeshGenerator.GetSharedMeshVertexCount(), MeshGenerator.GetSharedMeshIndicesCount() / 3);
+                    EditorGUILayout.HelpBox(meshInfo, MessageType.Info);
+                }
+                FoldableHeader.End();
+
+                if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderGlobal3DNoise))
+                {
+                    EditorGUILayout.PropertyField(globalNoiseScale, EditorStrings.Config.GlobalNoiseScale);
+                    EditorGUILayout.PropertyField(globalNoiseVelocity, EditorStrings.Config.GlobalNoiseVelocity);
+                }
+                FoldableHeader.End();
+
+                if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderFadeOutCamera))
+                {
+                    EditorGUI.BeginChangeCheck();
+                    fadeOutCameraTag.stringValue = EditorGUILayout.TagField(EditorStrings.Config.FadeOutCameraTag, fadeOutCameraTag.stringValue);
+                    if (EditorGUI.EndChangeCheck() && Application.isPlaying)
+                        m_TargetConfig.ForceUpdateFadeOutCamera();
+                }
+                FoldableHeader.End();
+
+                if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderFeaturesEnabled))
+                {
+                    EditorGUI.BeginChangeCheck();
+                    {
+                        EditorGUILayout.PropertyField(featureEnabledColorGradient, EditorStrings.Config.FeatureEnabledColorGradient);
+                        EditorGUILayout.PropertyField(featureEnabledDepthBlend, EditorStrings.Config.FeatureEnabledDepthBlend);
+                        EditorGUILayout.PropertyField(featureEnabledNoise3D, EditorStrings.Config.FeatureEnabledNoise3D);
+                        EditorGUILayout.PropertyField(featureEnabledDynamicOcclusion, EditorStrings.Config.FeatureEnabledDynamicOcclusion);
+                        EditorGUILayout.PropertyField(featureEnabledMeshSkewing, EditorStrings.Config.FeatureEnabledMeshSkewing);
+                        EditorGUILayout.PropertyField(featureEnabledShaderAccuracyHigh, EditorStrings.Config.FeatureEnabledShaderAccuracyHigh);
+                    }
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        SetDirty(DirtyFlags.Shader | DirtyFlags.AllBeamGeom);
+                    }
+                }
+                FoldableHeader.End();
+
+                if (FoldableHeader.Begin(this, EditorStrings.Config.HeaderInternalData))
+                {
+                    EditorGUILayout.PropertyField(dustParticlesPrefab, EditorStrings.Config.DustParticlesPrefab);
+
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.PropertyField(ditheringNoiseTexture, EditorStrings.Config.DitheringNoiseTexture);
+                    if (EditorGUI.EndChangeCheck())
+                        SetDirty(DirtyFlags.Shader);
+
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.PropertyField(noiseTexture3D, EditorStrings.Config.NoiseTexture3D);
+                    if (EditorGUI.EndChangeCheck())
+                        SetDirty(DirtyFlags.Noise);
+
+                    if (Noise3D.isSupported && !Noise3D.isProperlyLoaded)
+                        EditorGUILayout.HelpBox(EditorStrings.Common.HelpNoiseLoadingFailed, MessageType.Error);
+                }
+                FoldableHeader.End();
+
+                if (GUILayout.Button(EditorStrings.Config.OpenDocumentation, EditorStyles.miniButton))
+                {
+                    UnityEditor.Help.BrowseURL(Consts.Help.UrlConfig);
+                }
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    if (GUILayout.Button(EditorStrings.Config.ResetToDefaultButton, EditorStyles.miniButton))
+                    {
+                        UnityEditor.Undo.RecordObject(target, "Reset Config Properties");
+                        m_TargetConfig.Reset();
+                        SetDirty(DirtyFlags.Target | DirtyFlags.Noise);
+                    }
+
+                    if (GUILayout.Button(EditorStrings.Config.ResetInternalDataButton, EditorStyles.miniButton))
+                    {
+                        UnityEditor.Undo.RecordObject(target, "Reset Internal Data");
+                        m_TargetConfig.ResetInternalData();
+                        SetDirty(DirtyFlags.Target | DirtyFlags.Noise);
+                    }
+                }
+            }
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (m_NeedToRefreshShader)
+                m_TargetConfig.RefreshShader(Config.RefreshShaderFlags.All); // need to be done AFTER ApplyModifiedProperties
+
+            if (m_NeedToReloadNoise)
+                Noise3D._EditorForceReloadData(); // Should be called AFTER ApplyModifiedProperties so the Config instance has the proper values when reloading data
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/ConfigEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 11b7e89a4cae94542bcb6c9be7c2ee9b
+timeCreated: 1508778801
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/ConfigOverrideEditor.cs

@@ -0,0 +1,12 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(ConfigOverride))]
+    public class ConfigOverrideEditor : ConfigEditor // useless override, only useful for backward compatibility
+    {
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/ConfigOverrideEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 990b9a5f1d3a1cd41aa984f4b23a3d1a
+timeCreated: 1556445850
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/DynamicOcclusionAbstractBaseEditor.cs

@@ -0,0 +1,51 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    public class DynamicOcclusionAbstractBaseEditor<T> : EditorCommon where T : DynamicOcclusionAbstractBase
+    {
+        SerializedProperty updateRate = null;
+        SerializedProperty waitXFrames = null;
+        protected TargetList<T> m_Targets;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_Targets = new TargetList<T>(targets);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            if (!Config.Instance.featureEnabledDynamicOcclusion)
+            {
+                EditorGUILayout.HelpBox(EditorStrings.DynOcclusion.HelpFeatureDisabled, MessageType.Warning);
+            }
+        }
+
+        protected void DisplayCommonInspector()
+        {
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderUpdateRate))
+            {
+                updateRate.CustomEnum<DynamicOcclusionUpdateRate>(EditorStrings.DynOcclusion.UpdateRate, EditorStrings.DynOcclusion.UpdateRateDescriptions);
+
+                if (m_Targets.HasAtLeastOneTargetWith((T comp) => { return comp.updateRate.HasFlag(DynamicOcclusionUpdateRate.EveryXFrames); }))
+                {
+                    EditorGUILayout.PropertyField(waitXFrames, EditorStrings.DynOcclusion.WaitXFrames);
+                }
+
+                EditorGUILayout.HelpBox(
+                    string.Format(EditorStrings.DynOcclusion.GetUpdateRateAdvice<T>(m_Targets[0].updateRate), m_Targets[0].waitXFrames),
+                    MessageType.Info);
+            }
+
+            FoldableHeader.End();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/DynamicOcclusionAbstractBaseEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0192ed587a87bfb41b9ec2ac3f6098e2
+timeCreated: 1580771203
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/DynamicOcclusionDepthBufferEditor.cs

@@ -0,0 +1,55 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(DynamicOcclusionDepthBuffer))]
+    [CanEditMultipleObjects]
+    public class DynamicOcclusionDepthBufferEditor : DynamicOcclusionAbstractBaseEditor<DynamicOcclusionDepthBuffer>
+    {
+        SerializedProperty depthMapResolution = null;
+        SerializedProperty layerMask = null;
+        SerializedProperty useOcclusionCulling = null;
+        SerializedProperty fadeDistanceToSurface = null;
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            if (m_Targets.HasAtLeastOneTargetWith((DynamicOcclusionDepthBuffer comp) => { return comp.GetComponent<VolumetricLightBeam>().dimensions == Dimensions.Dim2D; }))
+            {
+                EditorGUILayout.HelpBox(EditorStrings.DynOcclusion.HelpDepthBufferAndBeam2D, MessageType.Warning);
+            }
+
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderCamera))
+            {
+                EditorGUILayout.PropertyField(layerMask, EditorStrings.DynOcclusion.LayerMask);
+
+                if(Config.Instance.geometryOverrideLayer == false)
+                {
+                    EditorGUILayout.HelpBox(EditorStrings.DynOcclusion.HelpOverrideLayer, MessageType.Warning);
+                }
+                else if (m_Targets.HasAtLeastOneTargetWith((DynamicOcclusionDepthBuffer comp) => { return comp.HasLayerMaskIssues(); }))
+                {
+                    EditorGUILayout.HelpBox(EditorStrings.DynOcclusion.HelpLayerMaskIssues, MessageType.Warning);
+                }
+
+                EditorGUILayout.PropertyField(useOcclusionCulling, EditorStrings.DynOcclusion.DepthBufferOcclusionCulling);
+                EditorGUILayout.PropertyField(depthMapResolution, EditorStrings.DynOcclusion.DepthBufferDepthMapResolution);
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderOccluderSurface))
+            {
+                EditorGUILayout.PropertyField(fadeDistanceToSurface, EditorStrings.DynOcclusion.FadeDistanceToSurface);
+            }
+            FoldableHeader.End();
+
+            DisplayCommonInspector();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/DynamicOcclusionDepthBufferEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cd6cc47c61bc28e4fb4568a2e48d1c32
+timeCreated: 1578172705
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/DynamicOcclusionRaycastingEditor.cs

@@ -0,0 +1,111 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(DynamicOcclusionRaycasting))]
+    [CanEditMultipleObjects]
+    public class DynamicOcclusionRaycastingEditor : DynamicOcclusionAbstractBaseEditor<DynamicOcclusionRaycasting>
+    {
+        SerializedProperty dimensions = null;
+        SerializedProperty layerMask = null;
+        SerializedProperty considerTriggers = null;
+        SerializedProperty minOccluderArea = null;
+        SerializedProperty planeAlignment = null;
+        SerializedProperty maxSurfaceDot = null;
+        SerializedProperty planeOffset = null;
+        SerializedProperty fadeDistanceToSurface = null;
+        SerializedProperty minSurfaceRatio = null;
+
+        public override bool RequiresConstantRepaint() { return Application.isPlaying || DynamicOcclusionRaycasting.editorRaycastAtEachFrame; }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            DynamicOcclusionRaycasting.EditorLoadPrefs();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderRaycasting))
+            {
+                dimensions.CustomEnum<Dimensions>(EditorStrings.DynOcclusion.Dimensions, EditorStrings.Common.DimensionsEnumDescriptions);
+                EditorGUILayout.PropertyField(layerMask, EditorStrings.DynOcclusion.LayerMask);
+                EditorGUILayout.PropertyField(considerTriggers, EditorStrings.DynOcclusion.ConsiderTriggers);
+
+                if (Physics2D.queriesHitTriggers == false)
+                {
+                    if(m_Targets.HasAtLeastOneTargetWith((DynamicOcclusionRaycasting instance) => { return instance.dimensions == Dimensions.Dim2D && instance.considerTriggers; }))
+                    {
+                        EditorGUILayout.HelpBox(EditorStrings.DynOcclusion.ConsiderTriggersNoPossible, MessageType.Error);
+                    }
+                }
+
+                EditorGUILayout.PropertyField(minOccluderArea, EditorStrings.DynOcclusion.MinOccluderArea);
+            }
+
+            FoldableHeader.End();
+
+            DisplayCommonInspector();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderOccluderSurface))
+            {
+                minSurfaceRatio.FloatSlider(
+                    EditorStrings.DynOcclusion.MinSurfaceRatio,
+                    Consts.DynOcclusion.RaycastingMinSurfaceRatioMin, Consts.DynOcclusion.RaycastingMinSurfaceRatioMax,
+                    (value) => value * 100f,  // conversion value to slider
+                    (value) => value / 100f   // conversion slider to value
+                    );
+
+                maxSurfaceDot.FloatSlider(
+                    EditorStrings.DynOcclusion.MaxSurfaceDot,
+                    Consts.DynOcclusion.RaycastingMaxSurfaceAngleMin, Consts.DynOcclusion.RaycastingMaxSurfaceAngleMax,
+                    (value) => Mathf.Acos(value) * Mathf.Rad2Deg,   // conversion value to slider
+                    (value) => Mathf.Cos(value * Mathf.Deg2Rad)     // conversion slider to value
+                    );
+            }
+
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderClippingPlane))
+            {
+                EditorGUILayout.PropertyField(planeAlignment, EditorStrings.DynOcclusion.PlaneAlignment);
+                EditorGUILayout.PropertyField(planeOffset, EditorStrings.DynOcclusion.PlaneOffset);
+                EditorGUILayout.PropertyField(fadeDistanceToSurface, EditorStrings.DynOcclusion.FadeDistanceToSurface);
+            }
+
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DynOcclusion.HeaderEditorDebug))
+            {
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GlobalToggleButton(ref DynamicOcclusionRaycasting.editorShowDebugPlane, EditorStrings.DynOcclusion.EditorShowDebugPlane, EditorPrefsStrings.DynOcclusion.PrefShowDebugPlane);
+                    GlobalToggleButton(ref DynamicOcclusionRaycasting.editorRaycastAtEachFrame, EditorStrings.DynOcclusion.EditorRaycastAtEachFrame, EditorPrefsStrings.DynOcclusion.PrefRaycastingEditor);
+                }
+
+                if (Application.isPlaying || DynamicOcclusionRaycasting.editorRaycastAtEachFrame)
+                {
+                    if (!serializedObject.isEditingMultipleObjects)
+                    {
+                        var instance = (target as DynamicOcclusionRaycasting);
+                        Debug.Assert(instance);
+                        var hit = instance.editorCurrentHitResult;
+                        var lastFrameUpdate = instance.editorDebugData.lastFrameUpdate;
+
+                        var occluderInfo = string.Format("Last update {0} frame(s) ago\n", Time.frameCount - lastFrameUpdate);
+                        occluderInfo += (hit.hasCollider) ? string.Format("Current occluder: '{0}'\nEstimated occluder area: {1} units²", hit.name, hit.bounds.GetMaxArea2D()) : "No occluder found";
+                        EditorGUILayout.HelpBox(occluderInfo, MessageType.Info);
+                    }
+                }
+            }
+            FoldableHeader.End();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/DynamicOcclusionRaycastingEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 296c1775a3a72104091469b9f856ae7b
+timeCreated: 1508778801
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EditorCommon.cs

@@ -0,0 +1,156 @@
+#if UNITY_EDITOR
+#if UNITY_2019_1_OR_NEWER
+#define UI_USE_FOLDOUT_HEADER_2019
+#endif
+
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace VLB
+{
+    public class EditorCommon : Editor
+    {
+        protected virtual void OnEnable()
+        {
+            FoldableHeader.OnEnable();
+            RetrieveSerializedProperties("_");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+    #if UNITY_2019_3_OR_NEWER
+            // no vertical space in 2019.3 looks better
+    #else
+            EditorGUILayout.Separator();
+    #endif
+        }
+
+        public static void DrawLineSeparator()
+        {
+            DrawLineSeparator(Color.grey, 1, 10);
+        }
+
+        static void DrawLineSeparator(Color color, int thickness = 2, int padding = 10)
+        {
+            Rect r = EditorGUILayout.GetControlRect(GUILayout.Height(padding + thickness));
+
+            r.x = 0;
+            r.width = EditorGUIUtility.currentViewWidth;
+
+            r.y += padding / 2;
+            r.height = thickness;
+
+            EditorGUI.DrawRect(r, color);
+        }
+
+        protected void ButtonOpenConfig(bool miniButton = true)
+        {
+            bool buttonClicked = false;
+            if (miniButton) buttonClicked = GUILayout.Button(EditorStrings.Common.ButtonOpenGlobalConfig, EditorStyles.miniButton);
+            else            buttonClicked = GUILayout.Button(EditorStrings.Common.ButtonOpenGlobalConfig);
+
+            if (buttonClicked)
+                Config.EditorSelectInstance();
+        }
+
+        protected bool GlobalToggleButton(ref bool boolean, GUIContent content, string saveString, float maxWidth = 999.0f)
+        {
+            EditorGUI.BeginChangeCheck();
+            boolean = GUILayout.Toggle(boolean, content, EditorStyles.miniButton, GUILayout.MaxWidth(maxWidth));
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorPrefs.SetBool(saveString, boolean);
+                SceneView.RepaintAll();
+                return true;
+            }
+            return false;
+        }
+
+        // SERIALIZED PROPERTY RETRIEVAL
+        string GetThisNamespaceAsString() { return GetType().Namespace; }
+
+        SerializedProperty FindProperty(string prefix, string name)
+        {
+            Debug.Assert(serializedObject != null);
+            var prop = serializedObject.FindProperty(name);
+            if (prop == null)
+            {
+                name = string.Format("{0}{1}{2}", prefix, char.ToUpperInvariant(name[0]), name.Substring(1)); // get '_Name' from 'name'
+                prop = serializedObject.FindProperty(name);
+            }
+            return prop;
+        }
+
+        void RetrieveSerializedProperties(string prefix, Type t)
+        {
+            if (t == null) return;
+            if (t.Namespace != GetThisNamespaceAsString()) return;
+
+            var allEditorFields = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
+            foreach (var field in allEditorFields)
+            {
+                if (field.FieldType == typeof(SerializedProperty))
+                {
+                    var runtimeFieldName = field.Name;
+                    var serializedProp = FindProperty(prefix, runtimeFieldName);
+                    Debug.AssertFormat(serializedProp != null, "Fail to find serialized field '{0}' in object {1}", runtimeFieldName, serializedObject.targetObject);
+                    field.SetValue(this, serializedProp);
+                }
+            }
+
+            RetrieveSerializedProperties(prefix, t.BaseType);
+        }
+
+        protected void RetrieveSerializedProperties(string prefix)
+        {
+            RetrieveSerializedProperties(prefix, GetType());
+        }
+
+        public abstract class EditorGUIWidth : System.IDisposable
+        {
+            protected abstract void ApplyWidth(float width);
+            public EditorGUIWidth(float width) { ApplyWidth(width); }
+            public void Dispose() { ApplyWidth(0.0f); }
+        }
+
+        public class LabelWidth : EditorGUIWidth
+        {
+            public LabelWidth(float width) : base(width) { }
+            protected override void ApplyWidth(float width) { EditorGUIUtility.labelWidth = width; }
+        }
+
+        public class FieldWidth : EditorGUIWidth
+        {
+            public FieldWidth(float width) : base(width) { }
+            protected override void ApplyWidth(float width) { EditorGUIUtility.fieldWidth = width; }
+        }
+
+        private static ArcHandle ms_HandleRadius = null;
+
+        // HANDLES
+        protected static ArcHandle handleRadius
+        {
+            get
+            {
+                if (ms_HandleRadius == null)
+                {
+                    ms_HandleRadius = new ArcHandle();
+                    ms_HandleRadius.SetColorWithRadiusHandle(Color.white, 0f);
+                    ms_HandleRadius.angle = 360f;
+                    ms_HandleRadius.angleHandleSizeFunction = null;
+                    ms_HandleRadius.angleHandleColor = Color.clear;
+                }
+                return ms_HandleRadius;
+            }
+        }
+    }
+}
+#endif // UNITY_EDITOR
+

Assets/Plugins/VolumetricLightBeam/Editor/EditorCommon.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 11a6b248e0eebc44bb9ba203d8a8d77a
+timeCreated: 1508779655
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EditorData.cs

@@ -0,0 +1,36 @@
+#if UNITY_EDITOR
+using UnityEngine;
+
+namespace VLB
+{
+    public class EditorData : ScriptableObject
+    {
+        [SerializeField] Texture2D buttonAddDustParticles = null;
+        [SerializeField] Texture2D buttonAddDynamicOcclusion = null;
+        [SerializeField] Texture2D buttonAddTriggerZone = null;
+        [SerializeField] Texture2D buttonAddEffect = null;
+        [SerializeField] Texture2D buttonFromSpotLight = null;
+
+        public GUIContent contentAddDustParticles       { get { return new GUIContent(Instance.buttonAddDustParticles, EditorStrings.Beam.ButtonAddDustParticles); } } 
+        public GUIContent contentAddDynamicOcclusion    { get { return new GUIContent(Instance.buttonAddDynamicOcclusion, EditorStrings.Beam.ButtonAddDynamicOcclusion); } } 
+        public GUIContent contentAddTriggerZone         { get { return new GUIContent(Instance.buttonAddTriggerZone, EditorStrings.Beam.ButtonAddTriggerZone); } } 
+        public GUIContent contentAddEffect              { get { return new GUIContent(Instance.buttonAddEffect, EditorStrings.Beam.ButtonAddEffect); } } 
+        public GUIContent contentFromSpotLight          { get { return new GUIContent(Instance.buttonFromSpotLight, EditorStrings.Beam.FromSpotLight); } }
+
+        static EditorData ms_Instance = null;
+        public static EditorData Instance
+        {
+            get
+            {
+                if (ms_Instance == null)
+                {
+                    ms_Instance = Resources.Load<EditorData>("VLBEditorData");
+                    Debug.Assert(ms_Instance != null, "Failed to find asset 'VLBEditorData', please reinstall the 'Volumetric Light Beam' plugin.");
+                }
+                return ms_Instance;
+            }
+        }
+    }
+}
+#endif
+

Assets/Plugins/VolumetricLightBeam/Editor/EditorData.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f87284b87b8be7c4b9708f25ddb6669b
+timeCreated: 1617782038
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EditorExtensions.cs

@@ -0,0 +1,297 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    public static class EditorExtensions
+    {
+        public static GameObject NewBeam()
+        {
+            return new GameObject("Volumetric Light Beam", typeof(VolumetricLightBeam));
+        }
+
+        public static GameObject NewBeam2D()
+        {
+            var gao = new GameObject("Volumetric Light Beam (2D)", typeof(VolumetricLightBeam));
+            gao.GetComponent<VolumetricLightBeam>().dimensions = Dimensions.Dim2D;
+            return gao;
+        }
+
+        public static GameObject NewBeamAndDust()
+        {
+            return new GameObject("Volumetric Light Beam + Dust", typeof(VolumetricLightBeam), typeof(VolumetricDustParticles));
+        }
+
+        public static GameObject NewSpotLightAndBeam()
+        {
+            var light = Utils.NewWithComponent<Light>("Spotlight and Beam");
+            light.type = LightType.Spot;
+            var gao = light.gameObject;
+            gao.AddComponent<VolumetricLightBeam>();
+            return gao;
+        }
+
+        static void OnNewGameObjectCreated(GameObject gao)
+        {
+            if (Selection.activeGameObject)
+                gao.transform.SetParent(Selection.activeGameObject.transform);
+
+            Selection.activeGameObject = gao;
+        }
+
+        [MenuItem("GameObject/Light/Volumetric Beam (3D)", false, 100)]
+        static void Menu_CreateNewBeam()
+        {
+            OnNewGameObjectCreated(NewBeam());
+        }
+
+        [MenuItem("GameObject/Light/Volumetric Beam (3D) and Spotlight", false, 101)]
+        static void Menu_CreateSpotLightAndBeam()
+        {
+            OnNewGameObjectCreated(NewSpotLightAndBeam());
+        }
+
+        [MenuItem("GameObject/Light/Volumetric Beam (2D)", false, 102)]
+        static void Menu_CreateNewBeam2D()
+        {
+            OnNewGameObjectCreated(NewBeam2D());
+        }
+
+        const string kAddVolumetricBeam = "CONTEXT/Light/Attach a Volumetric Beam";
+        static bool CanAddVolumetricBeam(Light light) { return !Application.isPlaying && light != null && light.type == LightType.Spot && light.GetComponent<VolumetricLightBeam>() == null; }
+
+        [MenuItem(kAddVolumetricBeam, false)]
+        static void Menu_AttachBeam_Command(MenuCommand menuCommand)
+        {
+            var light = menuCommand.context as Light;
+            if (CanAddVolumetricBeam(light))
+                Undo.AddComponent<VolumetricLightBeam>(light.gameObject);
+        }
+
+        [MenuItem(kAddVolumetricBeam, true)]
+        static bool Menu_AttachBeam_Validate() { return CanAddVolumetricBeam(GetActiveLight()); }
+
+
+        [MenuItem("CONTEXT/" + VolumetricLightBeam.ClassName + "/Documentation")]
+        static void Menu_Beam_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlBeam); }
+
+        [MenuItem("CONTEXT/" + VolumetricDustParticles.ClassName + "/Documentation")]
+        static void Menu_DustParticles_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlDustParticles); }
+
+        [MenuItem("CONTEXT/" + DynamicOcclusionRaycasting.ClassName + "/Documentation")]
+        static void Menu_DynamicOcclusionRaycasting_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlDynamicOcclusionRaycasting); }
+
+        [MenuItem("CONTEXT/" + DynamicOcclusionDepthBuffer.ClassName + "/Documentation")]
+        static void Menu_DynamicOcclusionDepthBuffer_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlDynamicOcclusionDepthBuffer); }
+
+        [MenuItem("CONTEXT/" + TriggerZone.ClassName + "/Documentation")]
+        static void Menu_TriggerZone_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlTriggerZone); }
+
+        [MenuItem("CONTEXT/" + EffectFlicker.ClassName + "/Documentation")]
+        static void Menu_EffectFlicker_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlEffectFlicker); }
+
+        [MenuItem("CONTEXT/" + EffectPulse.ClassName + "/Documentation")]
+        static void Menu_EffectPulse_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlEffectPulse); }
+
+        [MenuItem("CONTEXT/" + Config.ClassName + "/Documentation")]
+        static void Menu_Config_Doc(MenuCommand menuCommand) { Application.OpenURL(Consts.Help.UrlConfig); }
+
+        [MenuItem("CONTEXT/" + VolumetricLightBeam.ClassName + "/Open Global Config")]
+        [MenuItem("CONTEXT/" + VolumetricDustParticles.ClassName + "/Open Global Config")]
+        [MenuItem("CONTEXT/" + DynamicOcclusionAbstractBase.ClassName + "/Open Global Config")]
+        [MenuItem("CONTEXT/" + TriggerZone.ClassName + "/Open Global Config")]
+        [MenuItem("CONTEXT/" + EffectAbstractBase.ClassName + "/Open Global Config")]
+        public static void Menu_Beam_Config(MenuCommand menuCommand) { Config.EditorSelectInstance(); }
+
+        const string kAddParticles = "CONTEXT/" + VolumetricLightBeam.ClassName + "/Add Dust Particles";
+        [MenuItem(kAddParticles, false)]                    static void Menu_AddDustParticles_Command(MenuCommand menuCommand) { AddComponentFromEditor<VolumetricDustParticles>(menuCommand.context as VolumetricLightBeam); }
+        [MenuItem(kAddParticles, true)]                     static bool Menu_AddDustParticles_Validate() { return CanAddComponentFromEditor<VolumetricDustParticles>(GetActiveVolumetricLightBeam()); }
+
+        const string kAddDynamicOcclusionRaycasting = "CONTEXT/" + VolumetricLightBeam.ClassName + "/Add Dynamic Occlusion (Raycasting)";
+        [MenuItem(kAddDynamicOcclusionRaycasting, false)]   static void Menu_AddDynamicOcclusionRaycasting_Command(MenuCommand menuCommand) { AddComponentFromEditor<DynamicOcclusionRaycasting>(menuCommand.context as VolumetricLightBeam); }
+        [MenuItem(kAddDynamicOcclusionRaycasting, true)]    static bool Menu_AddDynamicOcclusionRaycasting_Validate() { return Config.Instance.featureEnabledDynamicOcclusion && CanAddComponentFromEditor<DynamicOcclusionAbstractBase>(GetActiveVolumetricLightBeam()); }
+
+        const string kAddDynamicOcclusionDepthBuffer = "CONTEXT/" + VolumetricLightBeam.ClassName + "/Add Dynamic Occlusion (Depth Buffer)";
+        [MenuItem(kAddDynamicOcclusionDepthBuffer, false)]  static void Menu_AddDynamicOcclusionDepthBuffer_Command(MenuCommand menuCommand) { AddComponentFromEditor<DynamicOcclusionDepthBuffer>(menuCommand.context as VolumetricLightBeam); }
+        [MenuItem(kAddDynamicOcclusionDepthBuffer, true)]   static bool Menu_AddDynamicOcclusionDepthBuffer_Validate() { return Config.Instance.featureEnabledDynamicOcclusion && CanAddComponentFromEditor<DynamicOcclusionAbstractBase>(GetActiveVolumetricLightBeam()); }
+
+        const string kAddTriggerZone = "CONTEXT/" + VolumetricLightBeam.ClassName + "/Add Trigger Zone";
+        [MenuItem(kAddTriggerZone, false)]                  static void Menu_AddTriggerZone_Command(MenuCommand menuCommand) { AddComponentFromEditor<TriggerZone>(menuCommand.context as VolumetricLightBeam); }
+        [MenuItem(kAddTriggerZone, true)]                   static bool Menu_AddTriggerZone_Validate() { return CanAddComponentFromEditor<TriggerZone>(GetActiveVolumetricLightBeam()); }
+
+        const string kAddEffectFlicker = "CONTEXT/" + VolumetricLightBeam.ClassName + "/Add Effect Flicker";
+        [MenuItem(kAddEffectFlicker, false)]                static void Menu_EffectFlicker_Command(MenuCommand menuCommand) { AddComponentFromEditor<EffectFlicker>(menuCommand.context as VolumetricLightBeam); }
+        [MenuItem(kAddEffectFlicker, true)]                 static bool Menu_EffectFlicker_Validate() { return CanAddComponentFromEditor<EffectAbstractBase>(GetActiveVolumetricLightBeam()); }
+
+        const string kAddEffectPulse = "CONTEXT/" + VolumetricLightBeam.ClassName + "/Add Effect Pulse";
+        [MenuItem(kAddEffectPulse, false)]                  static void Menu_EffectPulse_Command(MenuCommand menuCommand) { AddComponentFromEditor<EffectPulse>(menuCommand.context as VolumetricLightBeam); }
+        [MenuItem(kAddEffectPulse, true)]                   static bool Menu_EffectPulse_Validate() { return CanAddComponentFromEditor<EffectAbstractBase>(GetActiveVolumetricLightBeam()); }
+
+        static Light GetActiveLight()                               { return Selection.activeGameObject != null ? Selection.activeGameObject.GetComponent<Light>() : null; }
+        static VolumetricLightBeam GetActiveVolumetricLightBeam()   { return Selection.activeGameObject != null ? Selection.activeGameObject.GetComponent<VolumetricLightBeam>() : null; }
+
+        static bool CanAddComponentFromEditor<TComp>(VolumetricLightBeam self) where TComp : Component
+        {
+            return !Application.isPlaying && self != null && self.GetComponent<TComp>() == null;
+        }
+
+        public static void AddComponentFromEditor<TComp>(VolumetricLightBeam self) where TComp : Component
+        {
+            if (CanAddComponentFromEditor<TComp>(self))
+            {
+                /*var comp =*/ Undo.AddComponent<TComp>(self.gameObject);
+            }
+        }
+
+        [MenuItem("Edit/Volumetric Light Beam Config", false, 20001)]
+        static void Menu_EditOpenConfig()
+        {
+            Config.EditorSelectInstance();
+        }
+
+        /// <summary>
+        /// Add a EditorGUILayout.ToggleLeft which properly handles multi-object editing
+        /// </summary>
+        public static void ToggleLeft(this SerializedProperty prop, GUIContent label, params GUILayoutOption[] options)
+        {
+            ToggleLeft(prop, label, prop.boolValue, options);
+        }
+
+        public static void ToggleLeft(this SerializedProperty prop, GUIContent label, bool forcedValue, params GUILayoutOption[] options)
+        {
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+            var newValue = EditorGUILayout.ToggleLeft(label, forcedValue, options);
+            EditorGUI.showMixedValue = false;
+            if (EditorGUI.EndChangeCheck())
+                prop.boolValue = newValue;
+        }
+
+
+        public static bool HasAtLeastOneValue(this SerializedProperty prop, bool value)
+        {
+            return (prop.boolValue == value) || prop.hasMultipleDifferentValues;
+        }
+
+        /// <summary>
+        /// Create a EditorGUILayout.Slider which properly handles multi-object editing
+        /// We apply the 'convIn' conversion to the SerializedProperty value before exposing it as a Slider.
+        /// We apply the 'convOut' conversion to the Slider value to get the SerializedProperty back.
+        /// </summary>
+        /// <param name="prop">The value the slider shows.</param>
+        /// <param name="label">Label in front of the slider.</param>
+        /// <param name="leftValue">The value at the left end of the slider.</param>
+        /// <param name="rightValue">The value at the right end of the slider.</param>
+        /// <param name="convIn">Conversion applied on the SerializedProperty to get the Slider value</param>
+        /// <param name="convOut">Conversion applied on the Slider value to get the SerializedProperty</param>
+        public static bool FloatSlider(
+            this SerializedProperty prop,
+            GUIContent label,
+            float leftValue, float rightValue,
+            System.Func<float, float> convIn,
+            System.Func<float, float> convOut,
+            params GUILayoutOption[] options)
+        {
+            var floatValue = convIn(prop.floatValue);
+            EditorGUI.BeginChangeCheck();
+            {
+                EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+                {
+                    floatValue = EditorGUILayout.Slider(label, floatValue, leftValue, rightValue, options);
+                }
+                EditorGUI.showMixedValue = false;
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                prop.floatValue = convOut(floatValue);
+                return true;
+            }
+            return false;
+        }
+
+        public static bool FloatSlider(
+            this SerializedProperty prop,
+            GUIContent label,
+            float leftValue, float rightValue,
+            params GUILayoutOption[] options)
+        {
+            var floatValue = prop.floatValue;
+            EditorGUI.BeginChangeCheck();
+            {
+                EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+                {
+                    floatValue = EditorGUILayout.Slider(label, floatValue, leftValue, rightValue, options);
+                }
+                EditorGUI.showMixedValue = false;
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                prop.floatValue = floatValue;
+                return true;
+            }
+            return false;
+        }
+/*
+        public static void ToggleFromLight(this SerializedProperty prop)
+        {
+            ToggleLeft(
+                prop,
+                new GUIContent("From Spot", "Get the value from the Light Spot"),
+                GUILayout.MaxWidth(80.0f));
+        }
+*/
+        public static void ToggleUseGlobalNoise(this SerializedProperty prop)
+        {
+            ToggleLeft(
+                prop,
+                new GUIContent("Global", "Get the value from the Global 3D Noise"),
+                GUILayout.MaxWidth(55.0f));
+        }
+
+        public static void CustomEnum<EnumType>(this SerializedProperty prop, GUIContent content, string[] descriptions = null)
+        {
+            if(descriptions == null)
+                descriptions = System.Enum.GetNames(typeof(EnumType));
+
+            Debug.Assert(System.Enum.GetNames(typeof(EnumType)).Length == descriptions.Length, string.Format("Enum '{0}' and the description array don't have the same size", typeof(EnumType)));
+
+            int enumValueIndex = prop.enumValueIndex;
+            EditorGUI.BeginChangeCheck();
+            {
+                EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+                {
+#if UNITY_2018_1_OR_NEWER
+                    enumValueIndex = EditorGUILayout.Popup(content, enumValueIndex, descriptions);
+#else
+                    enumValueIndex = EditorGUILayout.Popup(content.text, enumValueIndex, descriptions);
+#endif
+                }
+                EditorGUI.showMixedValue = false;
+            }
+            if (EditorGUI.EndChangeCheck())
+                prop.enumValueIndex = enumValueIndex;
+        }
+
+        public static void CustomMask<EnumType>(this SerializedProperty prop, GUIContent content, string[] descriptions = null)
+        {
+            if (descriptions == null)
+                descriptions = System.Enum.GetNames(typeof(EnumType));
+
+            Debug.Assert(System.Enum.GetNames(typeof(EnumType)).Length == descriptions.Length, string.Format("Enum '{0}' and the description array don't have the same size", typeof(EnumType)));
+
+            int intValue = prop.intValue;
+            EditorGUI.BeginChangeCheck();
+            {
+                EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+                {
+                    intValue = EditorGUILayout.MaskField(content, intValue, descriptions);
+                }
+                EditorGUI.showMixedValue = false;
+            }
+            if (EditorGUI.EndChangeCheck())
+                prop.intValue = intValue;
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/EditorExtensions.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 554d3ed087749984585096b2d627574b
+timeCreated: 1504871769
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EditorStrings.cs

@@ -0,0 +1,333 @@
+#if UNITY_EDITOR
+using UnityEngine;
+
+namespace VLB
+{
+    public static class EditorStrings
+    {
+        public static class Common
+        {
+            public static readonly GUIContent ButtonOpenGlobalConfig = new GUIContent("Open Config asset in use");
+            public const string HelpNoiseLoadingFailed = "Fail to load 3D noise texture. Please check your Config.";
+
+            public static readonly string[] DimensionsEnumDescriptions = new string[]
+            {
+                "3D",
+                "2D",
+            };
+        }
+
+        public static class Beam
+        {
+            public static readonly GUIContent HeaderBasic = new GUIContent("Basic", "Basic beam's properties (color, angle, thickness...)");
+            public static readonly GUIContent HeaderAttenuation = new GUIContent("Fall-Off Attenuation", "Control the beam's range distance and the light fall-off behaviour");
+            public static readonly GUIContent Header3DNoise = new GUIContent("3D Noise", "Simulate animated volumetric fog / mist / smoke effects.\nIt makes the volumetric lights look less 'perfect' and so much more realistic.\nTo achieve that, a tiled 3D noise texture is internally loaded and used by the beam shader.");
+            public static readonly GUIContent HeaderBlendingDistances = new GUIContent("Soft Intersections Blending Distances", "Because the volumetric beams are rendered using cone geometry, it is possible that it intersects with the camera's near plane or with the world's geometry, which could produce unwanted artifacts.\nThese properties are designed to fix this issue.");
+            public static readonly GUIContent HeaderGeometry = new GUIContent("Cone Geometry", "Control how the beam's geometry is generated.");
+            public static readonly GUIContent HeaderFadeOut = new GUIContent("Fade Out");
+            public static readonly GUIContent Header2D = new GUIContent("2D", "Tweak and combine the order when beams are rendered with 2D objects (such as 2D sprites)");
+            public static readonly GUIContent HeaderInfos = new GUIContent("Infos");
+
+            public const string FromSpotLight = "Get the value from the Light Spot";
+
+            public static readonly GUIContent SideThickness = new GUIContent(
+                "Side Thickness",
+                "Thickness of the beam when looking at it from the side.\n1 = the beam is fully visible (no difference between the center and the edges), but produces hard edges.\nLower values produce softer transition at beam edges.");
+
+            public static readonly GUIContent ColorMode = new GUIContent("Color", "Apply a flat/plain/single color, or a gradient.");
+            public static readonly GUIContent ColorGradient = new GUIContent("", "Use the gradient editor to set color and alpha variations along the beam.");
+            public static readonly GUIContent ColorFlat = new GUIContent("", "Use the color picker to set a plain RGBA color (takes account of the alpha value).");
+
+            public static readonly GUIContent IntensityModeAdvanced = new GUIContent("Adv", "Advanced Mode: control inside and outside intensity values independently.");
+            public static readonly GUIContent IntensityGlobal = new GUIContent("Intensity", "Global beam intensity. If you want to control values for inside and outside independently, use the advanced mode.");
+            public static readonly GUIContent IntensityOutside = new GUIContent("Intensity (outside)", "Beam outside intensity (when looking at the beam from behind).");
+            public static readonly GUIContent IntensityInside = new GUIContent("Intensity (inside)", "Beam inside intensity (when looking at the beam from the inside directly at the source).");
+
+            public static readonly GUIContent BlendingMode = new GUIContent("Blending Mode", "Additive: highly recommended blending mode\nSoftAdditive: softer additive\nTraditional Transparency: support dark/black colors");
+            public static readonly GUIContent ShaderAccuracy = new GUIContent("Shader Accuracy", "- Fast: a lot of computation are done on the vertex shader to maximize performance.\n- High: most of the computation are done on the pixel shader to maximize graphical quality at some performance cost.\n\nWe recommend to keep the default 'Fast' shader accuracy to ensure best performance, except when using the 'Tilt Factor' feature or when using a very rich 'Gradient Color'.");
+
+            public static readonly GUIContent SpotAngle = new GUIContent("Spot Angle", "Define the angle (in degrees) at the base of the beam's cone");
+
+            public static readonly GUIContent GlareFrontal = new GUIContent("Glare (frontal)", "Boost intensity factor when looking at the beam from the inside directly at the source.");
+            public static readonly GUIContent GlareBehind = new GUIContent("Glare (from behind)", "Boost intensity factor when looking at the beam from behind.");
+
+            public static readonly GUIContent TrackChanges = new GUIContent(
+                " Track changes during Playtime",
+                "Check this box to be able to modify properties during Playtime via Script, Animator and/or Timeline.\nEnabling this feature is at very minor performance cost. So keep it disabled if you don't plan to modify this light beam during playtime.");
+
+            public static readonly GUIContent AttenuationEquation = new GUIContent("Equation", "Attenuation equation used to compute fading between 'Fade Start Distance' and 'Range Distance'.\n- Linear: Simple linear attenuation\n- Quadratic: Quadratic attenuation, which usually gives more realistic results\n- Blend: Custom blending mix between linear (0.0) and quadratic attenuation (1.0)");
+            public static readonly GUIContent AttenuationCustomBlending = new GUIContent("", "Blending value between Linear (0.0) and Quadratic (1.0) attenuation equations.");
+
+            public static readonly GUIContent FallOffStart = new GUIContent("Start Distance", "Distance from the light source (in units) the beam intensity will start to fall-off.");
+            public static readonly GUIContent FallOffEnd = new GUIContent("Range Limit", "Distance from the light source (in units) the beam is entirely faded out");
+
+            public static readonly GUIContent NoiseMode = new GUIContent("Enabled", "Enable 3D Noise effect and choose the mode:\n- World Space: the noise will look 'grounded' in the world\n- Local Space: the noise will look 'tied' to the beam");
+            public static readonly GUIContent NoiseIntensity = new GUIContent("Intensity", "Higher intensity means the noise contribution is stronger and more visible");
+            public static readonly GUIContent NoiseScale = new GUIContent("Scale", "3D Noise texture scaling: higher scale make the noise more visible, but potentially less realistic");
+            public static readonly GUIContent NoiseVelocity = new GUIContent("Velocity", "Direction and speed of the noise scrolling, simulating the fog/smoke movement");
+            public static readonly string[] NoiseModeEnumDescriptions = new string[]
+            {
+                "Disabled",
+                "Enabled (World Space)",
+                "Enabled (Local Space)",
+            };
+
+            public static readonly GUIContent CameraClippingDistance = new GUIContent("Camera", "Distance from the camera the beam will fade with.\n- 0.0: hard intersection\n- Higher values produce soft intersection when the camera is near the cone triangles.");
+            public static readonly GUIContent DepthBlendDistance = new GUIContent("Opaque geometry", "Distance from the world geometry the beam will fade with.\n- 0.0 (feature disabled): hard intersection but faster (doesn't require to update the depth texture).\n- Higher values produce soft intersection when the beam intersects world's geometry, but require to update the camera's depth texture.");
+
+            public static readonly GUIContent ConeRadiusStart = new GUIContent("Truncated Radius", "Radius (in units) at the beam's source (the top of the cone).\n0 will generate a perfect cone geometry.\nHigher values will generate truncated cones.");
+
+            public static readonly GUIContent GeomMeshType = new GUIContent("Mesh Type", "");
+            public static readonly GUIContent GeomCap = new GUIContent("Cap", "Show Cap Geometry (only visible from inside)");
+            public static readonly GUIContent GeomSides = new GUIContent("Sides", "Number of Sides of the cone.\nHigher values make the beam looks more 'round', but require more memory and graphic performance.\nA recommended value for a decent quality while keeping the poly count low is 18.");
+            public static readonly GUIContent GeomSegments = new GUIContent("Segments", "Number of Segments of the cone.\nHigher values give better looking results but require more performance. We recommend at least 3 segments, specially regarding Attenuation and Gradient, otherwise the approximation could become inaccurate.\nThe longer the beam, the more segments we recommend to set.\nA recommended value is 4.");
+
+            public static readonly GUIContent FadeOutEnabled = new GUIContent("Enabled", "Enable the fade out of the beam according to the distance to the camera.");
+            public static readonly GUIContent FadeOutBegin = new GUIContent("Begin Distance", "Fade out starting distance. Beyond this distance, the beam intensity will start to be dimmed.");
+            public static readonly GUIContent FadeOutEnd = new GUIContent("End", "Fade out ending distance. Beyond this distance, the beam will be culled off to save on performance.");
+
+            public static readonly GUIContent SkewingLocalForwardDirection = new GUIContent("Skewing Factor", "Distort the shape of the beam horizontally and vertically while keeping its circular slice unchanged.");
+            public static readonly GUIContent ClippingPlane = new GUIContent("Clipping Plane", "Additional clipping plane transform.");
+            public static readonly GUIContent EditorShowClippingPlane = new GUIContent("Debug", "Display the additional clipping plane.");
+
+            public static readonly GUIContent TiltFactor = new GUIContent("Tilt Factor", "Tilt the color and attenuation gradient compared to the global beam's direction.\nShould be used with 'High' shader accuracy mode.");
+            public static readonly GUIContent EditorShowTiltDirection = new GUIContent("Debug", "Display the direction of the tilt factor in editor.");
+
+            public static readonly GUIContent Dimensions = new GUIContent("Dimensions", "- 3D: beam along the Z axis.\n- 2D: beam along the X axis, so you won't have to rotate it to see it in 2D.");
+            public const string SortingLayer = "Sorting Layer";
+            public static readonly GUIContent SortingOrder = new GUIContent("Order", "The overlay priority within its layer. Lower numbers are rendered first and subsequent numbers overlay those below.");
+
+            // BUTTONS
+            public static readonly GUIContent ButtonCreateOverridePerPlatform = new GUIContent("Create another Config asset for a specific platform", "");
+            public static readonly GUIContent ButtonResetProperties = new GUIContent("Default values", "Reset properties to their default values.");
+            public static readonly GUIContent ButtonGenerateGeometry = new GUIContent("Regenerate geometry", "Force to re-create the Beam Geometry GameObject.");
+            public static readonly GUIContent ButtonEditInScene = new GUIContent("Edit in Scene View", "Edit some beam's properties directly in the Scene View using convenient gizmos.");
+            public const string ButtonAddDustParticles = "+ Volumetric Dust Particles\nAdd highly detailed dustlight/mote particles on your beam.";
+            public const string ButtonAddDynamicOcclusion = "+ Dynamic Occlusion\nGives awareness to your beam so it reacts to changes in the world: it could be occluded by environment geometry.";
+            public const string ButtonAddDynamicOcclusionRaycasting = "+ Dynamic Occlusion (Raycasting)";
+            public const string ButtonAddDynamicOcclusionDepthBuffer = "+ Dynamic Occlusion (Depth Buffer)";
+            public const string ButtonAddTriggerZone = "+ Trigger Zone\nTrack objects passing through the light beam and track when the beam is passing over them.";
+            public const string ButtonAddEffect = "+ Effect\nAdd runtime FX to easily animate your light and/or beam with effects such as strobe/flickering and pulsing/flashing.";
+            public const string ButtonAddEffectFlicker = "+ Effect Flicker";
+            public const string ButtonAddEffectPulse = "+ Effect Pulse";
+
+            // HELP BOXES
+            public const string HelpNoSpotlight = "To bind properties from the Light and the Beam together, this component must be attached to a Light of type 'Spot'";
+            public const string HelpAnimatorWarning = "If you want to animate your light beam in real-time, you should enable the 'Track Changes During Playtime' property.";
+            public const string HelpTrackChangesEnabled = "This beam will keep track of the changes of its own properties and the spotlight attached to it (if any) during playtime. You can modify every properties except 'geomSides'.";
+            public const string HelpDepthTextureMode = "To support 'Soft Intersection with Opaque Geometry', your camera must use 'DepthTextureMode.Depth'.";
+            public const string HelpDepthMobile = "On mobile platforms, the depth buffer precision can be pretty low. Try to keep a small depth range on your cameras: the difference between the near and far clip planes should stay as low as possible.";
+            public const string HelpFadeOutNoMainCamera = "Fail to retrieve the main camera specified in the config.";
+            public const string HelpTiltedWithShaderAccuracyFast = "We highly recommend to set the 'Shader Accuracy' property to 'High' when using 'Tilt Factor'.";
+
+            public const string PrefEditInScene = "VLB_BEAM_EDITINSCENE";
+            public const string PrefShowAddClippingPlane = "VLB_BEAM_SHOWADDCLIPPINGPLANE";
+        }
+
+        public static class DustParticles
+        {
+            public static readonly GUIContent HeaderRendering = new GUIContent("Rendering");
+            public static readonly GUIContent HeaderDirectionAndVelocity = new GUIContent("Direction & Velocity");
+            public static readonly GUIContent HeaderCulling = new GUIContent("Culling");
+            public static readonly GUIContent HeaderSpawning = new GUIContent("Spawning");
+            public static readonly GUIContent HeaderInfos = new GUIContent("Infos");
+
+            public static readonly GUIContent Alpha = new GUIContent("Alpha", "Max alpha of the particles");
+            public static readonly GUIContent Size = new GUIContent("Size", "Max size of the particles");
+
+            public static readonly GUIContent Direction = new GUIContent("Direction", "Direction of the particles\n- Random: random direction.\n- Local Space: particles follow the velicity direction in local space (Z is along the beam).\n- World Space: particles follow the velicity direction in world space.");
+            public static readonly GUIContent Velocity = new GUIContent("Velocity", "Movement speed of the particles along the chosen direction");
+
+            public static readonly GUIContent CullingEnabled = new GUIContent("Enabled", "Enable particles culling based on the distance to the Main Camera.\nWe highly recommend to enable this feature to keep good runtime performances.");
+            public static readonly GUIContent CullingMaxDistance = new GUIContent("Max Distance", "The particles will not be rendered if they are further than this distance to the Main Camera");
+
+            public static readonly GUIContent Density = new GUIContent("Density", "Control how many particles are spawned. The higher the density, the more particles are spawned, the higher the performance cost is");
+            public static readonly GUIContent SpawnDistanceRange = new GUIContent("Distance Range", "The distance range (from the light source) where the particles are spawned.\n- Min bound: the higher it is, the more the particles are spawned away from the light source.\n- Max bound: the lower it is, the more the particles are gathered near the light source.");
+
+            // HELP BOXES
+            public const string HelpFailToInstantiate = "Fail to instantiate the Particles. Please check your Config.";
+            public const string HelpRecommendation = "We do not recommend to use this feature if you plan to move or change properties of the beam during playtime.";
+        }
+
+        public static class DynOcclusion
+        {
+            public static readonly GUIContent HeaderUpdateRate = new GUIContent("Update Rate");
+            public static readonly GUIContent HeaderRaycasting = new GUIContent("Raycasting");
+            public static readonly GUIContent HeaderOccluderSurface = new GUIContent("Occluder Surface");
+            public static readonly GUIContent HeaderClippingPlane = new GUIContent("Clipping Plane");
+            public static readonly GUIContent HeaderCamera = new GUIContent("Camera");
+            public static readonly GUIContent HeaderEditorDebug = new GUIContent("Editor Debug");
+
+            public static readonly GUIContent Dimensions = new GUIContent("Dimensions", "Should it interact with 2D or 3D occluders?\n- 3D: the beam will react against 3D Occluders.\n- 2D: the beam will react against 2D Occluders. This is useful when using the beams with 2D objects (such as 2D Sprites).");
+
+            public static readonly GUIContent LayerMask = new GUIContent("Layer Mask",
+                "The beam can only be occluded by objects located on the layers matching this mask.\nIt's very important to set it as restrictive as possible (checking only the layers which are necessary) to perform a more efficient process in order to increase the performance.");
+            public static readonly GUIContent ConsiderTriggers = new GUIContent("Consider Triggers",
+                "Should this beam be occluded by triggers or not?");
+            public const string ConsiderTriggersNoPossible = "In order to be able to consider triggers as 2D occluders, you should tick the 'Queries Hit Triggers' checkbox under the 'Physics 2D' settings menu.";
+            public static readonly GUIContent MinOccluderArea = new GUIContent("Min Occluder Area",
+                "Minimum 'area' of the collider to become an occluder.\nColliders smaller than this value will not block the beam.");
+            public static readonly GUIContent UpdateRate = new GUIContent("Update Rate", "How often will the occlusion be processed?\nTry to update the occlusion as rarely as possible to keep good performance.");
+            public static readonly string[] UpdateRateDescriptions = new string[]
+            {
+                "Never",
+                "On Enable (only once)",
+                "On Beam Move",
+                "Every X Frames",
+                "On Beam Move and Every X Frames",
+            };
+
+            public static readonly GUIContent WaitXFrames = new GUIContent("X frames to wait",
+                "How many frames we wait between 2 occlusion tests?\nIf you want your beam to be super responsive to the changes of your environment, update it every frame by setting 1.\nIf you want to save on performance, we recommend to wait few frames between each update by setting a higher value.");
+            public static readonly GUIContent MinSurfaceRatio = new GUIContent("Min Occluded %", "Approximated percentage of the beam to collide with the surface in order to be considered as occluder.");
+            public static readonly GUIContent MaxSurfaceDot = new GUIContent("Max Angle", "Max angle (in degrees) between the beam and the surface in order to be considered as occluder.");
+            public static readonly GUIContent PlaneAlignment = new GUIContent("Alignment", "Alignment of the computed clipping plane:\n- Surface: align to the surface normal which blocks the beam. Works better for large occluders such as floors and walls.\n- Beam: keep the plane aligned with the beam direction. Works better with more complex occluders or with corners.");
+            public static readonly GUIContent PlaneOffset = new GUIContent("Offset Units", "Translate the plane. We recommend to set a small positive offset in order to handle non-flat surface better.");
+            public static readonly GUIContent FadeDistanceToSurface = new GUIContent("Fade Distance Units", "Fade out the beam before the occlusion surface in order to soften the transition.");
+            public static readonly GUIContent EditorShowDebugPlane = new GUIContent("Show Debug Plane", "Draw debug plane on the scene view.");
+            public static readonly GUIContent EditorRaycastAtEachFrame = new GUIContent("Update in Editor", "Perform occlusion tests and raycasts in Editor.");
+
+            public static string GetUpdateRateAdvice<T>(DynamicOcclusionUpdateRate value)
+            {
+                switch (value)
+                {
+                    case DynamicOcclusionUpdateRate.Never: return string.Format("The occlusion will never be updated.\nThe only way to update it is to manually call '{0}.ProcessOcclusionManually()' from script whenever you need.", typeof(T).Name);
+                    case DynamicOcclusionUpdateRate.OnEnable: return "The occlusion will only be updated once on start, and each time the beam is enabled/activated (after being disabled/deactivated).\nIt's suitable for static beams located in static environment.";
+                    case DynamicOcclusionUpdateRate.OnBeamMove: return "The occlusion will only be updated when the beam will move.\nIt's suitable for moving beams located in static environment.";
+                    case DynamicOcclusionUpdateRate.EveryXFrames: return "The occlusion will be updated every {0} frame(s).\nIt's suitable for static beams located in moving environment.";
+                    case DynamicOcclusionUpdateRate.OnBeamMoveAndEveryXFrames: return "The occlusion will be updated when the beam will move in addition to every {0} frame(s).\nIt's suitable for moving beams located in moving environment.";
+                    default: return null;
+                }
+            }
+
+            public static readonly GUIContent DepthBufferOcclusionCulling = new GUIContent("Occlusion Culling", "Whether or not the virtual camera will use occlusion culling during rendering from the beam's POV.");
+            public static readonly GUIContent DepthBufferDepthMapResolution = new GUIContent("Depth Map Resolution", "Controls how large the depth texture captured by the virtual camera is.\nThe lower the resolution, the better the performance, but the less accurate the rendering.");
+
+            public const string HelpDepthBufferAndBeam2D = "'Dynamic Occlusion (Depth Buffer)' doesn't work with 2D sprites nor 2D colliders. It will only track 3D objects.";
+
+            public const string HelpOverrideLayer = "To keep good performance, it's highly recommended to set an 'Override Layer' in the Config when using this feature, to prevent from having a LayerMark including any Volumetric Beam.";
+            public static string HelpLayerMaskIssues { get { return string.Format("The beams are generated on the layer '{0}' (set in the Config), but this LayerMask includes this layer.\nTo keep good performance, it's highly recommended to set a LayerMask which doesn't include this layer!", UnityEngine.LayerMask.LayerToName(VLB.Config.Instance.geometryLayerID)); } }
+
+            public const string HelpFeatureDisabled = "The Dynamic Occlusion features have been disabled in the plugin's Config.";
+        }
+
+        public static class TriggerZone
+        {
+            public static readonly GUIContent HeaderInfos = new GUIContent("Infos");
+
+            public static readonly GUIContent SetIsTrigger = new GUIContent("Set Is Trigger", "Define if the Collider will be created as a convex trigger (not physical, most common behavior) or as a regular collider (physical).");
+            public static readonly GUIContent RangeMultiplier = new GUIContent("Range Multiplier", "Change the length of the Collider.\nFor example, set 2.0 to make the Collider 2x longer than the beam.");
+
+            public const string HelpDescription2D = "Generate a 2D Polygon Collider with the same shape than the beam, supporting dynamic occlusion.";
+            public const string HelpDescription3D = "Generate a 3D Mesh Collider with the same shape than the beam. The collider doesn't support occlusion though.";
+            public const string HelpTrackChangesDuringPlaytimeEnabled = "The TriggerZone collider cannot be changed in realtime.\nIf you animate a property which change the shape of the beam, the collider shape won't fit anymore.";
+        }
+
+        public static class SkewingHandle
+        {
+            public static readonly GUIContent Beam = new GUIContent("Beam", "The Volumetric Light Beam you want to modify.");
+            public static readonly GUIContent ShouldUpdateEachFrame = new GUIContent("Should Update Each Frame", "Should the beam's skewing property be updated each frame or only once?");
+
+            public const string ErrorAttachedToSelf = "You should attach the 'SkewingHandle' component to another GameObject than the beam itself.";
+            public const string ErrorCannotSkew = "This beam can't be skewed because it doesn't use 'Custom' mesh type.";
+            public const string ErrorCannotUpdate = "This beam can't be updated each frame since its property 'Track Changes During Playtime' is disabled.";
+
+            public const string HelpFeatureDisabled = "The 'Mesh Skewing' feature has been disabled in the plugin's Config.";
+        }
+
+        public static class Config
+        {
+            public static readonly GUIContent HeaderBeamGeometry = new GUIContent("Beam Geometry", "");
+            public static readonly GUIContent HeaderRendering = new GUIContent("Rendering", "");
+            public static readonly GUIContent HeaderSharedMesh = new GUIContent("Shared Mesh", "");
+            public static readonly GUIContent HeaderGlobal3DNoise = new GUIContent("Global 3D Noise", "");
+            public static readonly GUIContent HeaderFadeOutCamera = new GUIContent("Camera to compute Fade Out", "");
+            public static readonly GUIContent HeaderFeaturesEnabled = new GUIContent("Features Enabled", "Disable the features you don't use in your project to speed up export time, specially with URP and HDRP.");
+            public static readonly GUIContent HeaderInternalData = new GUIContent("Internal Data (do not change)", "");
+
+            public static readonly GUIContent GeometryOverrideLayer = new GUIContent("Override Layer", "The layer the GameObjects holding the procedural cone meshes are created on");
+            public static readonly GUIContent GeometryTag = new GUIContent("Tag", "The tag applied on the procedural geometry GameObjects");
+            public static readonly GUIContent GeometryRenderQueue = new GUIContent("Render Queue", "Determine in which order beams are rendered compared to other objects.\nThis way for example transparent objects are rendered after opaque objects, and so on.");
+            public static readonly GUIContent GeometryRenderPipeline = new GUIContent("Render Pipeline", "Select the Render Pipeline (Built-In or SRP) in use.");
+            public static readonly GUIContent GeometryRenderingMode = new GUIContent("Rendering Mode",
+@"- Multi-Pass: Use the 2 pass shader. Will generate 2 drawcalls per beam (Not compatible with custom Render Pipeline such as HDRP and LWRP).
+- Single-Pass: Use the 1 pass shader. Will generate 1 drawcall per beam.
+- GPU Instancing: Dynamically batch multiple beams to combine and reduce draw calls.
+- SRP Batcher: Use the SRP Batcher to automatically batch multiple beams and reduce draw calls. Only available when using SRP.");
+
+            public static string ErrorSrpAndMultiPassNotCompatible { get { return string.Format("Using a Scriptable Render Pipeline with 'Multi-Pass' Rendering Mode is not supported: please choose another Rendering Mode, or '{0}' will be used.", VLB.Config.Instance.actualRenderingMode); } }
+            public static string ErrorSrpBatcherOnlyCompatibleWithSrp { get { return string.Format("The 'SRP Batcher' Rendering Mode is only compatible when using a SRP: please choose another Rendering Mode, or '{0}' will be used.", VLB.Config.Instance.actualRenderingMode); } }
+            public static string ErrorSrpBatcherNotCompatibleWithLWRP { get { return string.Format("The 'SRP Batcher' Rendering Mode is not compatible with LWRP: please choose another Rendering Mode, or '{0}' will be used.", VLB.Config.Instance.actualRenderingMode); } }
+            public static string ErrorGeometryGpuInstancingNotSupported { get { return string.Format("'GPU Instancing' Rendering Mode is only supported on Unity 5.6 or above! '{0}' will be used.", VLB.Config.Instance.actualRenderingMode); } }
+            public const string ErrorRenderPipelineMismatch = "It looks like the 'Render Pipeline' correctly is not set.\nPlease make sure to select the proper value depending on your pipeline in use.";
+
+            public static readonly GUIContent FadeOutCameraTag = new GUIContent("Fade Out Camera Tag", "Tag used to retrieve the camera used to compute the fade out factor on beams");
+
+            public static readonly GUIContent SharedMeshSides = new GUIContent("Sides", "Number of Sides of the cone.\nHigher values make the beam looks more 'round', but require more memory and graphic performance.\nA recommended value for a decent quality while keeping the poly count low is 18.");
+            public static readonly GUIContent SharedMeshSegments = new GUIContent("Segments", "Number of Segments of the cone.\nHigher values give better looking results but require more performance. We recommend at least 3 segments, specially regarding Attenuation and Gradient, otherwise the approximation could become inaccurate.\nThe longer the beam, the more segments we recommend to set.\nA recommended value is 4.");
+            public static readonly GUIContent GlobalNoiseScale = new GUIContent("Scale", "Global 3D Noise texture scaling: higher scale make the noise more visible, but potentially less realistic");
+            public static readonly GUIContent GlobalNoiseVelocity = new GUIContent("Velocity", "Global World Space direction and speed of the noise scrolling, simulating the fog/smoke movement");
+            public static readonly GUIContent NoiseTexture3D = new GUIContent("3D Noise Texture", "3D Texture storing noise data.");
+            public static readonly GUIContent DustParticlesPrefab = new GUIContent("Dust Particles Prefab", "ParticleSystem prefab instantiated for the Volumetric Dust Particles feature (Unity 5.5 or above)");
+            public static readonly GUIContent DitheringFactor = new GUIContent("Dithering", "Depending on the quality of your screen, you might see some artifacts with high contrast visual (like a white beam over a black background).\nThese is a very common problem known as color banding.\nTo help with this issue, the plugin offers a Dithering factor: it smooths the banding by introducing a subtle pattern of noise.");
+            public static readonly GUIContent DitheringNoiseTexture = new GUIContent("Dithering Noise Texture", "Noise texture for dithering feature.");
+            public static readonly GUIContent OpenDocumentation = new GUIContent("Documentation", "Open the online documentation.");
+            public static readonly GUIContent ResetToDefaultButton = new GUIContent("Default values", "Reset properties to their default values.");
+            public static readonly GUIContent ResetInternalDataButton = new GUIContent("Reset internal data", "Reset internal data to their default values.");
+
+            public static readonly GUIContent FeatureEnabledColorGradient = new GUIContent("Color Gradient", "- Off: do not support having a gradient as color.\n- High Only: support gradient color only for devices with Shader Level = 35 or higher.\n- High and Low: support gradient color for all devices");
+            public static readonly GUIContent FeatureEnabledDepthBlend = new GUIContent("Soft Intersect w/ Opaque Geometry", "Support having soft intersection when the beam intersects other opaque geometry or not.");
+            public static readonly GUIContent FeatureEnabledNoise3D = new GUIContent("Noise 3D", "Support 'Noise 3D' feature or not.");
+            public static readonly GUIContent FeatureEnabledDynamicOcclusion = new GUIContent("Dynamic Occlusion", "Support 'Dynamic Occlusion' features or not.");
+            public static readonly GUIContent FeatureEnabledMeshSkewing = new GUIContent("Mesh Skewing", "Support 'Mesh Skewing' feature or not.");
+            public static readonly GUIContent FeatureEnabledShaderAccuracyHigh = new GUIContent("High Shader Accuracy", "Support 'Shader Accuracy' property set to 'High' or not.");
+
+            public static readonly string[] GeometryRenderPipelineEnumDescriptions = new string[]
+            {
+                "Built-In",
+                "URP",
+                "HDRP",
+            };
+
+            public static string GetErrorInvalidShader() { return string.Format("Fail to generate shader asset. Please try to reset the Config asset or reinstall the plugin."); }
+
+            public static readonly string InvalidPlatformOverride = string.Format(
+                "This Config asset has an invalid name. It should be named either:\n- '{0}.asset' for the default config.\n- '{0}PlatformName.asset' for a config specific to a platform, e.g., '{0}Android.asset'."
+                , ConfigOverride.kAssetName
+                , typeof(ConfigOverride).ToString()
+                );
+
+            public static readonly string WrongAssetLocation = string.Format(
+                "This Config asset is not the one in use, please make sure: it's directly located under a 'Resources' folder."
+                );
+
+            public static readonly string NotCurrentAssetInUse = string.Format(
+                "This Config asset is not the one in use for current Target Platform '{0}'."
+                , PlatformHelper.GetCurrentPlatformSuffix()
+                );
+        }
+
+        public static class Effects
+        {
+            public static readonly GUIContent HeaderTimings = new GUIContent("Timings", "");
+            public static readonly GUIContent HeaderVisual = new GUIContent("Visual", "");
+            public static readonly GUIContent HeaderMisc = new GUIContent("Misc", "");
+
+            public static readonly GUIContent PerformPauses = new GUIContent("Perform Pauses", "If enabled, pauses will be added between 2 flickering sequences.");
+            public static readonly GUIContent FlickeringDuration = new GUIContent("Flickering Duration", "The duration of a flickering sequence.\nA random value will be picked each time inside that range.");
+            public static readonly GUIContent PauseDuration = new GUIContent("Pause Duration", "The duration of a pause sequence.\nA random value will be picked each time inside that range.");
+            public static readonly GUIContent FrequencyFlicker = new GUIContent("Frequency", "Frequency of flickering.\nHigher value means the flickering will occur faster.");
+            public static readonly GUIContent FrequencyPulse = new GUIContent("Frequency", "Frequency of pulsing.\nHigher value means the pulsing will occur faster.");
+            public static readonly GUIContent IntensityAmplitude = new GUIContent("Intensity Amplitude", "The amplitude of intensity change which will be applied to the Light and/or Beam.\nA random value will be picked each time inside that range.");
+            public static readonly GUIContent Smoothing = new GUIContent("Smoothing", "How much intensity change will be smoothed.\nHigher value means the more smoothing.");
+            public static readonly GUIContent RestoreBaseIntensity = new GUIContent("Restore Base Intensity", "Restore the default intensity when this component is disabled.");
+            public static readonly GUIContent ComponentsToChange = new GUIContent("Components To Change", "Decide which component to change among:\n- Unity's Light\n- Volumetric Light Beam\n- Volumetric Dust Particles");
+            public static readonly GUIContent ChangeVolumetricBeamIntensity = new GUIContent("Change Volumetric Beam Intensity", "Apply the flicker on the Volumetric Beam Intensity.");
+
+            public const string HelpNoValidComponents = "This component must be applied with a 'Unity Light' and/or a 'Volumetric Light Beam'.";
+            public const string HelpLightNotChangeable = "To apply this effect on the Unity Light's intensity, it must use 'Realtime' or 'Mixed' mode.";
+            public const string HelpBeamNotChangeable = "To apply this effect on the Volumetric Light Beam's intensity, it must have its 'Track Changes During Playtime' property enabled.";
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/EditorStrings.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 962298216d0e67f4c9294aa63ae5e9a4
+timeCreated: 1525089533
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EffectAbstractBaseEditor.cs

@@ -0,0 +1,74 @@
+#if UNITY_EDITOR
+using UnityEditor;
+
+namespace VLB
+{
+    public abstract class EffectAbstractBaseEditor<T> : EditorCommon where T : EffectAbstractBase
+    {
+        SerializedProperty componentsToChange = null;
+        SerializedProperty restoreBaseIntensity = null;
+
+        protected TargetList<T> m_Targets;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_Targets = new TargetList<T>(targets);
+        }
+
+        protected abstract void DisplayChildProperties();
+
+        public sealed override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            if (m_Targets.HasAtLeastOneTargetWith((T comp) => { return comp.GetComponent<UnityEngine.Light>() == null && comp.GetComponent<VolumetricLightBeam>() == null; }))
+            {
+                EditorGUILayout.HelpBox(EditorStrings.Effects.HelpNoValidComponents, MessageType.Error);
+                return;
+            }
+
+            if (m_Targets.HasAtLeastOneTargetWith((T comp) =>
+            {
+                if (comp.componentsToChange.HasFlag(EffectAbstractBase.ComponentsToChange.UnityLight))
+                {
+                    var light = comp.GetComponent<UnityEngine.Light>();
+#if UNITY_5_6_OR_NEWER
+                    return (light && light.lightmapBakeType == UnityEngine.LightmapBakeType.Baked);
+#else
+                    return (light && light.lightmappingMode == UnityEngine.LightmappingMode.Baked);
+#endif
+                }
+                return false;
+            }))
+            {
+                EditorGUILayout.HelpBox(EditorStrings.Effects.HelpLightNotChangeable, MessageType.Warning);
+            }
+
+            if (m_Targets.HasAtLeastOneTargetWith((T comp) =>
+            {
+                if (comp.componentsToChange.HasFlag(EffectAbstractBase.ComponentsToChange.VolumetricLightBeam))
+                {
+                    var beam = comp.GetComponent<VolumetricLightBeam>();
+                    return (beam && !beam.trackChangesDuringPlaytime);
+                }
+                return false;
+            }))
+            {
+                EditorGUILayout.HelpBox(EditorStrings.Effects.HelpBeamNotChangeable, MessageType.Warning);
+            }
+
+            DisplayChildProperties();
+
+            if (FoldableHeader.Begin(this, EditorStrings.Effects.HeaderMisc))
+            {
+                componentsToChange.CustomMask<EffectAbstractBase.ComponentsToChange>(EditorStrings.Effects.ComponentsToChange);
+                EditorGUILayout.PropertyField(restoreBaseIntensity, EditorStrings.Effects.RestoreBaseIntensity);
+            }
+            FoldableHeader.End();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/EffectAbstractBaseEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 18e0ceec3655f144990c0deb0f6493bb
+timeCreated: 1617647862
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EffectFlickerEditor.cs

@@ -0,0 +1,42 @@
+#if UNITY_EDITOR
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(EffectFlicker))]
+    [CanEditMultipleObjects]
+    public class EffectFlickerEditor : EffectAbstractBaseEditor<EffectFlicker>
+    {
+        SerializedProperty performPauses = null;
+        SerializedProperty flickeringDuration = null;
+        SerializedProperty pauseDuration = null;
+        SerializedProperty frequency = null;
+        SerializedProperty intensityAmplitude = null;
+        SerializedProperty smoothing = null;
+
+        protected override void DisplayChildProperties()
+        {
+            if (FoldableHeader.Begin(this, EditorStrings.Effects.HeaderTimings))
+            {
+                EditorGUILayout.PropertyField(frequency, EditorStrings.Effects.FrequencyFlicker);
+
+                EditorGUILayout.PropertyField(performPauses, EditorStrings.Effects.PerformPauses);
+
+                if (m_Targets.HasAtLeastOneTargetWith((EffectFlicker comp) => { return comp.performPauses == true; }))
+                {
+                    EditorGUILayout.PropertyField(flickeringDuration, EditorStrings.Effects.FlickeringDuration);
+                    EditorGUILayout.PropertyField(pauseDuration, EditorStrings.Effects.PauseDuration);
+                }
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.Effects.HeaderVisual))
+            {
+                EditorGUILayout.PropertyField(intensityAmplitude, EditorStrings.Effects.IntensityAmplitude);
+                EditorGUILayout.PropertyField(smoothing, EditorStrings.Effects.Smoothing);
+            }
+            FoldableHeader.End();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/EffectFlickerEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: acd24c9fc8968d74aa2ffe5a14630857
+timeCreated: 1617383958
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/EffectPulseEditor.cs

@@ -0,0 +1,29 @@
+#if UNITY_EDITOR
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(EffectPulse))]
+    [CanEditMultipleObjects]
+    public class EffectPulseEditor : EffectAbstractBaseEditor<EffectPulse>
+    {
+        SerializedProperty frequency = null;
+        SerializedProperty intensityAmplitude = null;
+
+        protected override void DisplayChildProperties()
+        {
+            if (FoldableHeader.Begin(this, EditorStrings.Effects.HeaderTimings))
+            {
+                EditorGUILayout.PropertyField(frequency, EditorStrings.Effects.FrequencyPulse);
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.Effects.HeaderVisual))
+            {
+                EditorGUILayout.PropertyField(intensityAmplitude, EditorStrings.Effects.IntensityAmplitude);
+            }
+            FoldableHeader.End();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/EffectPulseEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e5ae0f0491b8ca743b77f3ffbaf703d1
+timeCreated: 1617647714
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/FoldableHeader.cs

@@ -0,0 +1,73 @@
+#if UNITY_EDITOR
+#if UNITY_2019_1_OR_NEWER
+#define UI_USE_FOLDOUT_HEADER_2019
+#endif
+
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+using System;
+
+namespace VLB
+{
+    public static class FoldableHeader
+    {
+        public static void OnEnable()
+        {
+            ms_CurrentFoldableHeader = null;
+        }
+
+        public static bool Begin(UnityEngine.Object self, string label)
+        {
+            return Begin(self, new GUIContent(label));
+        }
+
+        public static bool Begin(UnityEngine.Object self, GUIContent label)
+        {
+            var uniqueString = label.text;
+            if(self) uniqueString = self.ToString() + uniqueString;
+
+            if (ms_StyleHeaderFoldable == null)
+            {
+                ms_StyleHeaderFoldable = new GUIStyle(EditorStyles.foldout);
+                ms_StyleHeaderFoldable.fontStyle = FontStyle.Bold;
+            }
+
+            ms_CurrentFoldableHeader = uniqueString;
+
+            bool folded = ms_FoldedHeaders.Contains(uniqueString);
+
+#if UI_USE_FOLDOUT_HEADER_2019
+            folded = !EditorGUILayout.BeginFoldoutHeaderGroup(!folded, label);
+#else
+            folded = !EditorGUILayout.Foldout(!folded, label, toggleOnLabelClick: true, style: ms_StyleHeaderFoldable);
+#endif
+
+            if (folded) ms_FoldedHeaders.Add(uniqueString);
+            else ms_FoldedHeaders.Remove(uniqueString);
+
+            return !folded;
+        }
+
+        public static void End()
+        {
+            Debug.Assert(ms_CurrentFoldableHeader != null, "Trying to call FoldableHeader.End() but there is no header opened");
+            ms_CurrentFoldableHeader = null;
+
+#if UI_USE_FOLDOUT_HEADER_2019
+            EditorGUILayout.EndFoldoutHeaderGroup();
+#if UNITY_2019_3_OR_NEWER
+            EditorGUILayout.Separator();
+#endif
+#else
+            EditorCommon.DrawLineSeparator();
+#endif
+        }
+
+        static string ms_CurrentFoldableHeader = null;
+        static HashSet<String> ms_FoldedHeaders = new HashSet<String>();
+        static GUIStyle ms_StyleHeaderFoldable = null;
+    }
+}
+#endif // UNITY_EDITOR
+

Assets/Plugins/VolumetricLightBeam/Editor/FoldableHeader.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ccdd6181af634264e819236c461b2ac4
+timeCreated: 1582578385
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e8db50253508b4c4ba3e2bb11c413f0e
+folderAsset: yes
+timeCreated: 1507401744
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/DynamicOcclusion.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: f4140fedf3f72d7448a4e55ea9db44ab
+timeCreated: 1513615323
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 2
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/DynamicOcclusion_button.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: c0b232bfb34a77a4a84fdc476cfedea4
+timeCreated: 1617797074
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/Effect.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 6dfec383bc9ad504891027fdab8062b1
+timeCreated: 1617798010
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/Effect_button.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 1a5ba5df396106d4cafd5a96415ffb6c
+timeCreated: 1617798010
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/FloatingDustParticles.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 54d50eb83191723439a591eeeb0eab84
+timeCreated: 1617781142
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 2
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/FloatingDustParticles_button.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: eae0c95c9c12c4e40a87d028b6e5aaad
+timeCreated: 1617781625
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/FromSpotLight_button.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 350d4bb70b7205342aefcb03e66a7dcb
+timeCreated: 1617992244
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/SkewingHandle.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 96c382e4368041b4aad93aed0a833e2b
+timeCreated: 1617808226
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/TriggerZone.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 568401c2857b94943af27dc14afca0ae
+timeCreated: 1531459068
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 2
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/TriggerZone_button.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 3fcfb96a95b4b82439ae47f4f060137c
+timeCreated: 1617796383
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/Icons/VolumetricLightBeam.png.meta

@@ -0,0 +1,84 @@
+fileFormatVersion: 2
+guid: 837747a8b63291a48838c340da834873
+timeCreated: 1507401784
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 2
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/OnBuildPostprocess.cs

@@ -0,0 +1,15 @@
+#if UNITY_EDITOR && UNITY_2018_1_OR_NEWER
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+class OnBuildPostprocess : IPostprocessBuildWithReport
+{
+    public int callbackOrder { get { return 0; } }
+    public void OnPostprocessBuild(BuildReport report)
+    {
+        VLB.PlatformHelper.SetBuildTargetOverride(BuildTarget.NoTarget);
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/OnBuildPostprocess.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f6591152e52a89a4dba853ddca8c00f6
+timeCreated: 1612121684
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/OnBuildPreprocess.cs

@@ -0,0 +1,15 @@
+#if UNITY_EDITOR && UNITY_2018_1_OR_NEWER
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+class OnBuildPreprocess : IPreprocessBuildWithReport
+{
+    public int callbackOrder { get { return 0; } }
+    public void OnPreprocessBuild(BuildReport report)
+    {
+        VLB.PlatformHelper.SetBuildTargetOverride(report.summary.platform);
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/OnBuildPreprocess.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9b7dc575bd0b12c449148d07bc32fe49
+timeCreated: 1612121684
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/OnBuildTargetChanged.cs

@@ -0,0 +1,19 @@
+#if UNITY_EDITOR && UNITY_2018_1_OR_NEWER
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Build;
+
+namespace VLB
+{
+    public class ActiveBuildTargetListener : IActiveBuildTargetChanged
+    {
+        public int callbackOrder { get { return 0; } }
+        public void OnActiveBuildTargetChanged(BuildTarget previousTarget, BuildTarget newTarget)
+        {
+            Config.Instance.RefreshShader(Config.RefreshShaderFlags.All);
+            GlobalMesh.Destroy();
+            VolumetricLightBeam._EditorSetAllMeshesDirty();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/OnBuildTargetChanged.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f54417ff4a50cfb4ba556d04b6689eab
+timeCreated: 1612121684
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/SkewingHandleEditor.cs

@@ -0,0 +1,47 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace VLB
+{
+    [CustomEditor(typeof(SkewingHandle))]
+    public class SkewingHandleEditor : EditorCommon
+    {
+        SerializedProperty volumetricLightBeam = null;
+        SerializedProperty shouldUpdateEachFrame = null;
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            var thisTarget = target as SkewingHandle;
+            if (thisTarget == null)
+                return;
+
+            if(Config.Instance.featureEnabledMeshSkewing == false)
+                EditorGUILayout.HelpBox(EditorStrings.SkewingHandle.HelpFeatureDisabled, MessageType.Warning);
+
+            EditorGUILayout.PropertyField(volumetricLightBeam, EditorStrings.SkewingHandle.Beam);
+            EditorGUILayout.PropertyField(shouldUpdateEachFrame, EditorStrings.SkewingHandle.ShouldUpdateEachFrame);
+
+            if (thisTarget.volumetricLightBeam)
+            {
+                if(thisTarget.IsAttachedToSelf())
+                {
+                    EditorGUILayout.HelpBox(EditorStrings.SkewingHandle.ErrorAttachedToSelf, MessageType.Error);
+                }
+                else if (!thisTarget.CanSetSkewingVector())
+                {
+                    EditorGUILayout.HelpBox(EditorStrings.SkewingHandle.ErrorCannotSkew, MessageType.Error);
+                }
+                else if (thisTarget.shouldUpdateEachFrame && !thisTarget.CanUpdateEachFrame())
+                {
+                    EditorGUILayout.HelpBox(EditorStrings.SkewingHandle.ErrorCannotUpdate, MessageType.Error);
+                }
+            }
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif
+

Assets/Plugins/VolumetricLightBeam/Editor/SkewingHandleEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f95e2188469d17a4081bb82c36e6e8de
+timeCreated: 1604927219
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/TargetList.cs

@@ -0,0 +1,72 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace VLB
+{
+    public class TargetList<T> : IEnumerable<T> where T : MonoBehaviour
+    {
+        public int Count { get { return m_Targets != null ? m_Targets.Count : 0; } }
+        public T this[int key] { get { return m_Targets != null ? m_Targets[key] : null; } }
+
+        public List<T> m_Targets = null;
+
+        public TargetList(UnityEngine.Object[] entities)
+        {
+            m_Targets = new List<T>();
+            foreach (var entity in entities)
+            {
+                if (entity is T)
+                {
+                    m_Targets.Add(entity as T); // directly get the component from the object
+                }
+                else
+                {
+                    // otherwise get access from the current MonoBehaviour, in case the current MonoBehaviour is not the type wanted as target
+                    var behaviour = entity as MonoBehaviour;
+                    var comp = behaviour.GetComponent<T>();
+                    if (comp)
+                        m_Targets.Add(comp);
+                }
+            }
+            Debug.Assert(m_Targets.Count > 0);
+        }
+
+        public bool HasAtLeastOneTargetWith(System.Func<T, bool> lambda)
+        {
+            foreach (var target in m_Targets)
+            {
+                if (lambda(target))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void RecordUndoAction(string name, System.Action<T> lambda)
+        {
+            Undo.RecordObjects(m_Targets.ToArray(), name);
+
+            foreach (var target in m_Targets)
+            {
+                lambda(target);
+            }
+        }
+
+        // make this object foreach compatible
+        public IEnumerator<T> GetEnumerator()
+        {
+            foreach (var target in m_Targets)
+                yield return target;
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}
+#endif
+

Assets/Plugins/VolumetricLightBeam/Editor/TargetList.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b0e1e5cc7f9712648b3438ad03f9f073
+timeCreated: 1578239648
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/TriggerZoneEditor.cs

@@ -0,0 +1,46 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace VLB
+{
+    [CustomEditor(typeof(TriggerZone))]
+    [CanEditMultipleObjects]
+    public class TriggerZoneEditor : EditorCommon
+    {
+        SerializedProperty setIsTrigger = null;
+        SerializedProperty rangeMultiplier = null;
+        TargetList<VolumetricLightBeam> m_Targets;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_Targets = new TargetList<VolumetricLightBeam>(targets);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            EditorGUILayout.PropertyField(setIsTrigger, EditorStrings.TriggerZone.SetIsTrigger);
+            EditorGUILayout.PropertyField(rangeMultiplier, EditorStrings.TriggerZone.RangeMultiplier);
+
+            if (FoldableHeader.Begin(this, EditorStrings.TriggerZone.HeaderInfos))
+            {
+                EditorGUILayout.HelpBox(
+                    m_Targets.m_Targets[0].dimensions == Dimensions.Dim3D ? EditorStrings.TriggerZone.HelpDescription3D : EditorStrings.TriggerZone.HelpDescription2D
+                    , MessageType.Info);
+
+                if(m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.trackChangesDuringPlaytime; }))
+                {
+                    EditorGUILayout.HelpBox(EditorStrings.TriggerZone.HelpTrackChangesDuringPlaytimeEnabled, MessageType.Warning);
+                }
+            }
+            FoldableHeader.End();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/TriggerZoneEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ded92402e19378c4a90ceb5ed4b418f9
+timeCreated: 1531119204
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/VolumetricDustParticlesEditor.cs

@@ -0,0 +1,94 @@
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace VLB
+{
+    [CustomEditor(typeof(VolumetricDustParticles))]
+    [CanEditMultipleObjects]
+    public class VolumetricDustParticlesEditor : EditorCommon
+    {
+        SerializedProperty alpha = null;
+        SerializedProperty size = null;
+        SerializedProperty direction = null;
+        SerializedProperty velocity = null;
+        SerializedProperty density = null;
+        SerializedProperty spawnDistanceRange = null;
+        SerializedProperty cullingEnabled = null;
+        SerializedProperty cullingMaxDistance = null;
+
+        static bool AreParticlesInfosUpdated() { return Application.isPlaying; }
+        public override bool RequiresConstantRepaint() { return AreParticlesInfosUpdated(); }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            var particles = target as VolumetricDustParticles;
+
+            if (particles.gameObject.activeSelf && particles.enabled && !particles.particlesAreInstantiated)
+            {
+                EditorGUILayout.HelpBox(EditorStrings.DustParticles.HelpFailToInstantiate, MessageType.Error);
+                ButtonOpenConfig();
+            }
+
+            if (FoldableHeader.Begin(this, EditorStrings.DustParticles.HeaderRendering))
+            {
+                EditorGUILayout.PropertyField(alpha, EditorStrings.DustParticles.Alpha);
+                EditorGUILayout.PropertyField(size, EditorStrings.DustParticles.Size);
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DustParticles.HeaderDirectionAndVelocity))
+            {
+                EditorGUILayout.PropertyField(direction, EditorStrings.DustParticles.Direction);
+
+                if (particles.direction == ParticlesDirection.Random)
+                {
+                    var vec = velocity.vector3Value;
+                    vec.z = EditorGUILayout.FloatField(EditorStrings.DustParticles.Velocity, vec.z);
+                    velocity.vector3Value = vec;
+                }
+                else
+                {
+                    EditorGUILayout.PropertyField(velocity, EditorStrings.DustParticles.Velocity);
+                }
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DustParticles.HeaderCulling))
+            {
+                EditorGUILayout.PropertyField(cullingEnabled, EditorStrings.DustParticles.CullingEnabled);
+                if (cullingEnabled.boolValue)
+                    EditorGUILayout.PropertyField(cullingMaxDistance, EditorStrings.DustParticles.CullingMaxDistance);
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DustParticles.HeaderSpawning))
+            {
+                EditorGUILayout.PropertyField(density, EditorStrings.DustParticles.Density);
+                EditorGUILayout.PropertyField(spawnDistanceRange, EditorStrings.DustParticles.SpawnDistanceRange);
+
+                {
+                    var infos = "Current particles count: ";
+                    if (AreParticlesInfosUpdated()) infos += particles.particlesCurrentCount;
+                    else infos += "(playtime only)";
+                    if (particles.isCulled)
+                        infos += string.Format(" (culled by '{0}')", particles.mainCamera.name);
+                    infos += string.Format("\nMax particles count: {0}", particles.particlesMaxCount);
+                    EditorGUILayout.HelpBox(infos, MessageType.Info);
+                }
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.DustParticles.HeaderInfos))
+            {
+                EditorGUILayout.HelpBox(EditorStrings.DustParticles.HelpRecommendation, MessageType.Info);
+            }
+            FoldableHeader.End();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/VolumetricDustParticlesEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 264a06b7c9bbc6940bd66056f4a38291
+timeCreated: 1510686811
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Editor/VolumetricLightBeamEditor.cs

@@ -0,0 +1,777 @@
+//#define DEBUG_SHOW_CUSTOM_MATERIAL_INFO
+
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using System.Collections.Generic;
+using System.Linq;
+
+#pragma warning disable 0429, 0162 // Unreachable expression code detected (because of Noise3D.isSupported on mobile)
+
+namespace VLB
+{
+    [CustomEditor(typeof(VolumetricLightBeam))]
+    [CanEditMultipleObjects]
+    public class VolumetricLightBeamEditor : EditorCommon
+    {
+        SerializedProperty trackChangesDuringPlaytime = null;
+        SerializedProperty colorFromLight = null, colorMode = null, color = null, colorGradient = null;
+        SerializedProperty intensityFromLight = null, intensityModeAdvanced = null, intensityInside = null, intensityOutside = null;
+        SerializedProperty blendingMode = null, shaderAccuracy = null;
+        SerializedProperty fresnelPow = null, glareFrontal = null, glareBehind = null;
+        SerializedProperty spotAngleFromLight = null, spotAngle = null;
+        SerializedProperty coneRadiusStart = null, geomMeshType = null, geomCustomSides = null, geomCustomSegments = null, geomCap = null;
+        SerializedProperty fallOffEndFromLight = null, fallOffStart = null, fallOffEnd = null;
+        SerializedProperty attenuationEquation = null, attenuationCustomBlending = null;
+        SerializedProperty depthBlendDistance = null, cameraClippingDistance = null;
+        SerializedProperty noiseMode = null, noiseIntensity = null, noiseScaleUseGlobal = null, noiseScaleLocal = null, noiseVelocityUseGlobal = null, noiseVelocityLocal = null;
+        SerializedProperty fadeOutBegin = null, fadeOutEnd = null;
+        SerializedProperty dimensions = null, sortingLayerID = null, sortingOrder = null;
+        SerializedProperty skewingLocalForwardDirection = null, clippingPlaneTransform = null, tiltFactor = null;
+
+        TargetList<VolumetricLightBeam> m_Targets;
+        string[] m_SortingLayerNames;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_SortingLayerNames = SortingLayer.layers.Select(l => l.name).ToArray();
+            m_Targets = new TargetList<VolumetricLightBeam>(targets);
+        }
+
+        static void PropertyThickness(SerializedProperty sp)
+        {
+            sp.FloatSlider(
+                EditorStrings.Beam.SideThickness,
+                0, 1,
+                (value) => Mathf.Clamp01(1 - (value / Consts.Beam.FresnelPowMaxValue)),    // conversion value to slider
+                (value) => (1 - value) * Consts.Beam.FresnelPowMaxValue                    // conversion slider to value
+                );
+        }
+
+
+        class ButtonToggleScope : System.IDisposable
+        {
+            SerializedProperty m_Property;
+            bool m_DisableGroup = false;
+            GUIContent m_Content = null;
+
+            void Enable()
+            {
+                EditorGUILayout.BeginHorizontal();
+                if(m_DisableGroup)
+                    EditorGUI.BeginDisabledGroup(m_Property.HasAtLeastOneValue(true));
+            }
+
+            void Disable()
+            {
+                if(m_DisableGroup)
+                    EditorGUI.EndDisabledGroup();
+                DrawToggleButton();
+                EditorGUILayout.EndHorizontal();
+            }
+
+            public ButtonToggleScope(SerializedProperty prop, bool disableGroup, GUIContent content)
+            {
+                m_Property = prop;
+                m_DisableGroup = disableGroup;
+                m_Content = content;
+                Enable();
+            }
+
+            public void Dispose() { Disable(); }
+
+            static GUIStyle ms_ToggleButtonStyleNormal = null;
+            static GUIStyle ms_ToggleButtonStyleToggled = null;
+            static GUIStyle ms_ToggleButtonStyleMixedValue = null;
+
+            void DrawToggleButton()
+            {
+                if (ms_ToggleButtonStyleNormal == null)
+                {
+                    ms_ToggleButtonStyleNormal = new GUIStyle(EditorStyles.miniButton);
+                    ms_ToggleButtonStyleToggled = new GUIStyle(ms_ToggleButtonStyleNormal);
+                    ms_ToggleButtonStyleToggled.normal.background = ms_ToggleButtonStyleToggled.active.background;
+                    ms_ToggleButtonStyleMixedValue = new GUIStyle(ms_ToggleButtonStyleToggled);
+                    ms_ToggleButtonStyleMixedValue.fontStyle = FontStyle.Italic;
+                }
+
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.showMixedValue = m_Property.hasMultipleDifferentValues;
+
+                var style = EditorGUI.showMixedValue ? ms_ToggleButtonStyleMixedValue : (m_Property.boolValue ? ms_ToggleButtonStyleToggled : ms_ToggleButtonStyleNormal);
+                var calcSize = style.CalcSize(m_Content);
+
+            #if UNITY_2019_3_OR_NEWER
+                var defaultColor = GUI.backgroundColor;
+                if(m_Property.boolValue)
+                    GUI.backgroundColor = new Color(0.75f, 0.75f, 0.75f);
+            #endif
+
+                GUILayout.Button(
+                    m_Content,
+                    style,
+                    GUILayout.MaxWidth(calcSize.x));
+
+            #if UNITY_2019_3_OR_NEWER
+                GUI.backgroundColor = defaultColor;
+            #endif
+
+                EditorGUI.showMixedValue = false;
+                if (EditorGUI.EndChangeCheck())
+                    m_Property.boolValue = !m_Property.boolValue;
+            }
+        }
+
+        static ButtonToggleScope ButtonToggleScopeFromLight(SerializedProperty prop, bool visible)
+        {
+            if (!visible) return null;
+
+            return new ButtonToggleScope(prop,
+                true,   // disableGroup
+                EditorData.Instance.contentFromSpotLight);
+        }
+
+        static ButtonToggleScope ButtonToggleScopeAdvanced(SerializedProperty prop, bool visible)
+        {
+            if (!visible) return null;
+
+            return new ButtonToggleScope(prop,
+                false,  // disableGroup
+                EditorStrings.Beam.IntensityModeAdvanced);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+            Debug.Assert(m_Targets.Count > 0);
+
+#if DEBUG_SHOW_CUSTOM_MATERIAL_INFO
+            if (m_Targets.Count == 1)
+            {
+                string msg = "";
+                var geom = m_Targets[0].GetComponentInChildren<BeamGeometry>();
+                if (geom == null)
+                    msg = "No BeamGeometry";
+                else
+                    msg = geom._EDITOR_IsUsingCustomMaterial ? "Custom Material" : "GPU Instanced Shared Material";
+                EditorGUILayout.HelpBox(msg, MessageType.Info);
+            }
+#endif
+
+            VolumetricLightBeam.AttachedLightType lightType;
+            bool hasLightSpot = m_Targets[0].GetLightSpotAttachedSlow(out lightType) != null;
+            if (lightType == VolumetricLightBeam.AttachedLightType.OtherLight)
+            {
+                EditorGUILayout.HelpBox(EditorStrings.Beam.HelpNoSpotlight, MessageType.Warning);
+            }
+
+            if (FoldableHeader.Begin(this, EditorStrings.Beam.HeaderBasic))
+            {
+                // Color
+                using (ButtonToggleScopeFromLight(colorFromLight, hasLightSpot))
+                {
+                    if (!hasLightSpot) EditorGUILayout.BeginHorizontal();    // mandatory to have the color picker on the same line (when the button "from light" is not here)
+                    {
+                        if (Config.Instance.featureEnabledColorGradient == FeatureEnabledColorGradient.Off)
+                        {
+                            EditorGUILayout.PropertyField(color, EditorStrings.Beam.ColorMode);
+                        }
+                        else
+                        {
+                            using (new LabelWidth(65f))
+                            {
+                                EditorGUILayout.PropertyField(colorMode, EditorStrings.Beam.ColorMode);
+                            }
+
+                            if (colorMode.enumValueIndex == (int)ColorMode.Gradient)
+                                EditorGUILayout.PropertyField(colorGradient, EditorStrings.Beam.ColorGradient);
+                            else
+                                EditorGUILayout.PropertyField(color, EditorStrings.Beam.ColorFlat);
+                        }
+                    }
+                    if (!hasLightSpot) EditorGUILayout.EndHorizontal();
+                }
+                
+                // Blending Mode
+                EditorGUILayout.PropertyField(blendingMode, EditorStrings.Beam.BlendingMode);
+
+                EditorGUILayout.Separator();
+
+                // Intensity
+                bool advancedModeEnabled = false;
+                using (ButtonToggleScopeFromLight(intensityFromLight, hasLightSpot))
+                {
+                    bool advancedModeButton = !hasLightSpot || intensityFromLight.HasAtLeastOneValue(false);
+                    using (ButtonToggleScopeAdvanced(intensityModeAdvanced, advancedModeButton))
+                    {
+                        advancedModeEnabled = intensityModeAdvanced.HasAtLeastOneValue(true);
+                        EditorGUILayout.PropertyField(intensityOutside, advancedModeEnabled ? EditorStrings.Beam.IntensityOutside : EditorStrings.Beam.IntensityGlobal);
+                    }
+                }
+
+                if (advancedModeEnabled)
+                    EditorGUILayout.PropertyField(intensityInside, EditorStrings.Beam.IntensityInside);
+                else
+                    intensityInside.floatValue = intensityOutside.floatValue;
+
+                EditorGUILayout.Separator();
+
+                // Spot Angle
+                using (ButtonToggleScopeFromLight(spotAngleFromLight, hasLightSpot))
+                {
+                    EditorGUILayout.PropertyField(spotAngle, EditorStrings.Beam.SpotAngle);
+                }
+
+                PropertyThickness(fresnelPow);
+
+                EditorGUILayout.Separator();
+
+                EditorGUILayout.PropertyField(glareFrontal, EditorStrings.Beam.GlareFrontal);
+                EditorGUILayout.PropertyField(glareBehind, EditorStrings.Beam.GlareBehind);
+
+                EditorGUILayout.Separator();
+
+                if (Config.Instance.featureEnabledShaderAccuracyHigh)
+                {
+                    EditorGUILayout.PropertyField(shaderAccuracy, EditorStrings.Beam.ShaderAccuracy);
+                    EditorGUILayout.Separator();
+                }
+
+                trackChangesDuringPlaytime.ToggleLeft(EditorStrings.Beam.TrackChanges);
+                DrawAnimatorWarning();
+            }
+            FoldableHeader.End();
+            
+            if(FoldableHeader.Begin(this, EditorStrings.Beam.HeaderAttenuation))
+            {
+                EditorGUILayout.BeginHorizontal();
+                {
+                    EditorGUILayout.PropertyField(attenuationEquation, EditorStrings.Beam.AttenuationEquation);
+                    if (attenuationEquation.enumValueIndex == (int)AttenuationEquation.Blend)
+                        EditorGUILayout.PropertyField(attenuationCustomBlending, EditorStrings.Beam.AttenuationCustomBlending);
+                }
+                EditorGUILayout.EndHorizontal();
+
+                // Fade End
+                using (ButtonToggleScopeFromLight(fallOffEndFromLight, hasLightSpot))
+                {
+                    EditorGUILayout.PropertyField(fallOffEnd, EditorStrings.Beam.FallOffEnd);
+                }
+
+                if (fallOffEnd.hasMultipleDifferentValues)
+                    EditorGUILayout.PropertyField(fallOffStart, EditorStrings.Beam.FallOffStart);
+                else
+                    fallOffStart.FloatSlider(EditorStrings.Beam.FallOffStart, 0f, fallOffEnd.floatValue - Consts.Beam.FallOffDistancesMinThreshold);
+
+                EditorGUILayout.Separator();
+
+                // Tilt
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    EditorGUILayout.PropertyField(tiltFactor, EditorStrings.Beam.TiltFactor);
+                    GlobalToggleButton(ref VolumetricLightBeam.editorShowTiltFactor, EditorStrings.Beam.EditorShowTiltDirection, EditorPrefsStrings.Beam.PrefShowTiltDir, 50f);
+                }
+
+                if (m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.isTilted && beam.shaderAccuracy != ShaderAccuracy.High; }))
+                    EditorGUILayout.HelpBox(EditorStrings.Beam.HelpTiltedWithShaderAccuracyFast, MessageType.Warning);
+            }
+            FoldableHeader.End();
+
+            if (Config.Instance.featureEnabledNoise3D)
+            {
+                if (FoldableHeader.Begin(this, EditorStrings.Beam.Header3DNoise))
+                {
+                    noiseMode.CustomEnum<NoiseMode>(EditorStrings.Beam.NoiseMode, EditorStrings.Beam.NoiseModeEnumDescriptions);
+
+                    bool showNoiseProps = m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.isNoiseEnabled; });
+                    if (showNoiseProps)
+                    {
+                        EditorGUILayout.PropertyField(noiseIntensity, EditorStrings.Beam.NoiseIntensity);
+
+                        using (new EditorGUILayout.HorizontalScope())
+                        {
+                            using (new EditorGUI.DisabledGroupScope(noiseScaleUseGlobal.boolValue))
+                            {
+                                EditorGUILayout.PropertyField(noiseScaleLocal, EditorStrings.Beam.NoiseScale);
+                            }
+                            noiseScaleUseGlobal.ToggleUseGlobalNoise();
+                        }
+
+                        using (new EditorGUILayout.HorizontalScope())
+                        {
+                            using (new EditorGUI.DisabledGroupScope(noiseVelocityUseGlobal.boolValue))
+                            {
+                                EditorGUILayout.PropertyField(noiseVelocityLocal, EditorStrings.Beam.NoiseVelocity);
+                            }
+                            noiseVelocityUseGlobal.ToggleUseGlobalNoise();
+                        }
+
+                        if (Noise3D.isSupported && !Noise3D.isProperlyLoaded)
+                            EditorGUILayout.HelpBox(EditorStrings.Common.HelpNoiseLoadingFailed, MessageType.Error);
+
+                        if (!Noise3D.isSupported)
+                            EditorGUILayout.HelpBox(Noise3D.isNotSupportedString, MessageType.Info);
+                    }
+                }
+                FoldableHeader.End();
+            }
+
+            if(FoldableHeader.Begin(this, EditorStrings.Beam.HeaderBlendingDistances))
+            {
+                {
+                    var content = AddEnabledStatusToContentText(EditorStrings.Beam.CameraClippingDistance, cameraClippingDistance);
+                    EditorGUILayout.PropertyField(cameraClippingDistance, content);
+                }
+
+                {
+                    var content = AddEnabledStatusToContentText(EditorStrings.Beam.DepthBlendDistance, depthBlendDistance);
+                    EditorGUILayout.PropertyField(depthBlendDistance, content);
+                }
+            }
+            FoldableHeader.End();
+
+            if(FoldableHeader.Begin(this, EditorStrings.Beam.HeaderGeometry))
+            {
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    EditorGUILayout.PropertyField(coneRadiusStart, EditorStrings.Beam.ConeRadiusStart);
+                    EditorGUI.BeginChangeCheck();
+                    {
+                        geomCap.ToggleLeft(EditorStrings.Beam.GeomCap, GUILayout.MaxWidth(42.0f));
+                    }
+                    if (EditorGUI.EndChangeCheck()) { SetMeshesDirty(); }
+                }
+
+                EditorGUI.BeginChangeCheck();
+                {
+                    EditorGUILayout.PropertyField(geomMeshType, EditorStrings.Beam.GeomMeshType);
+                }
+                if (EditorGUI.EndChangeCheck()) { SetMeshesDirty(); }
+
+                if (geomMeshType.intValue == (int)MeshType.Custom)
+                {
+                    EditorGUI.indentLevel++;
+
+                    EditorGUI.BeginChangeCheck();
+                    {
+                        EditorGUILayout.PropertyField(geomCustomSides, EditorStrings.Beam.GeomSides);
+                        EditorGUILayout.PropertyField(geomCustomSegments, EditorStrings.Beam.GeomSegments);
+                    }
+                    if (EditorGUI.EndChangeCheck()) { SetMeshesDirty(); }
+
+                    if (Config.Instance.featureEnabledMeshSkewing)
+                    {
+                        var vec3 = skewingLocalForwardDirection.vector3Value;
+                        var vec2 = Vector2.zero;
+                        EditorGUI.BeginChangeCheck();
+                        {
+                            vec2 = EditorGUILayout.Vector2Field(EditorStrings.Beam.SkewingLocalForwardDirection, vec3.xy());
+                        }
+                        if (EditorGUI.EndChangeCheck())
+                        {
+                            vec3 = new Vector3(vec2.x, vec2.y, 1.0f);
+                            skewingLocalForwardDirection.vector3Value = vec3;
+                            SetMeshesDirty();
+                        }
+                    }
+
+                    if (m_Targets.Count == 1)
+                    {
+                        EditorGUILayout.HelpBox(m_Targets[0].meshStats, MessageType.Info);
+                    }
+
+                    EditorGUI.indentLevel--;
+                }
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    EditorGUILayout.PropertyField(clippingPlaneTransform, EditorStrings.Beam.ClippingPlane);
+
+                    if (m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.clippingPlaneTransform != null; }))
+                    {
+                        GlobalToggleButton(ref VolumetricLightBeam.editorShowClippingPlane, EditorStrings.Beam.EditorShowClippingPlane, EditorStrings.Beam.PrefShowAddClippingPlane, 50f);
+                    }
+                }
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.Beam.HeaderFadeOut))
+            {
+                bool wasEnabled = fadeOutBegin.floatValue <= fadeOutEnd.floatValue;
+
+                if(m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return (beam.fadeOutBegin <= beam.fadeOutEnd) != wasEnabled; }))
+                {
+                    wasEnabled = true;
+                    EditorGUI.showMixedValue = true;
+                }
+
+                System.Action<float> setFadeOutBegin = value =>
+                {
+                    fadeOutBegin.floatValue = value;
+                    m_Targets.RecordUndoAction("Change Fade Out Begin Distance",
+                        (VolumetricLightBeam beam) => { beam.fadeOutBegin = value; });
+                };
+
+                System.Action<float> setFadeOutEnd = value =>
+                {
+                    fadeOutEnd.floatValue = value;
+                    m_Targets.RecordUndoAction("Change Fade Out End Distance",
+                        (VolumetricLightBeam beam) => { beam.fadeOutEnd = value; });
+                };
+
+                EditorGUI.BeginChangeCheck();
+                bool isEnabled = EditorGUILayout.Toggle(EditorStrings.Beam.FadeOutEnabled, wasEnabled);
+                EditorGUI.showMixedValue = false;
+                if (EditorGUI.EndChangeCheck())
+                {
+                    float invValue = isEnabled ? 1 : -1;
+                    float valueA = Mathf.Abs(fadeOutBegin.floatValue);
+                    float valueB = Mathf.Abs(fadeOutEnd.floatValue);
+                    setFadeOutBegin(invValue * Mathf.Min(valueA, valueB));
+                    setFadeOutEnd  (invValue * Mathf.Max(valueA, valueB));
+                }
+
+                if (isEnabled)
+                {
+                    const float kEpsilon = 0.1f;
+
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        EditorGUI.BeginChangeCheck();
+                        EditorGUILayout.PropertyField(fadeOutBegin, EditorStrings.Beam.FadeOutBegin);
+                        if (EditorGUI.EndChangeCheck())
+                        {
+                            setFadeOutBegin(Mathf.Clamp(fadeOutBegin.floatValue, 0, fadeOutEnd.floatValue - kEpsilon));
+                        }
+
+                        using (new LabelWidth(30f))
+                        {
+                            EditorGUI.BeginChangeCheck();
+                            EditorGUILayout.PropertyField(fadeOutEnd, EditorStrings.Beam.FadeOutEnd);
+                            if (EditorGUI.EndChangeCheck())
+                            {
+                                setFadeOutEnd(Mathf.Max(fadeOutBegin.floatValue + kEpsilon, fadeOutEnd.floatValue));
+                            }
+                        }
+                    }
+                    if (Application.isPlaying)
+                    {
+                        if(Config.Instance.fadeOutCameraTransform == null)
+                        {
+                            EditorGUILayout.HelpBox(EditorStrings.Beam.HelpFadeOutNoMainCamera, MessageType.Error);
+                        }
+                    }
+                }
+            }
+            FoldableHeader.End();
+
+            if (FoldableHeader.Begin(this, EditorStrings.Beam.Header2D))
+            {
+                dimensions.CustomEnum<Dimensions>(EditorStrings.Beam.Dimensions, EditorStrings.Common.DimensionsEnumDescriptions);
+                DrawSortingLayerAndOrder();
+            }
+            FoldableHeader.End();
+
+            DrawInfos();
+            DrawEditInSceneButton();
+            DrawCustomActionButtons();
+            DrawAdditionalFeatures();
+            
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        GUIContent AddEnabledStatusToContentText(GUIContent inContent, SerializedProperty prop)
+        {
+            Debug.Assert(prop.propertyType == SerializedPropertyType.Float);
+
+            var content = new GUIContent(inContent);
+            if (prop.hasMultipleDifferentValues)
+                content.text += " (-)";
+            else
+                content.text += prop.floatValue > 0.0 ? " (on)" : " (off)";
+            return content;
+        }
+
+        void SetMeshesDirty()
+        {
+            foreach (var entity in m_Targets) entity._EditorSetMeshDirty();
+        }
+
+        void DrawSortingLayerAndOrder()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.showMixedValue = sortingLayerID.hasMultipleDifferentValues;
+                int layerIndex = System.Array.IndexOf(m_SortingLayerNames, SortingLayer.IDToName(sortingLayerID.intValue));
+                layerIndex = EditorGUILayout.Popup(EditorStrings.Beam.SortingLayer, layerIndex, m_SortingLayerNames);
+                EditorGUI.showMixedValue = false;
+                if (EditorGUI.EndChangeCheck())
+                {
+                    sortingLayerID.intValue = SortingLayer.NameToID(m_SortingLayerNames[layerIndex]);
+
+                    m_Targets.RecordUndoAction("Edit Sorting Layer",
+                        (VolumetricLightBeam beam) => beam.sortingLayerID = sortingLayerID.intValue); // call setters
+                }
+
+                using (new LabelWidth(40f))
+                {
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.PropertyField(sortingOrder, EditorStrings.Beam.SortingOrder, GUILayout.MaxWidth(90f));
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_Targets.RecordUndoAction("Edit Sorting Order",
+                            (VolumetricLightBeam beam) => beam.sortingOrder = sortingOrder.intValue); // call setters
+                    }
+                }
+            }
+        }
+
+        void DrawAnimatorWarning()
+        {
+            var showAnimatorWarning = m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.GetComponent<Animator>() != null && beam.trackChangesDuringPlaytime == false; });
+
+            if (showAnimatorWarning)
+                EditorGUILayout.HelpBox(EditorStrings.Beam.HelpAnimatorWarning, MessageType.Warning);
+        }
+
+        void DrawEditInSceneButton()
+        {
+            EditorGUI.BeginChangeCheck();
+            bool editInScene = EditorPrefs.GetBool(EditorStrings.Beam.PrefEditInScene, false);
+            editInScene = GUILayout.Toggle(editInScene, EditorStrings.Beam.ButtonEditInScene, EditorStyles.miniButton);
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorPrefs.SetBool(EditorStrings.Beam.PrefEditInScene, editInScene);
+                SceneView.RepaintAll();
+            }
+        }
+
+        void DrawCustomActionButtons()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                if (GUILayout.Button(EditorStrings.Beam.ButtonResetProperties, EditorStyles.miniButton))
+                {
+                    m_Targets.RecordUndoAction("Reset Light Beam Properties",
+                        (VolumetricLightBeam beam) => { beam.Reset(); beam.GenerateGeometry(); } );
+                }
+
+                if(m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.geomMeshType == MeshType.Custom; }))
+                {
+                    if (GUILayout.Button(EditorStrings.Beam.ButtonGenerateGeometry, EditorStyles.miniButton))
+                    {
+                        foreach (var entity in m_Targets) entity.GenerateGeometry();
+                    }
+                }
+            }
+        }
+
+        void AddComponentToTargets<T>() where T : MonoBehaviour
+        {
+            foreach (var target in m_Targets) EditorExtensions.AddComponentFromEditor<T>(target);
+        }
+
+        void DrawAdditionalFeatures()
+        {
+            if (Application.isPlaying) return; // do not support adding additional components at runtime
+
+            bool showButtonDust         = m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.GetComponent<VolumetricDustParticles>() == null; });
+            bool showButtonOcclusion    = Config.Instance.featureEnabledDynamicOcclusion && m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.GetComponent<DynamicOcclusionAbstractBase>() == null; });
+            bool showButtonTriggerZone  = m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.GetComponent<TriggerZone>() == null; });
+            bool showButtonEffect       = m_Targets.HasAtLeastOneTargetWith((VolumetricLightBeam beam) => { return beam.GetComponent<EffectAbstractBase>() == null; });
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUIStyle kStyle = GUI.skin.button;
+
+                if (showButtonDust && GUILayout.Button(EditorData.Instance.contentAddDustParticles, kStyle))
+                    AddComponentToTargets<VolumetricDustParticles>();
+
+                if (showButtonOcclusion && GUILayout.Button(EditorData.Instance.contentAddDynamicOcclusion, kStyle))
+                {
+                    var menu = new GenericMenu();
+                    menu.AddItem(new GUIContent(EditorStrings.Beam.ButtonAddDynamicOcclusionRaycasting),  false, AddComponentToTargets<DynamicOcclusionRaycasting>);
+                    menu.AddItem(new GUIContent(EditorStrings.Beam.ButtonAddDynamicOcclusionDepthBuffer), false, AddComponentToTargets<DynamicOcclusionDepthBuffer>);
+                    menu.ShowAsContext();
+                }
+
+                if (showButtonEffect && GUILayout.Button(EditorData.Instance.contentAddEffect, kStyle))
+                {
+                    var menu = new GenericMenu();
+                    menu.AddItem(new GUIContent(EditorStrings.Beam.ButtonAddEffectFlicker), false, AddComponentToTargets<EffectFlicker>);
+                    menu.AddItem(new GUIContent(EditorStrings.Beam.ButtonAddEffectPulse),   false, AddComponentToTargets<EffectPulse>);
+                    menu.ShowAsContext();
+                }
+
+                if (showButtonTriggerZone && GUILayout.Button(EditorData.Instance.contentAddTriggerZone, kStyle))
+                    AddComponentToTargets<TriggerZone>();
+            }
+        }
+
+        struct InfoTip
+        {
+            public MessageType type;
+            public string message;
+        }
+
+        bool DrawInfos()
+        {
+            var tips = GetInfoTips();
+            var gpuInstancingReport = GetBatchingReport();
+
+            if (tips.Count > 0 || !string.IsNullOrEmpty(gpuInstancingReport))
+            {
+                if (FoldableHeader.Begin(this, EditorStrings.Beam.HeaderInfos))
+                {
+                    foreach (var tip in tips)
+                        EditorGUILayout.HelpBox(tip.message, tip.type);
+
+                    if (!string.IsNullOrEmpty(gpuInstancingReport))
+                        EditorGUILayout.HelpBox(gpuInstancingReport, MessageType.Warning);
+                }
+                FoldableHeader.End();
+                return true;
+            }
+            return false;
+        }
+
+        List<InfoTip> GetInfoTips()
+        {
+            var tips = new List<InfoTip>();
+            if (m_Targets.Count == 1)
+            {
+                if (depthBlendDistance.floatValue > 0f || !Noise3D.isSupported || trackChangesDuringPlaytime.boolValue)
+                {
+                    if (depthBlendDistance.floatValue > 0f)
+                    {
+                        tips.Add(new InfoTip { type = MessageType.Info, message = EditorStrings.Beam.HelpDepthTextureMode });
+#if UNITY_IPHONE || UNITY_IOS || UNITY_ANDROID
+                        tips.Add(new InfoTip { type = MessageType.Info, message = EditorStrings.Beam.HelpDepthMobile });
+#endif
+                    }
+
+                    if (trackChangesDuringPlaytime.boolValue)
+                        tips.Add(new InfoTip { type = MessageType.Info, message = EditorStrings.Beam.HelpTrackChangesEnabled });
+                }
+            }
+            return tips;
+        }
+
+        string GetBatchingReport()
+        {
+            if (m_Targets.Count > 1)
+            {
+                string reasons = "";
+                for (int i = 1; i < m_Targets.Count; ++i)
+                {
+                    if (!BatchingHelper.CanBeBatched(m_Targets[0], m_Targets[i], ref reasons))
+                    {
+                        return "Selected beams can't be batched together:\n" + reasons;
+                    }
+                }
+            }
+            return null;
+        }
+
+        void DrawFallOffSliderHandle(VolumetricLightBeam beam, float lineStartOffset, float lineAlpha, Handles.CapFunction capFunction, string recordName, ref float value)
+        {
+            Debug.Assert(beam != null);
+
+            var fwd = beam.beamGlobalForward;
+
+            EditorGUI.BeginChangeCheck();
+            var sliderPos = beam.transform.position + fwd * value;
+            sliderPos = Handles.Slider(sliderPos, fwd, HandleUtility.GetHandleSize(sliderPos) * 0.1f, capFunction, 0.5f);
+
+            var savedCol = Handles.color;
+            {
+                var col = savedCol;
+                col.a = lineAlpha;
+                Handles.color = col;
+                Handles.DrawLine(beam.transform.position + fwd * lineStartOffset, sliderPos);
+                Handles.color = savedCol;
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(target, string.Format("Edit Beam '{0}'", recordName));
+
+                var sliderVec = (sliderPos - beam.transform.position);
+                var sliderLength = 0.0f;
+                if (Vector3.Dot(sliderVec, fwd) > 0.0f)
+                    sliderLength = sliderVec.magnitude;
+
+                value = sliderLength;
+                beam.UpdateAfterManualPropertyChange();
+            }
+        }
+
+        void DrawRadiusHandle(VolumetricLightBeam beam, Vector3 pos, string recordName, float value, System.Action<float> setValue)
+        {
+            Debug.Assert(beam != null);
+
+            var handleMatrix = Matrix4x4.TRS(
+                pos,
+                Quaternion.LookRotation(beam.transform.up, beam.beamGlobalForward) * Quaternion.Euler(0.0f, 45.0f, 0.0f), // rotate the circle handle to have both this and the Unity's light handle
+                Vector3.one);
+
+            using (new Handles.DrawingScope(handleMatrix))
+            {
+                var hdl = handleRadius;
+                EditorGUI.BeginChangeCheck();
+                hdl.radius = value;
+                hdl.DrawHandle();
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Undo.RecordObject(beam, string.Format("Edit Beam '{0}'", recordName));
+                    setValue(hdl.radius);
+                    beam.UpdateAfterManualPropertyChange();
+                }
+            }
+        }
+
+        protected virtual void OnSceneGUI()
+        {
+            bool editInScene = EditorPrefs.GetBool(EditorStrings.Beam.PrefEditInScene, false);
+            if (!editInScene)
+                return;
+
+            var beam = target as VolumetricLightBeam;
+            Debug.Assert(beam != null);
+
+            Handles.color = beam.ComputeColorAtDepth(0.0f).ComputeComplementaryColor(true);
+            {
+                DrawRadiusHandle(beam, beam.transform.position, "Truncated Radius", beam.coneRadiusStart, (float v) => beam.coneRadiusStart = v);
+            }
+
+            if (!beam.hasMeshSkewing)
+            {
+                Handles.color = beam.ComputeColorAtDepth(beam.fallOffStart / beam.fallOffEnd).ComputeComplementaryColor(true);
+                {
+                    DrawFallOffSliderHandle(beam, 0.0f, 1.0f, Handles.CylinderHandleCap, "Start Distance", ref beam.fallOffStart);
+                }
+
+                Handles.color = beam.ComputeColorAtDepth(1.0f).ComputeComplementaryColor(true);
+                {
+                    VolumetricLightBeam.AttachedLightType lightType;
+                    var hasSpotLight = beam.GetLightSpotAttachedSlow(out lightType) != null;
+
+                    if (!hasSpotLight || !beam.fallOffEndFromLight)
+                    {
+                        DrawFallOffSliderHandle(beam, beam.fallOffStart, 0.5f, Handles.CubeHandleCap, "Range Limit", ref beam.fallOffEnd);
+                    }
+
+                    if (!hasSpotLight || !beam.spotAngleFromLight)
+                    {
+                        var fallOffEndPos = beam.transform.localToWorldMatrix.MultiplyPoint(beam.beamLocalForward * beam.fallOffEnd);
+                        DrawRadiusHandle(beam, fallOffEndPos, "Spot Angle", beam.coneRadiusEnd, (float v) => beam.coneRadiusEnd = v);
+                    }
+                }
+            }
+        }
+    }
+}
+#endif

Assets/Plugins/VolumetricLightBeam/Editor/VolumetricLightBeamEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2bd45af80c148e249bd23ff7970f6181
+timeCreated: 1504689328
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Readme.txt

@@ -0,0 +1,20 @@
+Hi and thank you for using the Volumetric Light Beam plugin for Unity!
+You can find here some resources to help your first steps.
+
+*******************
+** Documentation **
+*******************
+Please visit: http://saladgamer.com/vlb-doc/
+
+**************************
+** Configure the plugin **
+**************************
+- For the Built-in Render Pipeline: nothing to do!
+- For the Universal Render Pipeline (URP): http://saladgamer.com/vlb-doc/render-pipelines/#universal-render-pipeline-urp
+- For the High Definition Render Pipeline (HDRP): http://saladgamer.com/vlb-doc/render-pipelines/#high-definition-render-pipeline-hdrp
+
+And that's it! You can start to create new volumetric lights!
+
+Thank you very much, and do not hesitate to contact the team for any questions or suggestions: techsaladunity@gmail.com
+
+Cheers!

Assets/Plugins/VolumetricLightBeam/Readme.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fab8da82f79796e4ba84aae4e9a3133a
+timeCreated: 1504866837
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4b1378abda8ff96459042374d10440a6
+folderAsset: yes
+timeCreated: 1504539305
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources/DustParticles.mat

@@ -0,0 +1,34 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: DustParticles
+  m_Shader: {fileID: 203, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_CustomRenderQueue: 3000
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 2800000, guid: 365cef3e061d6364697f7ace5046c93e, type: 3}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _InvFade
+        second: 1
+    m_Colors:
+      data:
+        first:
+          name: _TintColor
+        second: {r: 1, g: 1, b: 1, a: 1}

Assets/Plugins/VolumetricLightBeam/Resources/DustParticles.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8d20a6834f5625e4eba5372d38bf7e99
+timeCreated: 1510679888
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources/DustParticles.prefab.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 472bc216b0f362147943a3cedc36711f
+timeCreated: 1510760761
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources/DustParticles.psd.meta

@@ -0,0 +1,56 @@
+fileFormatVersion: 2
+guid: 365cef3e061d6364697f7ace5046c93e
+timeCreated: 1510679738
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 8
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 32
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: .5, y: .5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: -1
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources/Noise3D_64x64x64.asset.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: e4c4c1cbfaa63db45b17891f8f2caf6d
+timeCreated: 1619169302
+licenseType: Store
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11700000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources/VLBDitheringNoise.png.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 52f46dcaae8132a4090a9a8d14ece711
+timeCreated: 1599686876
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Resources/VLBEditorData.asset

@@ -0,0 +1,21 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f87284b87b8be7c4b9708f25ddb6669b, type: 3}
+  m_Name: VLBEditorData
+  m_EditorClassIdentifier: 
+  buttonAddDustParticles: {fileID: 2800000, guid: eae0c95c9c12c4e40a87d028b6e5aaad,
+    type: 3}
+  buttonAddDynamicOcclusion: {fileID: 2800000, guid: c0b232bfb34a77a4a84fdc476cfedea4,
+    type: 3}
+  buttonAddTriggerZone: {fileID: 2800000, guid: 3fcfb96a95b4b82439ae47f4f060137c,
+    type: 3}
+  buttonAddEffect: {fileID: 2800000, guid: 1a5ba5df396106d4cafd5a96415ffb6c, type: 3}
+  buttonFromSpotLight: {fileID: 2800000, guid: 350d4bb70b7205342aefcb03e66a7dcb, type: 3}

Assets/Plugins/VolumetricLightBeam/Resources/VLBEditorData.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8979130d593fc654f8d175cfe9729e82
+timeCreated: 1617863368
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 669ee18ab3eab354ab18af8cb4889466
+folderAsset: yes
+timeCreated: 1504767154
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3e67e58060c57924398e7c67ebb5582f
+folderAsset: yes
+timeCreated: 1509878135
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimAngleAndColor.anim

@@ -0,0 +1,309 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!74 &7400000
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimAngleAndColor
+  serializedVersion: 6
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_PositionCurves: []
+  m_ScaleCurves: []
+  m_FloatCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 90
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: spotAngle
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: -1
+        outSlope: -1
+        tangentMode: 10
+      - time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 1
+        outSlope: 1
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.r
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: .972413778
+        inSlope: .0275862217
+        outSlope: .0275862217
+        tangentMode: 10
+      - time: 1
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: .972413778
+        inSlope: -.0275862217
+        outSlope: -.0275862217
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.g
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 0
+        inSlope: .958620548
+        outSlope: .958620548
+        tangentMode: 10
+      - time: 1
+        value: .958620548
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 0
+        inSlope: -.958620548
+        outSlope: -.958620548
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.b
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.a
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings:
+    - path: 0
+      attribute: 1767412965
+      script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+      classID: 114
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 57601170
+      script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+      classID: 114
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 1857226873
+      script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+      classID: 114
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 517602550
+      script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+      classID: 114
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 2278600012
+      script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+      classID: 114
+      customType: 0
+      isPPtrCurve: 0
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_StartTime: 0
+    m_StopTime: 2
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_LoopTime: 1
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 90
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: spotAngle
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: -1
+        outSlope: -1
+        tangentMode: 10
+      - time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 1
+        outSlope: 1
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.r
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: .972413778
+        inSlope: .0275862217
+        outSlope: .0275862217
+        tangentMode: 10
+      - time: 1
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: .972413778
+        inSlope: -.0275862217
+        outSlope: -.0275862217
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.g
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 0
+        inSlope: .958620548
+        outSlope: .958620548
+        tangentMode: 10
+      - time: 1
+        value: .958620548
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 0
+        inSlope: -.958620548
+        outSlope: -.958620548
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.b
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: color.a
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  m_EulerEditorCurves: []
+  m_HasGenericRootTransform: 0
+  m_HasMotionFloatCurves: 0
+  m_GenerateMotionCurves: 0
+  m_Events: []

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimAngleAndColor.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2da70c68670fd4a4eb423ef705ba51ab
+timeCreated: 1509868687
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimAngleAndColor.controller

@@ -0,0 +1,67 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimAngleAndColor
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 110772430}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &110204976
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: New Animation
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 2da70c68670fd4a4eb423ef705ba51ab, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+--- !u!1107 &110772430
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 110204976}
+    m_Position: {x: 144, y: 24, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: -72, y: -60, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 110204976}

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimAngleAndColor.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c55990406d8ba4149b299c7f48f819fd
+timeCreated: 1509868687
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimFadingDistances.anim

@@ -0,0 +1,116 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!74 &7400000
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimFadingDistances
+  serializedVersion: 6
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_EulerCurves: []
+  m_PositionCurves: []
+  m_ScaleCurves: []
+  m_FloatCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 2
+        time: 0
+        value: 6
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+      - serializedVersion: 2
+        time: 1
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+      - serializedVersion: 2
+        time: 2
+        value: 6
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: fallOffEnd
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings:
+    - path: 0
+      attribute: 2398626827
+      script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+      classID: 114
+      customType: 0
+      isPPtrCurve: 0
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_AdditiveReferencePoseClip: {fileID: 0}
+    m_AdditiveReferencePoseTime: 0
+    m_StartTime: 0
+    m_StopTime: 2
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_HasAdditiveReferencePose: 0
+    m_LoopTime: 1
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 2
+        time: 0
+        value: 6
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+      - serializedVersion: 2
+        time: 1
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+      - serializedVersion: 2
+        time: 2
+        value: 6
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: fallOffEnd
+    path: 
+    classID: 114
+    script: {fileID: 11500000, guid: 7b69c542c9a8f4f44a3123e3fa103d13, type: 3}
+  m_EulerEditorCurves: []
+  m_HasGenericRootTransform: 0
+  m_HasMotionFloatCurves: 0
+  m_GenerateMotionCurves: 0
+  m_IsEmpty: 0
+  m_Events: []

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimFadingDistances.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7ecd9944b6be1bd4786c90076c64b534
+timeCreated: 1509878761
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimFadingDistances.controller

@@ -0,0 +1,67 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimFadingDistances
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 110731564}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &110292738
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimFadingDistances
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 7ecd9944b6be1bd4786c90076c64b534, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+--- !u!1107 &110731564
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 110292738}
+    m_Position: {x: 200, y: 0, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 110292738}

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimFadingDistances.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 040292e6fd2a7b149a7c000103e8632d
+timeCreated: 1509878761
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimLightProperties.anim

@@ -0,0 +1,309 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!74 &7400000
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimLightProperties
+  serializedVersion: 6
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_PositionCurves: []
+  m_ScaleCurves: []
+  m_FloatCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 1
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.r
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.g
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.b
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.a
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 80
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_SpotAngle
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings:
+    - path: 0
+      attribute: 4215373228
+      script: {fileID: 0}
+      classID: 108
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 2334886179
+      script: {fileID: 0}
+      classID: 108
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 3044587006
+      script: {fileID: 0}
+      classID: 108
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 2526845255
+      script: {fileID: 0}
+      classID: 108
+      customType: 0
+      isPPtrCurve: 0
+    - path: 0
+      attribute: 304273561
+      script: {fileID: 0}
+      classID: 108
+      customType: 0
+      isPPtrCurve: 0
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_StartTime: 0
+    m_StopTime: 2
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_LoopTime: 1
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 1
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.r
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.g
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.b
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 2
+        value: 1
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_Color.a
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - time: 0
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      - time: 1
+        value: 80
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 10
+      - time: 2
+        value: 30
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 0
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+    attribute: m_SpotAngle
+    path: 
+    classID: 108
+    script: {fileID: 0}
+  m_EulerEditorCurves: []
+  m_HasGenericRootTransform: 0
+  m_HasMotionFloatCurves: 0
+  m_GenerateMotionCurves: 0
+  m_Events: []

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimLightProperties.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: db19a367419a6b3429ffd7cb7d5c2f89
+timeCreated: 1509879186
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimLightProperties.controller

@@ -0,0 +1,67 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimLightProperties
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 110714998}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &110227352
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: AnimLight
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: db19a367419a6b3429ffd7cb7d5c2f89, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+--- !u!1107 &110714998
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 110227352}
+    m_Position: {x: 200, y: 0, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 110227352}

Assets/Plugins/VolumetricLightBeam/Samples/Animations/AnimLightProperties.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 25d91ec95cd77c247a608d0dbaac623f
+timeCreated: 1509879186
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Materials.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 887248689287add4c871624a2319dd58
+folderAsset: yes
+timeCreated: 1504767176
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Materials/checkIfInsideBeam.mat

@@ -0,0 +1,138 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: checkIfInsideBeam
+  m_Shader: {fileID: 10755, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _BumpMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailNormalMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _ParallaxMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _OcclusionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _EmissionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailMask
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailAlbedoMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _MetallicGlossMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _SrcBlend
+        second: 1
+      data:
+        first:
+          name: _DstBlend
+        second: 0
+      data:
+        first:
+          name: _Cutoff
+        second: .5
+      data:
+        first:
+          name: _Parallax
+        second: .0199999996
+      data:
+        first:
+          name: _ZWrite
+        second: 1
+      data:
+        first:
+          name: _Glossiness
+        second: .5
+      data:
+        first:
+          name: _BumpScale
+        second: 1
+      data:
+        first:
+          name: _OcclusionStrength
+        second: 1
+      data:
+        first:
+          name: _DetailNormalMapScale
+        second: 1
+      data:
+        first:
+          name: _UVSec
+        second: 0
+      data:
+        first:
+          name: _Mode
+        second: 0
+      data:
+        first:
+          name: _Metallic
+        second: .5
+    m_Colors:
+      data:
+        first:
+          name: _EmissionColor
+        second: {r: 0, g: 0, b: 0, a: 1}
+      data:
+        first:
+          name: _Color
+        second: {r: 1, g: 1, b: 1, a: 1}

Assets/Plugins/VolumetricLightBeam/Samples/Materials/checkIfInsideBeam.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 863df4913247ae3499994d7e90827a32
+timeCreated: 1531568652
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VolumetricLightBeam/Samples/Materials/geometry_hdrp.mat

@@ -0,0 +1,243 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: geometry_hdrp
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 0
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 0
+    - _DistortionDepthTest: 1
+    - _DistortionDstBlend: 0
+    - _DistortionEnable: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 0
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HdrpVersion: 2
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _Ior: 1
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _ReceivesSSR: 1
+    - _RefractionModel: 0
+    - _SSRefractionProjectionModel: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 0.5
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _StencilRefDepth: 0
+    - _StencilRefGBuffer: 2
+    - _StencilRefMV: 128
+    - _StencilWriteMask: 3
+    - _StencilWriteMaskDepth: 32
+    - _StencilWriteMaskGBuffer: 3
+    - _StencilWriteMaskMV: 128
+    - _Stiffness: 1
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessMultiplier: 1
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingVelocity: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 4
+    - _ZTestGBuffer: 4
+    - _ZTestModeDistortion: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

Assets/Plugins/VolumetricLightBeam/Samples/Materials/geometry_hdrp.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3cd8e1320c011904b8e4fbcb14859857
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: