Merge pull request #45 from murasaqi/dev

murasaqi · web-flow · commit fba5f5f4a6cd · 2025-02-22T21:50:52.000+09:00
Dev
diff --git a/jp.iridescenet.stagelightmaneuver/Editor/CustomEditor/StageLightTimelineClipEditor.cs b/jp.iridescenet.stagelightmaneuver/Editor/CustomEditor/StageLightTimelineClipEditor.cs
@@ -86,6 +86,7 @@ public override void DrawBackground(TimelineClip clip, ClipBackgroundRegion regi
             var stageLightTimelineClip = (StageLightTimelineClip) clip.asset;
 
 
+            if(stageLightTimelineClip.track == null) return;
 
             if (stageLightTimelineClip.clipDisplayName != clip.displayName)
             {
@@ -240,7 +241,7 @@ Texture2D GetGradientTexture(TimelineClip clip, bool update = false)
             }
            
 
-            var lightIntensityProperty = customClip.StageLightQueueData.TryGetActiveProperty<LightIntensityProperty>();
+            var lightDimmerProperty = customClip.StageLightQueueData.TryGetActiveProperty<LightIntensityProperty>();
             if (update) 
             {
                 _gradientTextures.Remove(customClip);
@@ -277,10 +278,10 @@ Texture2D GetGradientTexture(TimelineClip clip, bool update = false)
                     }
 
                     var intensityValue = 1f;
-                    if (lightIntensityProperty != null)
+                    if (lightDimmerProperty != null)
                     {
-                        var t = SlmUtility.GetNormalizedTime(currentTime, timeProperty, lightIntensityProperty);
-                        intensityValue = lightIntensityProperty.lightToggleIntensity.value.Evaluate(t);
+                        var t = SlmUtility.GetNormalizedTime(currentTime, timeProperty, lightDimmerProperty);
+                        intensityValue = lightDimmerProperty.lightToggleDimmer.value.Evaluate(t);
                         // intensityValue = intensityValue
                     }
                     else if(materialColorProperty != null)
diff --git a/jp.iridescenet.stagelightmaneuver/Editor/PropertyDrawer/StageLightPropertiesDrawer.cs b/jp.iridescenet.stagelightmaneuver/Editor/PropertyDrawer/StageLightPropertiesDrawer.cs
@@ -152,16 +152,16 @@ private void DrawAddPropertyButton(SerializedObject serializedObject, List<SlmPr
                 {
                     var manualLightArrayProperty = property as ManualLightArrayProperty;
                     var lightProperty = stageLightProperties.Find(x => x.GetType() == typeof(LightProperty)) as LightProperty;
-                    var lightIntensityProperty = stageLightProperties.Find(x => x.GetType() == typeof(LightIntensityProperty)) as LightIntensityProperty;
+                    var lightDimmerProperty = stageLightProperties.Find(x => x.GetType() == typeof(LightIntensityProperty)) as LightIntensityProperty;
                     if (lightProperty != null)
                     {
                         manualLightArrayProperty.initialValue.angle = lightProperty.spotAngle.value.constant;
                         manualLightArrayProperty.initialValue.innerAngle = lightProperty.innerSpotAngle.value.constant;
                         manualLightArrayProperty.initialValue.range = lightProperty.range.value.constant;
                     }
-                    if (lightIntensityProperty != null)
+                    if (lightDimmerProperty != null)
                     {
-                        manualLightArrayProperty.initialValue.intensity = lightIntensityProperty.lightToggleIntensity.value.constant;
+                        manualLightArrayProperty.initialValue.intensity = lightDimmerProperty.lightToggleDimmer.value.constant;
                     }
                 }
                 stageLightProperties.Add(property);
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Channels/LightChannel.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Channels/LightChannel.cs
@@ -47,6 +47,7 @@ public enum FallOffMode
 
 
 #region Configs
+        [ChannelField(true)] public float intensityMultiplier = 1f;
         [ChannelField(true)] public float limitIntensityMin = 0f;
         [ChannelField(true)] public float limitIntensityMax = 10000f;
         [ChannelField(true)] public float limitInnerSpotAngleMin = 0f;
@@ -138,7 +139,7 @@ public override void EvaluateQue(float currentTime)
                 var clockProperty= data.TryGetActiveProperty<ClockProperty>() as ClockProperty;
                 var lightProperty = data.TryGetActiveProperty<LightProperty>() as LightProperty;
                 var lightColorProperty = data.TryGetActiveProperty<LightColorProperty>() as LightColorProperty;
-                var lightIntensityProperty = data.TryGetActiveProperty<LightIntensityProperty>() as LightIntensityProperty;
+                var lightDimmerProperty = data.TryGetActiveProperty<LightIntensityProperty>() as LightIntensityProperty;
                 var lightFlickerProperty = data.TryGetActiveProperty<LightFlickerProperty>() as LightFlickerProperty;
                 var weight = data.weight;
                 var stageLightOrderProperty = data.TryGetActiveProperty<StageLightOrderProperty>() as StageLightOrderProperty;
@@ -163,10 +164,10 @@ public override void EvaluateQue(float currentTime)
                 }
                 else
                 {
-                    if (lightIntensityProperty != null)
+                    if (lightDimmerProperty != null)
                     {
                         var t = SlmUtility.GetNormalizedTime(currentTime, data, typeof(LightIntensityProperty),index);
-                        lightIntensity += lightIntensityProperty.lightToggleIntensity.value.Evaluate(t) * weight;
+                        lightIntensity += lightDimmerProperty.lightToggleDimmer.value.Evaluate(t) * weight;
                     }
                     if(lightFlickerProperty != null)
                     {
@@ -209,7 +210,7 @@ public override void EvaluateQue(float currentTime)
                 }
             }
             
-            lightIntensity = Mathf.Clamp(lightIntensity, limitIntensityMin, limitIntensityMax);
+            lightIntensity = Mathf.Clamp(lightIntensity, limitIntensityMin, limitIntensityMax) * intensityMultiplier;
             spotAngle = Mathf.Clamp(spotAngle, limitSpotAngleMin, limitSpotAngleMax);
             innerSpotAngle = Mathf.Clamp(innerSpotAngle, limitInnerSpotAngleMin, limitInnerSpotAngleMax);
             spotRange = Mathf.Clamp(spotRange, limitSpotRangeMin, limitSpotRangeMax);
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Channels/MaterialColorChannel.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Channels/MaterialColorChannel.cs
@@ -30,6 +30,8 @@ public class MaterialColorChannel:StageLightChannelBase
         [ChannelField(false)] private int propertyId;
 #endregion
 
+        private List<Material> sharedMaterials = new();
+
 
         void Start()
         {
@@ -49,18 +51,22 @@ public void GetMeshRenderer()
 
         public override void Init()
         {
-            
-            _materialPropertyBlock = new MaterialPropertyBlock();
+            _materialPropertyBlock ??= new MaterialPropertyBlock();
             if(meshRenderer)meshRenderer.GetPropertyBlock(_materialPropertyBlock);
-            _materialPropertyBlocks = new Dictionary<Renderer, MaterialPropertyBlock>();
+
+            _materialPropertyBlocks ??= new Dictionary<Renderer, MaterialPropertyBlock>();
+            _materialPropertyBlocks.Clear();
+
             foreach (var meshRenderer in syncMeshRenderers)
             {
-                if(meshRenderer == null) continue;
+                if(meshRenderer == null || (_materialPropertyBlocks.TryGetValue(meshRenderer, out var prop) && prop != null)) continue;
                 var materialPropertyBlock = new MaterialPropertyBlock();
                 meshRenderer.GetPropertyBlock(materialPropertyBlock);
-                _materialPropertyBlocks.Add(meshRenderer,materialPropertyBlock);
+
+                _materialPropertyBlocks.Add(meshRenderer, materialPropertyBlock);
             }
             
+            PropertyTypes.Clear();
             PropertyTypes.Add(typeof(MaterialColorProperty));
         }
 
@@ -105,15 +111,17 @@ public override void EvaluateQue(float currentTime)
 
         public override void UpdateChannel()
         {
-            if (_materialPropertyBlock == null || _materialPropertyBlocks == null) return;
+            if (_materialPropertyBlock == null || _materialPropertyBlocks == null)
             {
                 Init();
             }
-            if(_materialPropertyBlock ==null) return;
+
+            if(_materialPropertyBlock == null) return;
 
             if (meshRenderer)
             {
-                if(meshRenderer.sharedMaterials.Length <= materialIndex) return;
+                meshRenderer.GetSharedMaterials(sharedMaterials);
+                if(sharedMaterials.Count <= materialIndex) return;
                 meshRenderer.GetPropertyBlock(_materialPropertyBlock,materialIndex);
                 _materialPropertyBlock.SetColor(colorPropertyName,SlmUtility.GetHDRColor(color,intensity));
                 meshRenderer.SetPropertyBlock(_materialPropertyBlock,materialIndex);
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Channels/MaterialFloatChannel.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Channels/MaterialFloatChannel.cs
@@ -24,6 +24,9 @@ public class MaterialFloatChannel:StageLightChannelBase
         [ChannelField(false)] private Dictionary<Renderer,MaterialPropertyBlock> _materialPropertyBlocks = null;
         [ChannelField(false)] private int propertyId;
 #endregion
+
+        private List<Material> sharedMaterials = new();
+
         
         void Start()
         {
@@ -43,19 +46,23 @@ public void GetMeshRenderer()
         
         public override void Init()
         {
-            
-            _materialPropertyBlock = new MaterialPropertyBlock();
+            _materialPropertyBlock ??= new MaterialPropertyBlock();
             if(meshRenderer)meshRenderer.GetPropertyBlock(_materialPropertyBlock);
-            _materialPropertyBlocks = new Dictionary<Renderer, MaterialPropertyBlock>();
+
+            _materialPropertyBlocks ??= new Dictionary<Renderer, MaterialPropertyBlock>();
+            _materialPropertyBlocks.Clear();
+
             foreach (var meshRenderer in syncMeshRenderers)
             {
-                if(meshRenderer == null) continue;
+                if(meshRenderer == null || (_materialPropertyBlocks.TryGetValue(meshRenderer, out var prop) && prop != null)) continue;
                 var materialPropertyBlock = new MaterialPropertyBlock();
                 meshRenderer.GetPropertyBlock(materialPropertyBlock);
-                _materialPropertyBlocks.Add(meshRenderer,materialPropertyBlock);
+
+                _materialPropertyBlocks.Add(meshRenderer, materialPropertyBlock);
             }
             
-            PropertyTypes.Add(typeof(MaterialFloatProperty));
+            PropertyTypes.Clear();
+            PropertyTypes.Add(typeof(MaterialColorProperty));
         }
         
         private void OnValidate()
@@ -86,15 +93,17 @@ public override void EvaluateQue(float currentTime)
 
         public override void UpdateChannel()
         {
-            if (_materialPropertyBlock == null || _materialPropertyBlocks == null) return;
+            if (_materialPropertyBlock == null || _materialPropertyBlocks == null)
             {
                 Init();
             }
+
             if(_materialPropertyBlock ==null) return;
 
             if (meshRenderer)
             {
-                if(meshRenderer.sharedMaterials.Length <= materialIndex) return;
+                meshRenderer.GetSharedMaterials(sharedMaterials);
+                if(sharedMaterials.Count <= materialIndex) return;
                 meshRenderer.GetPropertyBlock(_materialPropertyBlock,materialIndex);
                 _materialPropertyBlock.SetFloat(colorPropertyName,floatValue);
                 meshRenderer.SetPropertyBlock(_materialPropertyBlock,materialIndex);
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Channels/MaterialTextureChannel.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Channels/MaterialTextureChannel.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
@@ -36,14 +36,19 @@ protected void OnEnable()
 
         public override void Init()
         {
-            _materialPropertyBlockDictionary = new Dictionary<MeshRenderer, MaterialPropertyBlock>();
+            _materialPropertyBlockDictionary ??= new Dictionary<MeshRenderer, MaterialPropertyBlock>();
+            _materialPropertyBlockDictionary.Clear();
+
             foreach (var meshRenderer in meshRenderers)
             {
                 if(meshRenderer == null) continue;
                 var materialPropertyBlock = new MaterialPropertyBlock();
                 meshRenderer.GetPropertyBlock(materialPropertyBlock);
-                _materialPropertyBlockDictionary.Add(meshRenderer,materialPropertyBlock);
+
+                _materialPropertyBlockDictionary.Add(meshRenderer, materialPropertyBlock);
             }
+
+            PropertyTypes.Clear();
             PropertyTypes.Add(typeof(MaterialTextureProperty));
         }
         
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Channels/SyncLightMaterialChannel.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Channels/SyncLightMaterialChannel.cs
@@ -32,10 +32,10 @@ public class SyncLightMaterialChannel : StageLightChannelBase
         [ChannelField(true)] public float maxIntensityLimit = 3;
         [ChannelField(true)] public int materialIndex = 0;
         [FormerlySerializedAs("lightChannelChannel")] [FormerlySerializedAs("lightFxChannel")]
+        [ChannelField(true)] public bool brightnessDecreasesToBlack = true;
 #endregion
 
 #region params
-        [ChannelField(false)] public bool brightnessDecreasesToBlack = true;
         [ChannelField(false)] private Dictionary<MeshRenderer,MaterialPropertyBlock> _materialPropertyBlocks;
         [ChannelField(false)] public float intensityMultiplier = 1f;
 #endregion
@@ -78,8 +78,8 @@ public void GetMeshRenderersInChild()
 
         public override void Init()
         {
+            _materialPropertyBlocks ??= new Dictionary<MeshRenderer, MaterialPropertyBlock>();
             if(_materialPropertyBlocks != null) _materialPropertyBlocks.Clear();
-            _materialPropertyBlocks = new Dictionary<MeshRenderer, MaterialPropertyBlock>();
 
             foreach (var meshRenderer in meshRenderers)
             {
@@ -106,10 +106,10 @@ public override void EvaluateQue(float currentTime)
                 if(syncLightMaterialProperty != null)
                 {
                     intensityMultiplier += syncLightMaterialProperty.intensitymultiplier.value * data.weight;
-                    if(data.weight > 0.5f)
-                    {
-                        brightnessDecreasesToBlack = syncLightMaterialProperty.brightnessDecreasesToBlack.value;
-                    }
+                    // if(data.weight > 0.5f)
+                    // {
+                    //     brightnessDecreasesToBlack = syncLightMaterialProperty.brightnessDecreasesToBlack.value;
+                    // }
 
                     maxIntensityLimit += syncLightMaterialProperty.maxIntensityLimit.value * data.weight;
                 }
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Channels/SyncRensFlaretChannel.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Channels/SyncRensFlaretChannel.cs
@@ -24,6 +24,7 @@ public class SyncLensFlareChannel : StageLightChannelBase
 
 #region Configs
         [ChannelField(true)] public float maxIntensityLimit = 3;
+        [ChannelField(true)] public bool brightnessDecreasesToBlack = true;
 #endregion
 
 
@@ -80,6 +81,14 @@ public override void UpdateChannel()
             var intensity = Mathf.Min(lightChannel.lightIntensity * intensityMultiplier,maxIntensityLimit);
             lensFlareSRP.intensity = intensity;
             lensFlareSRP.scale = scale;
+
+            //? ライトの色を考慮
+            //! レンズフレアの色変える方法わからんので、一旦単に明るさを変えるだけにする
+            if (brightnessDecreasesToBlack)
+            {
+                float lightColorBrightness = lightChannel.lightColor.grayscale;
+                lensFlareSRP.intensity *= lightColorBrightness;
+            }
         }
     }
 
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Data/LightIntensityProperty.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Data/LightIntensityProperty.cs
@@ -8,13 +8,13 @@ namespace StageLightManeuver
     [Serializable]
     public class LightIntensityProperty:SlmAdditionalProperty
     {
-        [SlmValue("Intensity")]public SlmToggleValue<MinMaxEasingValue> lightToggleIntensity;// = new StageLightProperty<float>(){value = 1f};
+         [FormerlySerializedAs("lightToggleIntensity")] [SlmValue("Dimmer")]public SlmToggleValue<MinMaxEasingValue> lightToggleDimmer;// = new StageLightProperty<float>(){value = 1f};
         public LightIntensityProperty()
         {
             propertyOverride = true;
-            propertyName = "Intensity";
+            propertyName = "Dimmer";
             clockOverride = new SlmToggleValue<ClockOverride>();
-            lightToggleIntensity = new SlmToggleValue<MinMaxEasingValue>(){value = new MinMaxEasingValue()
+            lightToggleDimmer = new SlmToggleValue<MinMaxEasingValue>(){value = new MinMaxEasingValue()
             {
                 minMaxValue = new Vector2(0, 10),
                 constant = 1f,
@@ -26,18 +26,18 @@ public override void ToggleOverride(bool toggle)
         {
             propertyOverride = toggle;
             clockOverride.propertyOverride = toggle;
-            lightToggleIntensity.propertyOverride = toggle;
+            lightToggleDimmer.propertyOverride = toggle;
         }
         
         public LightIntensityProperty( LightIntensityProperty other )
         {
             propertyName = other.propertyName;
             propertyOverride = other.propertyOverride;
             clockOverride = new SlmToggleValue<ClockOverride>(other.clockOverride);
-            lightToggleIntensity = new SlmToggleValue<MinMaxEasingValue>()
+            lightToggleDimmer = new SlmToggleValue<MinMaxEasingValue>()
             {
-                propertyOverride = other.lightToggleIntensity.propertyOverride,
-                value = new MinMaxEasingValue(other.lightToggleIntensity.value)
+                propertyOverride = other.lightToggleDimmer.propertyOverride,
+                value = new MinMaxEasingValue(other.lightToggleDimmer.value)
             };
         }
 
@@ -48,7 +48,7 @@ public override void OverwriteProperty(SlmProperty other)
                 var otherProperty = other as LightIntensityProperty;
                 if (other.propertyOverride)
                 {
-                    if(otherProperty.lightToggleIntensity.propertyOverride) lightToggleIntensity.value = new MinMaxEasingValue(otherProperty.lightToggleIntensity.value);
+                    if(otherProperty.lightToggleDimmer.propertyOverride) lightToggleDimmer.value = new MinMaxEasingValue(otherProperty.lightToggleDimmer.value);
                     if(otherProperty.clockOverride.propertyOverride) clockOverride = new SlmToggleValue<ClockOverride>(otherProperty.clockOverride);
                 }
                     
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Data/ManualColorArrayProperty.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Data/ManualColorArrayProperty.cs
@@ -44,6 +44,8 @@ public override void ToggleOverride(bool toggle)
         public override void ResyncArraySize(List<StageLightFixture> stageLights)
         {
             var colorPrimitiveValues = colorValues.value;
+            if(colorPrimitiveValues.Count == stageLights.Count) return;
+
             if (colorPrimitiveValues.Count < stageLights.Count)
             {
                 while (colorPrimitiveValues.Count < stageLights.Count)
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Data/ManualLightArrayProperty.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Data/ManualLightArrayProperty.cs
@@ -92,8 +92,9 @@ public void AddLightPrimitive(LightPrimitiveValue lightPrimitiveValue = null)
 
         public override void ResyncArraySize(List<StageLightFixture> stageLights)
         {
-            
             var lightPrimitiveValues = lightValues.value;
+            if(lightPrimitiveValues.Count == stageLights.Count) return;
+            
             if (lightPrimitiveValues.Count < stageLights.Count)
             {
                 while (lightPrimitiveValues.Count < stageLights.Count)
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Data/ManualPanTiltProperty.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Data/ManualPanTiltProperty.cs
@@ -56,6 +56,8 @@ public override void ResyncArraySize(List<StageLightFixture> stageLights)
         {
             base.ResyncArraySize(stageLights);
             var manualPanTiltArray = positions.value;
+            if(manualPanTiltArray.Count == stageLights.Count) return;
+            
             if (manualPanTiltArray.Count < stageLights.Count)
             {
                 while (manualPanTiltArray.Count < stageLights.Count)
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/Data/SyncLightMaterialProperty.cs b/jp.iridescenet.stagelightmaneuver/Runtime/Data/SyncLightMaterialProperty.cs
@@ -3,7 +3,7 @@
     public class SyncLightMaterialProperty:SlmAdditionalProperty
     {
         public SlmToggleValue<float> intensitymultiplier;
-        public SlmToggleValue<bool> brightnessDecreasesToBlack;
+        internal SlmToggleValue<bool> brightnessDecreasesToBlack;
         public SlmToggleValue<float> maxIntensityLimit;
         public SyncLightMaterialProperty()
         {
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/StageLightTimeline/StageLightTimelineLayerMixerBehaviour.cs b/jp.iridescenet.stagelightmaneuver/Runtime/StageLightTimeline/StageLightTimelineLayerMixerBehaviour.cs
diff --git a/jp.iridescenet.stagelightmaneuver/Runtime/StageLightTimeline/StageLightTimelineMixerBehaviour.cs b/jp.iridescenet.stagelightmaneuver/Runtime/StageLightTimeline/StageLightTimelineMixerBehaviour.cs

Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,7 @@ public override void DrawBackground(TimelineClip clip, ClipBackgroundRegion regi`
`86`	`86`	`var stageLightTimelineClip = (StageLightTimelineClip) clip.asset;`
`87`	`87`
`88`	`88`
	`89`	`+ if(stageLightTimelineClip.track == null) return;`
`89`	`90`
`90`	`91`	`if (stageLightTimelineClip.clipDisplayName != clip.displayName)`
`91`	`92`	`{`
`@@ -240,7 +241,7 @@ Texture2D GetGradientTexture(TimelineClip clip, bool update = false)`
`240`	`241`	`}`
`241`	`242`
`242`	`243`
`243`		`- var lightIntensityProperty = customClip.StageLightQueueData.TryGetActiveProperty<LightIntensityProperty>();`
	`244`	`+ var lightDimmerProperty = customClip.StageLightQueueData.TryGetActiveProperty<LightIntensityProperty>();`
`244`	`245`	`if (update)`
`245`	`246`	`{`
`246`	`247`	`_gradientTextures.Remove(customClip);`
`@@ -277,10 +278,10 @@ Texture2D GetGradientTexture(TimelineClip clip, bool update = false)`
`277`	`278`	`}`
`278`	`279`
`279`	`280`	`var intensityValue = 1f;`
`280`		`- if (lightIntensityProperty != null)`
	`281`	`+ if (lightDimmerProperty != null)`
`281`	`282`	`{`
`282`		`- var t = SlmUtility.GetNormalizedTime(currentTime, timeProperty, lightIntensityProperty);`
`283`		`- intensityValue = lightIntensityProperty.lightToggleIntensity.value.Evaluate(t);`
	`283`	`+ var t = SlmUtility.GetNormalizedTime(currentTime, timeProperty, lightDimmerProperty);`
	`284`	`+ intensityValue = lightDimmerProperty.lightToggleDimmer.value.Evaluate(t);`
`284`	`285`	`// intensityValue = intensityValue`
`285`	`286`	`}`
`286`	`287`	`else if(materialColorProperty != null)`
Original file line number	Diff line number	Diff line change
`@@ -152,16 +152,16 @@ private void DrawAddPropertyButton(SerializedObject serializedObject, List<SlmPr`
`152`	`152`	`{`
`153`	`153`	`var manualLightArrayProperty = property as ManualLightArrayProperty;`
`154`	`154`	`var lightProperty = stageLightProperties.Find(x => x.GetType() == typeof(LightProperty)) as LightProperty;`
`155`		`- var lightIntensityProperty = stageLightProperties.Find(x => x.GetType() == typeof(LightIntensityProperty)) as LightIntensityProperty;`
	`155`	`+ var lightDimmerProperty = stageLightProperties.Find(x => x.GetType() == typeof(LightIntensityProperty)) as LightIntensityProperty;`
`156`	`156`	`if (lightProperty != null)`
`157`	`157`	`{`
`158`	`158`	`manualLightArrayProperty.initialValue.angle = lightProperty.spotAngle.value.constant;`
`159`	`159`	`manualLightArrayProperty.initialValue.innerAngle = lightProperty.innerSpotAngle.value.constant;`
`160`	`160`	`manualLightArrayProperty.initialValue.range = lightProperty.range.value.constant;`
`161`	`161`	`}`
`162`		`- if (lightIntensityProperty != null)`
	`162`	`+ if (lightDimmerProperty != null)`
`163`	`163`	`{`
`164`		`- manualLightArrayProperty.initialValue.intensity = lightIntensityProperty.lightToggleIntensity.value.constant;`
	`164`	`+ manualLightArrayProperty.initialValue.intensity = lightDimmerProperty.lightToggleDimmer.value.constant;`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`stageLightProperties.Add(property);`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@ public enum FallOffMode`
`47`	`47`
`48`	`48`
`49`	`49`	`#region Configs`
	`50`	`+ [ChannelField(true)] public float intensityMultiplier = 1f;`
`50`	`51`	`[ChannelField(true)] public float limitIntensityMin = 0f;`
`51`	`52`	`[ChannelField(true)] public float limitIntensityMax = 10000f;`
`52`	`53`	`[ChannelField(true)] public float limitInnerSpotAngleMin = 0f;`
`@@ -138,7 +139,7 @@ public override void EvaluateQue(float currentTime)`
`138`	`139`	`var clockProperty= data.TryGetActiveProperty<ClockProperty>() as ClockProperty;`
`139`	`140`	`var lightProperty = data.TryGetActiveProperty<LightProperty>() as LightProperty;`
`140`	`141`	`var lightColorProperty = data.TryGetActiveProperty<LightColorProperty>() as LightColorProperty;`
`141`		`- var lightIntensityProperty = data.TryGetActiveProperty<LightIntensityProperty>() as LightIntensityProperty;`
	`142`	`+ var lightDimmerProperty = data.TryGetActiveProperty<LightIntensityProperty>() as LightIntensityProperty;`
`142`	`143`	`var lightFlickerProperty = data.TryGetActiveProperty<LightFlickerProperty>() as LightFlickerProperty;`
`143`	`144`	`var weight = data.weight;`
`144`	`145`	`var stageLightOrderProperty = data.TryGetActiveProperty<StageLightOrderProperty>() as StageLightOrderProperty;`
`@@ -163,10 +164,10 @@ public override void EvaluateQue(float currentTime)`
`163`	`164`	`}`
`164`	`165`	`else`
`165`	`166`	`{`
`166`		`- if (lightIntensityProperty != null)`
	`167`	`+ if (lightDimmerProperty != null)`
`167`	`168`	`{`
`168`	`169`	`var t = SlmUtility.GetNormalizedTime(currentTime, data, typeof(LightIntensityProperty),index);`
`169`		`- lightIntensity += lightIntensityProperty.lightToggleIntensity.value.Evaluate(t) * weight;`
	`170`	`+ lightIntensity += lightDimmerProperty.lightToggleDimmer.value.Evaluate(t) * weight;`
`170`	`171`	`}`
`171`	`172`	`if(lightFlickerProperty != null)`
`172`	`173`	`{`
`@@ -209,7 +210,7 @@ public override void EvaluateQue(float currentTime)`
`209`	`210`	`}`
`210`	`211`	`}`
`211`	`212`
`212`		`- lightIntensity = Mathf.Clamp(lightIntensity, limitIntensityMin, limitIntensityMax);`
	`213`	`+ lightIntensity = Mathf.Clamp(lightIntensity, limitIntensityMin, limitIntensityMax) * intensityMultiplier;`
`213`	`214`	`spotAngle = Mathf.Clamp(spotAngle, limitSpotAngleMin, limitSpotAngleMax);`
`214`	`215`	`innerSpotAngle = Mathf.Clamp(innerSpotAngle, limitInnerSpotAngleMin, limitInnerSpotAngleMax);`
`215`	`216`	`spotRange = Mathf.Clamp(spotRange, limitSpotRangeMin, limitSpotRangeMax);`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,8 @@ public class MaterialColorChannel:StageLightChannelBase`
`30`	`30`	`[ChannelField(false)] private int propertyId;`
`31`	`31`	`#endregion`
`32`	`32`
	`33`	`+ private List<Material> sharedMaterials = new();`
	`34`	`+`
`33`	`35`
`34`	`36`	`void Start()`
`35`	`37`	`{`
`@@ -49,18 +51,22 @@ public void GetMeshRenderer()`
`49`	`51`
`50`	`52`	`public override void Init()`
`51`	`53`	`{`
`52`		`-`
`53`		`- _materialPropertyBlock = new MaterialPropertyBlock();`
	`54`	`+ _materialPropertyBlock ??= new MaterialPropertyBlock();`
`54`	`55`	`if(meshRenderer)meshRenderer.GetPropertyBlock(_materialPropertyBlock);`
`55`		`- _materialPropertyBlocks = new Dictionary<Renderer, MaterialPropertyBlock>();`
	`56`	`+`
	`57`	`+ _materialPropertyBlocks ??= new Dictionary<Renderer, MaterialPropertyBlock>();`
	`58`	`+ _materialPropertyBlocks.Clear();`
	`59`	`+`
`56`	`60`	`foreach (var meshRenderer in syncMeshRenderers)`
`57`	`61`	`{`
`58`		`- if(meshRenderer == null) continue;`
	`62`	`+ if(meshRenderer == null \|\| (_materialPropertyBlocks.TryGetValue(meshRenderer, out var prop) && prop != null)) continue;`
`59`	`63`	`var materialPropertyBlock = new MaterialPropertyBlock();`
`60`	`64`	`meshRenderer.GetPropertyBlock(materialPropertyBlock);`
`61`		`- _materialPropertyBlocks.Add(meshRenderer,materialPropertyBlock);`
	`65`	`+`
	`66`	`+ _materialPropertyBlocks.Add(meshRenderer, materialPropertyBlock);`
`62`	`67`	`}`
`63`	`68`
	`69`	`+ PropertyTypes.Clear();`
`64`	`70`	`PropertyTypes.Add(typeof(MaterialColorProperty));`
`65`	`71`	`}`
`66`	`72`
`@@ -105,15 +111,17 @@ public override void EvaluateQue(float currentTime)`
`105`	`111`
`106`	`112`	`public override void UpdateChannel()`
`107`	`113`	`{`
`108`		`- if (_materialPropertyBlock == null \|\| _materialPropertyBlocks == null) return;`
	`114`	`+ if (_materialPropertyBlock == null \|\| _materialPropertyBlocks == null)`
`109`	`115`	`{`
`110`	`116`	`Init();`
`111`	`117`	`}`
`112`		`- if(_materialPropertyBlock ==null) return;`
	`118`	`+`
	`119`	`+ if(_materialPropertyBlock == null) return;`
`113`	`120`
`114`	`121`	`if (meshRenderer)`
`115`	`122`	`{`
`116`		`- if(meshRenderer.sharedMaterials.Length <= materialIndex) return;`
	`123`	`+ meshRenderer.GetSharedMaterials(sharedMaterials);`
	`124`	`+ if(sharedMaterials.Count <= materialIndex) return;`
`117`	`125`	`meshRenderer.GetPropertyBlock(_materialPropertyBlock,materialIndex);`
`118`	`126`	`_materialPropertyBlock.SetColor(colorPropertyName,SlmUtility.GetHDRColor(color,intensity));`
`119`	`127`	`meshRenderer.SetPropertyBlock(_materialPropertyBlock,materialIndex);`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System;`
	`1`	`+using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using UnityEngine;`
`4`	`4`
`@@ -36,14 +36,19 @@ protected void OnEnable()`
`36`	`36`
`37`	`37`	`public override void Init()`
`38`	`38`	`{`
`39`		`- _materialPropertyBlockDictionary = new Dictionary<MeshRenderer, MaterialPropertyBlock>();`
	`39`	`+ _materialPropertyBlockDictionary ??= new Dictionary<MeshRenderer, MaterialPropertyBlock>();`
	`40`	`+ _materialPropertyBlockDictionary.Clear();`
	`41`	`+`
`40`	`42`	`foreach (var meshRenderer in meshRenderers)`
`41`	`43`	`{`
`42`	`44`	`if(meshRenderer == null) continue;`
`43`	`45`	`var materialPropertyBlock = new MaterialPropertyBlock();`
`44`	`46`	`meshRenderer.GetPropertyBlock(materialPropertyBlock);`
`45`		`- _materialPropertyBlockDictionary.Add(meshRenderer,materialPropertyBlock);`
	`47`	`+`
	`48`	`+ _materialPropertyBlockDictionary.Add(meshRenderer, materialPropertyBlock);`
`46`	`49`	`}`
	`50`	`+`
	`51`	`+ PropertyTypes.Clear();`
`47`	`52`	`PropertyTypes.Add(typeof(MaterialTextureProperty));`
`48`	`53`	`}`
`49`	`54`
Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,13 @@ namespace StageLightManeuver`
`8`	`8`	`[Serializable]`
`9`	`9`	`public class LightIntensityProperty:SlmAdditionalProperty`
`10`	`10`	`{`
`11`		`- [SlmValue("Intensity")]public SlmToggleValue<MinMaxEasingValue> lightToggleIntensity;// = new StageLightProperty<float>(){value = 1f};`
	`11`	`+ [FormerlySerializedAs("lightToggleIntensity")] [SlmValue("Dimmer")]public SlmToggleValue<MinMaxEasingValue> lightToggleDimmer;// = new StageLightProperty<float>(){value = 1f};`
`12`	`12`	`public LightIntensityProperty()`
`13`	`13`	`{`
`14`	`14`	`propertyOverride = true;`
`15`		`- propertyName = "Intensity";`
	`15`	`+ propertyName = "Dimmer";`
`16`	`16`	`clockOverride = new SlmToggleValue<ClockOverride>();`
`17`		`- lightToggleIntensity = new SlmToggleValue<MinMaxEasingValue>(){value = new MinMaxEasingValue()`
	`17`	`+ lightToggleDimmer = new SlmToggleValue<MinMaxEasingValue>(){value = new MinMaxEasingValue()`
`18`	`18`	`{`
`19`	`19`	`minMaxValue = new Vector2(0, 10),`
`20`	`20`	`constant = 1f,`
`@@ -26,18 +26,18 @@ public override void ToggleOverride(bool toggle)`
`26`	`26`	`{`
`27`	`27`	`propertyOverride = toggle;`
`28`	`28`	`clockOverride.propertyOverride = toggle;`
`29`		`- lightToggleIntensity.propertyOverride = toggle;`
	`29`	`+ lightToggleDimmer.propertyOverride = toggle;`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public LightIntensityProperty( LightIntensityProperty other )`
`33`	`33`	`{`
`34`	`34`	`propertyName = other.propertyName;`
`35`	`35`	`propertyOverride = other.propertyOverride;`
`36`	`36`	`clockOverride = new SlmToggleValue<ClockOverride>(other.clockOverride);`
`37`		`- lightToggleIntensity = new SlmToggleValue<MinMaxEasingValue>()`
	`37`	`+ lightToggleDimmer = new SlmToggleValue<MinMaxEasingValue>()`
`38`	`38`	`{`
`39`		`- propertyOverride = other.lightToggleIntensity.propertyOverride,`
`40`		`- value = new MinMaxEasingValue(other.lightToggleIntensity.value)`
	`39`	`+ propertyOverride = other.lightToggleDimmer.propertyOverride,`
	`40`	`+ value = new MinMaxEasingValue(other.lightToggleDimmer.value)`
`41`	`41`	`};`
`42`	`42`	`}`
`43`	`43`
`@@ -48,7 +48,7 @@ public override void OverwriteProperty(SlmProperty other)`
`48`	`48`	`var otherProperty = other as LightIntensityProperty;`
`49`	`49`	`if (other.propertyOverride)`
`50`	`50`	`{`
`51`		`- if(otherProperty.lightToggleIntensity.propertyOverride) lightToggleIntensity.value = new MinMaxEasingValue(otherProperty.lightToggleIntensity.value);`
	`51`	`+ if(otherProperty.lightToggleDimmer.propertyOverride) lightToggleDimmer.value = new MinMaxEasingValue(otherProperty.lightToggleDimmer.value);`
`52`	`52`	`if(otherProperty.clockOverride.propertyOverride) clockOverride = new SlmToggleValue<ClockOverride>(otherProperty.clockOverride);`
`53`	`53`	`}`
`54`	`54`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,8 @@ public override void ToggleOverride(bool toggle)`
`44`	`44`	`public override void ResyncArraySize(List<StageLightFixture> stageLights)`
`45`	`45`	`{`
`46`	`46`	`var colorPrimitiveValues = colorValues.value;`
	`47`	`+ if(colorPrimitiveValues.Count == stageLights.Count) return;`
	`48`	`+`
`47`	`49`	`if (colorPrimitiveValues.Count < stageLights.Count)`
`48`	`50`	`{`
`49`	`51`	`while (colorPrimitiveValues.Count < stageLights.Count)`
Original file line number	Diff line number	Diff line change
`@@ -92,8 +92,9 @@ public void AddLightPrimitive(LightPrimitiveValue lightPrimitiveValue = null)`
`92`	`92`
`93`	`93`	`public override void ResyncArraySize(List<StageLightFixture> stageLights)`
`94`	`94`	`{`
`95`		`-`
`96`	`95`	`var lightPrimitiveValues = lightValues.value;`
	`96`	`+ if(lightPrimitiveValues.Count == stageLights.Count) return;`
	`97`	`+`
`97`	`98`	`if (lightPrimitiveValues.Count < stageLights.Count)`
`98`	`99`	`{`
`99`	`100`	`while (lightPrimitiveValues.Count < stageLights.Count)`
Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,8 @@ public override void ResyncArraySize(List<StageLightFixture> stageLights)`
`56`	`56`	`{`
`57`	`57`	`base.ResyncArraySize(stageLights);`
`58`	`58`	`var manualPanTiltArray = positions.value;`
	`59`	`+ if(manualPanTiltArray.Count == stageLights.Count) return;`
	`60`	`+`
`59`	`61`	`if (manualPanTiltArray.Count < stageLights.Count)`
`60`	`62`	`{`
`61`	`63`	`while (manualPanTiltArray.Count < stageLights.Count)`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`public class SyncLightMaterialProperty:SlmAdditionalProperty`
`4`	`4`	`{`
`5`	`5`	`public SlmToggleValue<float> intensitymultiplier;`
`6`		`- public SlmToggleValue<bool> brightnessDecreasesToBlack;`
	`6`	`+ internal SlmToggleValue<bool> brightnessDecreasesToBlack;`
`7`	`7`	`public SlmToggleValue<float> maxIntensityLimit;`
`8`	`8`	`public SyncLightMaterialProperty()`
`9`	`9`	`{`