Exemple #1
0
        public void BlendValues(AmplifyColorEffect targetColor, VolumeEffect other, float blendAmount)
        {
            VolumeEffectFlags effectFlags = targetColor.EffectFlags;
            GameObject        go          = targetColor.gameObject;

            for (int comp = 0; comp < effectFlags.components.Count; comp++)
            {
                VolumeEffectComponentFlags compFlags = effectFlags.components[comp];
                if (!compFlags.blendFlag)
                {
                    continue;
                }

                Component             c               = go.GetComponent(compFlags.componentName);
                VolumeEffectComponent effectComp      = FindEffectComponent(compFlags.componentName);
                VolumeEffectComponent effectCompOther = other.FindEffectComponent(compFlags.componentName);
                if (c == null || effectComp == null || effectCompOther == null)
                {
                    continue;
                }

                for (int i = 0; i < compFlags.componentFields.Count; i++)
                {
                    VolumeEffectFieldFlags fieldFlags = compFlags.componentFields[i];
                    if (!fieldFlags.blendFlag)
                    {
                        continue;
                    }

#if !UNITY_EDITOR && UNITY_METRO
                    FieldInfo fi = c.GetType().GetRuntimeField(fieldFlags.fieldName);
#else
                    FieldInfo fi = c.GetType().GetField(fieldFlags.fieldName);
#endif
                    VolumeEffectField effectField      = effectComp.FindEffectField(fieldFlags.fieldName);
                    VolumeEffectField effectFieldOther = effectCompOther.FindEffectField(fieldFlags.fieldName);

                    if (fi == null || effectField == null || effectFieldOther == null)
                    {
                        continue;
                    }

                    switch (fi.FieldType.FullName)
                    {
                    case "System.Single": fi.SetValue(c, Mathf.Lerp(effectField.valueSingle, effectFieldOther.valueSingle, blendAmount)); break;

                    case "System.Boolean": fi.SetValue(c, effectFieldOther.valueBoolean); break;

                    case "UnityEngine.Vector2": fi.SetValue(c, Vector2.Lerp(effectField.valueVector2, effectFieldOther.valueVector2, blendAmount)); break;

                    case "UnityEngine.Vector3": fi.SetValue(c, Vector3.Lerp(effectField.valueVector3, effectFieldOther.valueVector3, blendAmount)); break;

                    case "UnityEngine.Vector4": fi.SetValue(c, Vector4.Lerp(effectField.valueVector4, effectFieldOther.valueVector4, blendAmount)); break;

                    case "UnityEngine.Color": fi.SetValue(c, Color.Lerp(effectField.valueColor, effectFieldOther.valueColor, blendAmount)); break;
                    }
                }
            }
        }
Exemple #2
0
        public static VolumeEffect BlendValuesToVolumeEffect(VolumeEffectFlags flags, VolumeEffect volume1, VolumeEffect volume2, float blend)
        {
            VolumeEffect volumeEffect = new VolumeEffect(volume1.gameObject);

            foreach (VolumeEffectComponentFlags compFlags in flags.components)
            {
                if (compFlags.blendFlag)
                {
                    VolumeEffectComponent volumeEffectComponent  = volume1.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent2 = volume2.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
                    if (volumeEffectComponent != null && volumeEffectComponent2 != null)
                    {
                        VolumeEffectComponent volumeEffectComponent3 = new VolumeEffectComponent(volumeEffectComponent.componentName);
                        foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
                        {
                            if (fieldFlags.blendFlag)
                            {
                                VolumeEffectField volumeEffectField  = volumeEffectComponent.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                                VolumeEffectField volumeEffectField2 = volumeEffectComponent2.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                                if (volumeEffectField != null && volumeEffectField2 != null)
                                {
                                    VolumeEffectField volumeEffectField3 = new VolumeEffectField(volumeEffectField.fieldName, volumeEffectField.fieldType);
                                    string            fieldType          = volumeEffectField3.fieldType;
                                    switch (fieldType)
                                    {
                                    case "System.Single":
                                        volumeEffectField3.valueSingle = Mathf.Lerp(volumeEffectField.valueSingle, volumeEffectField2.valueSingle, blend);
                                        break;

                                    case "System.Boolean":
                                        volumeEffectField3.valueBoolean = volumeEffectField2.valueBoolean;
                                        break;

                                    case "UnityEngine.Vector2":
                                        volumeEffectField3.valueVector2 = Vector2.Lerp(volumeEffectField.valueVector2, volumeEffectField2.valueVector2, blend);
                                        break;

                                    case "UnityEngine.Vector3":
                                        volumeEffectField3.valueVector3 = Vector3.Lerp(volumeEffectField.valueVector3, volumeEffectField2.valueVector3, blend);
                                        break;

                                    case "UnityEngine.Vector4":
                                        volumeEffectField3.valueVector4 = Vector4.Lerp(volumeEffectField.valueVector4, volumeEffectField2.valueVector4, blend);
                                        break;

                                    case "UnityEngine.Color":
                                        volumeEffectField3.valueColor = Color.Lerp(volumeEffectField.valueColor, volumeEffectField2.valueColor, blend);
                                        break;
                                    }
                                    volumeEffectComponent3.fields.Add(volumeEffectField3);
                                }
                            }
                        }
                        volumeEffect.components.Add(volumeEffectComponent3);
                    }
                }
            }
            return(volumeEffect);
        }
Exemple #3
0
        public void BlendValues(AmplifyColorBase targetColor, VolumeEffect other, float blendAmount)
        {
            VolumeEffectFlags effectFlags = targetColor.EffectFlags;
            GameObject        gameObject  = targetColor.gameObject;

            foreach (VolumeEffectComponentFlags compFlags in effectFlags.components)
            {
                if (compFlags.blendFlag)
                {
                    Component             component              = gameObject.GetComponent(compFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent  = this.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent2 = other.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
                    if (!(component == null) && volumeEffectComponent != null && volumeEffectComponent2 != null)
                    {
                        foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
                        {
                            if (fieldFlags.blendFlag)
                            {
                                FieldInfo         field              = component.GetType().GetField(fieldFlags.fieldName);
                                VolumeEffectField volumeEffectField  = volumeEffectComponent.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                                VolumeEffectField volumeEffectField2 = volumeEffectComponent2.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                                if (field != null && volumeEffectField != null && volumeEffectField2 != null)
                                {
                                    string fullName = field.FieldType.FullName;
                                    switch (fullName)
                                    {
                                    case "System.Single":
                                        field.SetValue(component, Mathf.Lerp(volumeEffectField.valueSingle, volumeEffectField2.valueSingle, blendAmount));
                                        break;

                                    case "System.Boolean":
                                        field.SetValue(component, volumeEffectField2.valueBoolean);
                                        break;

                                    case "UnityEngine.Vector2":
                                        field.SetValue(component, Vector2.Lerp(volumeEffectField.valueVector2, volumeEffectField2.valueVector2, blendAmount));
                                        break;

                                    case "UnityEngine.Vector3":
                                        field.SetValue(component, Vector3.Lerp(volumeEffectField.valueVector3, volumeEffectField2.valueVector3, blendAmount));
                                        break;

                                    case "UnityEngine.Vector4":
                                        field.SetValue(component, Vector4.Lerp(volumeEffectField.valueVector4, volumeEffectField2.valueVector4, blendAmount));
                                        break;

                                    case "UnityEngine.Color":
                                        field.SetValue(component, Color.Lerp(volumeEffectField.valueColor, volumeEffectField2.valueColor, blendAmount));
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #4
0
 public VolumeEffectComponentFlags(Component c) : this(string.Concat(c.GetType()))
 {
     foreach (FieldInfo fieldInfo in c.GetType().GetFields())
     {
         if (VolumeEffectField.IsValidType(fieldInfo.FieldType.FullName))
         {
             this.componentFields.Add(new VolumeEffectFieldFlags(fieldInfo));
         }
     }
 }
Exemple #5
0
 public static FieldInfo[] ListAcceptableFields(Component c)
 {
     if (c == null)
     {
         return(new FieldInfo[0]);
     }
     return((from f in c.GetType().GetFields()
             where VolumeEffectField.IsValidType(f.FieldType.FullName)
             select f).ToArray <FieldInfo>());
 }
Exemple #6
0
        public void SetValues(AmplifyColorBase targetColor)
        {
            VolumeEffectFlags effectFlags = targetColor.EffectFlags;
            GameObject        gameObject  = targetColor.gameObject;

            foreach (VolumeEffectComponentFlags compFlags in effectFlags.components)
            {
                if (compFlags.blendFlag)
                {
                    Component             component             = gameObject.GetComponent(compFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent = this.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
                    if (!(component == null) && volumeEffectComponent != null)
                    {
                        foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
                        {
                            if (fieldFlags.blendFlag)
                            {
                                FieldInfo         field             = component.GetType().GetField(fieldFlags.fieldName);
                                VolumeEffectField volumeEffectField = volumeEffectComponent.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                                if (field != null && volumeEffectField != null)
                                {
                                    string fullName = field.FieldType.FullName;
                                    switch (fullName)
                                    {
                                    case "System.Single":
                                        field.SetValue(component, volumeEffectField.valueSingle);
                                        break;

                                    case "System.Boolean":
                                        field.SetValue(component, volumeEffectField.valueBoolean);
                                        break;

                                    case "UnityEngine.Vector2":
                                        field.SetValue(component, volumeEffectField.valueVector2);
                                        break;

                                    case "UnityEngine.Vector3":
                                        field.SetValue(component, volumeEffectField.valueVector3);
                                        break;

                                    case "UnityEngine.Vector4":
                                        field.SetValue(component, volumeEffectField.valueVector4);
                                        break;

                                    case "UnityEngine.Color":
                                        field.SetValue(component, volumeEffectField.valueColor);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #7
0
        public static VolumeEffect BlendValuesToVolumeEffect(VolumeEffectFlags flags, VolumeEffect volume1, VolumeEffect volume2, float blend)
        {
            VolumeEffect resultVolume = new VolumeEffect(volume1.gameObject);

            foreach (VolumeEffectComponentFlags compFlags in flags.components)
            {
                if (!compFlags.blendFlag)
                {
                    continue;
                }

                VolumeEffectComponent ec1 = volume1.FindEffectComponent(compFlags.componentName);
                VolumeEffectComponent ec2 = volume2.FindEffectComponent(compFlags.componentName);
                if (ec1 == null || ec2 == null)
                {
                    continue;
                }

                VolumeEffectComponent resultComp = new VolumeEffectComponent(ec1.componentName);
                foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
                {
                    if (fieldFlags.blendFlag)
                    {
                        VolumeEffectField ef1 = ec1.FindEffectField(fieldFlags.fieldName);
                        VolumeEffectField ef2 = ec2.FindEffectField(fieldFlags.fieldName);
                        if (ef1 == null || ef2 == null)
                        {
                            continue;
                        }

                        VolumeEffectField resultField = new VolumeEffectField(ef1.fieldName, ef1.fieldType);

                        switch (resultField.fieldType)
                        {
                        case "System.Single": resultField.valueSingle = Mathf.Lerp(ef1.valueSingle, ef2.valueSingle, blend); break;

                        case "System.Boolean": resultField.valueBoolean = ef2.valueBoolean; break;

                        case "UnityEngine.Vector2": resultField.valueVector2 = Vector2.Lerp(ef1.valueVector2, ef2.valueVector2, blend); break;

                        case "UnityEngine.Vector3": resultField.valueVector3 = Vector3.Lerp(ef1.valueVector3, ef2.valueVector3, blend); break;

                        case "UnityEngine.Vector4": resultField.valueVector4 = Vector4.Lerp(ef1.valueVector4, ef2.valueVector4, blend); break;

                        case "UnityEngine.Color": resultField.valueColor = Color.Lerp(ef1.valueColor, ef2.valueColor, blend); break;
                        }

                        resultComp.fields.Add(resultField);
                    }
                }
                resultVolume.components.Add(resultComp);
            }
            return(resultVolume);
        }
Exemple #8
0
        public void SetValues(AmplifyColorEffect targetColor)
        {
            VolumeEffectFlags effectFlags = targetColor.EffectFlags;
            GameObject        go          = targetColor.gameObject;

            foreach (VolumeEffectComponentFlags compFlags in effectFlags.components)
            {
                if (!compFlags.blendFlag)
                {
                    continue;
                }

                Component             c          = go.GetComponent(compFlags.componentName);
                VolumeEffectComponent effectComp = FindEffectComponent(compFlags.componentName);
                if (c == null || effectComp == null)
                {
                    continue;
                }

                foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
                {
                    if (!fieldFlags.blendFlag)
                    {
                        continue;
                    }

#if !UNITY_EDITOR && UNITY_METRO
                    FieldInfo fi = c.GetType().GetRuntimeField(fieldFlags.fieldName);
#else
                    FieldInfo fi = c.GetType().GetField(fieldFlags.fieldName);
#endif
                    VolumeEffectField effectField = effectComp.FindEffectField(fieldFlags.fieldName);
                    if (fi == null || effectField == null)
                    {
                        continue;
                    }

                    switch (fi.FieldType.FullName)
                    {
                    case "System.Single": fi.SetValue(c, effectField.valueSingle); break;

                    case "System.Boolean": fi.SetValue(c, effectField.valueBoolean); break;

                    case "UnityEngine.Vector2": fi.SetValue(c, effectField.valueVector2); break;

                    case "UnityEngine.Vector3": fi.SetValue(c, effectField.valueVector3); break;

                    case "UnityEngine.Vector4": fi.SetValue(c, effectField.valueVector4); break;

                    case "UnityEngine.Color": fi.SetValue(c, effectField.valueColor); break;
                    }
                }
            }
        }
 public VolumeEffectComponentFlags(VolumeEffectComponent comp) : this(comp.componentName)
 {
     this.blendFlag = true;
     foreach (VolumeEffectField volumeEffectField in comp.fields)
     {
         if (VolumeEffectField.IsValidType(volumeEffectField.fieldType))
         {
             this.componentFields.Add(new VolumeEffectFieldFlags(volumeEffectField));
         }
     }
 }
 public VolumeEffectComponentFlags(Component c) : this(c.GetType() + string.Empty)
 {
     FieldInfo[] fields = c.GetType().GetFields();
     foreach (FieldInfo fieldInfo in fields)
     {
         if (VolumeEffectField.IsValidType(fieldInfo.FieldType.FullName))
         {
             this.componentFields.Add(new VolumeEffectFieldFlags(fieldInfo));
         }
     }
 }
Exemple #11
0
 public static VolumeEffect BlendValuesToVolumeEffect(VolumeEffectFlags flags, VolumeEffect volume1, VolumeEffect volume2, float blend)
 {
     VolumeEffect volumeEffect = new VolumeEffect(volume1.gameObject);
     foreach (VolumeEffectComponentFlags compFlags in flags.components)
     {
         if (compFlags.blendFlag)
         {
             VolumeEffectComponent volumeEffectComponent = volume1.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
             VolumeEffectComponent volumeEffectComponent2 = volume2.components.Find((VolumeEffectComponent s) => s.componentName == compFlags.componentName);
             if (volumeEffectComponent != null && volumeEffectComponent2 != null)
             {
                 VolumeEffectComponent volumeEffectComponent3 = new VolumeEffectComponent(volumeEffectComponent.componentName);
                 foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
                 {
                     if (fieldFlags.blendFlag)
                     {
                         VolumeEffectField volumeEffectField = volumeEffectComponent.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                         VolumeEffectField volumeEffectField2 = volumeEffectComponent2.fields.Find((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName);
                         if (volumeEffectField != null && volumeEffectField2 != null)
                         {
                             VolumeEffectField volumeEffectField3 = new VolumeEffectField(volumeEffectField.fieldName, volumeEffectField.fieldType);
                             string fieldType = volumeEffectField3.fieldType;
                             switch (fieldType)
                             {
                             case "System.Single":
                                 volumeEffectField3.valueSingle = Mathf.Lerp(volumeEffectField.valueSingle, volumeEffectField2.valueSingle, blend);
                                 break;
                             case "System.Boolean":
                                 volumeEffectField3.valueBoolean = volumeEffectField2.valueBoolean;
                                 break;
                             case "UnityEngine.Vector2":
                                 volumeEffectField3.valueVector2 = Vector2.Lerp(volumeEffectField.valueVector2, volumeEffectField2.valueVector2, blend);
                                 break;
                             case "UnityEngine.Vector3":
                                 volumeEffectField3.valueVector3 = Vector3.Lerp(volumeEffectField.valueVector3, volumeEffectField2.valueVector3, blend);
                                 break;
                             case "UnityEngine.Vector4":
                                 volumeEffectField3.valueVector4 = Vector4.Lerp(volumeEffectField.valueVector4, volumeEffectField2.valueVector4, blend);
                                 break;
                             case "UnityEngine.Color":
                                 volumeEffectField3.valueColor = Color.Lerp(volumeEffectField.valueColor, volumeEffectField2.valueColor, blend);
                                 break;
                             }
                             volumeEffectComponent3.fields.Add(volumeEffectField3);
                         }
                     }
                 }
                 volumeEffect.components.Add(volumeEffectComponent3);
             }
         }
     }
     return volumeEffect;
 }
 public VolumeEffectComponentFlags(Component c) : this(c.GetType() + string.Empty)
 {
     FieldInfo[] fields = c.GetType().GetFields();
     FieldInfo[] array  = fields;
     for (int i = 0; i < array.Length; i++)
     {
         FieldInfo fieldInfo = array[i];
         if (VolumeEffectField.IsValidType(fieldInfo.FieldType.FullName))
         {
             this.componentFields.Add(new VolumeEffectFieldFlags(fieldInfo));
         }
     }
 }
 public void UpdateComponentFlags(VolumeEffectComponent comp)
 {
     using (List <VolumeEffectField> .Enumerator enumerator = comp.fields.GetEnumerator())
     {
         while (enumerator.MoveNext())
         {
             VolumeEffectField field = enumerator.Current;
             if (this.componentFields.Find((VolumeEffectFieldFlags s) => s.fieldName == field.fieldName) == null && VolumeEffectField.IsValidType(field.fieldType))
             {
                 this.componentFields.Add(new VolumeEffectFieldFlags(field));
             }
         }
     }
 }
Exemple #14
0
        public static FieldInfo[] ListAcceptableFields(Component c)
        {
            if (c == null)
            {
                return(new FieldInfo[0]);
            }

#if !UNITY_EDITOR && UNITY_METRO
            FieldInfo[] fields = c.GetType().GetRuntimeFields().ToArray();
#else
            FieldInfo[] fields = c.GetType().GetFields();
#endif

            return((fields.Where(f => VolumeEffectField.IsValidType(f.FieldType.FullName))).ToArray());
        }
Exemple #15
0
 public VolumeEffectComponent(Component c, VolumeEffectComponentFlags compFlags) : this(compFlags.componentName)
 {
     foreach (VolumeEffectFieldFlags volumeEffectFieldFlags in compFlags.componentFields)
     {
         if (volumeEffectFieldFlags.blendFlag)
         {
             FieldInfo         field             = c.GetType().GetField(volumeEffectFieldFlags.fieldName);
             VolumeEffectField volumeEffectField = (!VolumeEffectField.IsValidType(field.FieldType.FullName)) ? null : new VolumeEffectField(field, c);
             if (volumeEffectField != null)
             {
                 this.fields.Add(volumeEffectField);
             }
         }
     }
 }
 public void UpdateComponentFlags(Component c)
 {
 #if !UNITY_EDITOR && UNITY_METRO
     FieldInfo[] fields = c.GetType().GetRuntimeFields().ToArray();
 #else
     FieldInfo[] fields = c.GetType().GetFields();
 #endif
     foreach (FieldInfo pi in fields)
     {
         if (!componentFields.Exists(s => s.fieldName == pi.Name) && VolumeEffectField.IsValidType(pi.FieldType.FullName))
         {
             componentFields.Add(new VolumeEffectFieldFlags(pi));
         }
     }
 }
 public VolumeEffectComponentFlags(Component c)
     : this(c.GetType() + "")
 {
 #if !UNITY_EDITOR && UNITY_METRO
     FieldInfo[] fields = c.GetType().GetRuntimeFields().ToArray();
 #else
     FieldInfo[] fields = c.GetType().GetFields();
 #endif
     foreach (FieldInfo pi in fields)
     {
         if (VolumeEffectField.IsValidType(pi.FieldType.FullName))
         {
             componentFields.Add(new VolumeEffectFieldFlags(pi));
         }
     }
 }
Exemple #18
0
        public VolumeEffectField AddField(FieldInfo pi, Component c, int position)
        {
            VolumeEffectField volumeEffectField = (!VolumeEffectField.IsValidType(pi.FieldType.FullName)) ? null : new VolumeEffectField(pi, c);

            if (volumeEffectField != null)
            {
                if (position < 0 || position >= this.fields.Count)
                {
                    this.fields.Add(volumeEffectField);
                }
                else
                {
                    this.fields.Insert(position, volumeEffectField);
                }
            }
            return(volumeEffectField);
        }
Exemple #19
0
        public VolumeEffectField AddField(FieldInfo pi, Component c, int position)
        {
            VolumeEffectField field = VolumeEffectField.IsValidType(pi.FieldType.FullName) ? new VolumeEffectField(pi, c) : null;

            if (field != null)
            {
                if (position < 0 || position >= fields.Count)
                {
                    fields.Add(field);
                }
                else
                {
                    fields.Insert(position, field);
                }
            }
            return(field);
        }
Exemple #20
0
 public void UpdateComponent(Component c, VolumeEffectComponentFlags compFlags)
 {
     foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
     {
         if (fieldFlags.blendFlag)
         {
             if (!this.fields.Exists((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName))
             {
                 FieldInfo         field             = c.GetType().GetField(fieldFlags.fieldName);
                 VolumeEffectField volumeEffectField = (!VolumeEffectField.IsValidType(field.FieldType.FullName)) ? null : new VolumeEffectField(field, c);
                 if (volumeEffectField != null)
                 {
                     this.fields.Add(volumeEffectField);
                 }
             }
         }
     }
 }
Exemple #21
0
 public void UpdateComponent(Component c, VolumeEffectComponentFlags compFlags)
 {
     using (List <VolumeEffectFieldFlags> .Enumerator enumerator = compFlags.componentFields.GetEnumerator())
     {
         while (enumerator.MoveNext())
         {
             VolumeEffectFieldFlags fieldFlags = enumerator.Current;
             if (fieldFlags.blendFlag && !this.fields.Exists((VolumeEffectField s) => s.fieldName == fieldFlags.fieldName))
             {
                 FieldInfo         field             = c.GetType().GetField(fieldFlags.fieldName);
                 VolumeEffectField volumeEffectField = VolumeEffectField.IsValidType(field.FieldType.FullName) ? new VolumeEffectField(field, c) : null;
                 if (volumeEffectField != null)
                 {
                     this.fields.Add(volumeEffectField);
                 }
             }
         }
     }
 }
Exemple #22
0
        public static VolumeEffect BlendValuesToVolumeEffect( VolumeEffectFlags flags, VolumeEffect volume1, VolumeEffect volume2, float blend )
        {
            VolumeEffect resultVolume = new VolumeEffect( volume1.gameObject );
            foreach ( VolumeEffectComponentFlags compFlags in flags.components )
            {
            if ( !compFlags.blendFlag )
                continue;

            VolumeEffectComponent ec1 = volume1.components.Find( s => s.componentName == compFlags.componentName );
            VolumeEffectComponent ec2 = volume2.components.Find( s => s.componentName == compFlags.componentName );
            if ( ec1 == null || ec2 == null )
                continue;

            VolumeEffectComponent resultComp = new VolumeEffectComponent( ec1.componentName );
            foreach ( VolumeEffectFieldFlags fieldFlags in compFlags.componentFields )
            {
                if ( fieldFlags.blendFlag )
                {
                    VolumeEffectField ef1 = ec1.fields.Find( s => s.fieldName == fieldFlags.fieldName );
                    VolumeEffectField ef2 = ec2.fields.Find( s => s.fieldName == fieldFlags.fieldName );
                    if ( ef1 == null || ef2 == null )
                        continue;

                    VolumeEffectField resultField = new VolumeEffectField( ef1.fieldName, ef1.fieldType );

                    switch ( resultField.fieldType )
                    {
                        case "System.Single": resultField.valueSingle = Mathf.Lerp( ef1.valueSingle, ef2.valueSingle, blend ); break;
                        case "System.Boolean": resultField.valueBoolean = ef2.valueBoolean; break;
                        case "UnityEngine.Vector2": resultField.valueVector2 = Vector2.Lerp( ef1.valueVector2, ef2.valueVector2, blend ); break;
                        case "UnityEngine.Vector3": resultField.valueVector3 = Vector3.Lerp( ef1.valueVector3, ef2.valueVector3, blend ); break;
                        case "UnityEngine.Vector4": resultField.valueVector4 = Vector4.Lerp( ef1.valueVector4, ef2.valueVector4, blend ); break;
                        case "UnityEngine.Color": resultField.valueColor = Color.Lerp( ef1.valueColor, ef2.valueColor, blend ); break;
                    }

                    resultComp.fields.Add( resultField );
                }
            }
            resultVolume.components.Add( resultComp );
            }
            return resultVolume;
        }
Exemple #23
0
        public VolumeEffectComponent(Component c, VolumeEffectComponentFlags compFlags) : this(compFlags.componentName)
        {
            foreach (VolumeEffectFieldFlags fieldFlags in compFlags.componentFields)
            {
                if (!fieldFlags.blendFlag)
                {
                    continue;
                }

#if !UNITY_EDITOR && UNITY_METRO
                FieldInfo pi = c.GetType().GetRuntimeField(fieldFlags.fieldName);
#else
                FieldInfo pi = c.GetType().GetField(fieldFlags.fieldName);
#endif
                VolumeEffectField field = VolumeEffectField.IsValidType(pi.FieldType.FullName) ? new VolumeEffectField(pi, c) : null;
                if (field != null)
                {
                    fields.Add(field);
                }
            }
        }
Exemple #24
0
 public void RemoveEffectField( VolumeEffectField field )
 {
     fields.Remove( field );
 }
Exemple #25
0
 public void RemoveEffectField(VolumeEffectField field)
 {
     fields.Remove(field);
 }
    void DrawVolumeEffectFields(AmplifyColorVolumeBase volume)
    {
        List <AmplifyColor.VolumeEffect> effectsToDelete = new List <AmplifyColor.VolumeEffect>();
        float removeButtonSize = 16;

        List <NewLineContainer> volumeLines = null;

        if (!(newLines.TryGetValue(volume, out volumeLines)))
        {
            volumeLines = newLines[volume] = new List <NewLineContainer>();
        }

        GUIStyle minusStyle = new GUIStyle(( GUIStyle )"OL Minus");
        GUIStyle plusStyle  = new GUIStyle(( GUIStyle )"OL Plus");

        minusStyle.margin.top = 2;
        plusStyle.margin.top  = 2;

        #region CurrentEffectFields
        int fieldPosition = 0;
        foreach (AmplifyColor.VolumeEffect effectVol in volume.EffectContainer.volumes)
        {
            if (effectVol.gameObject == null)
            {
                continue;
            }

            AmplifyColorBase effect = effectVol.gameObject;
            List <AmplifyColor.VolumeEffectComponent> compsToDelete = new List <AmplifyColor.VolumeEffectComponent>();

            foreach (AmplifyColor.VolumeEffectComponent comp in effectVol.components)
            {
                Component c = effect.GetComponent(comp.componentName);
                if (c == null)
                {
                    continue;
                }

                List <AmplifyColor.VolumeEffectField> fieldsToDelete = new List <AmplifyColor.VolumeEffectField>();
                List <KeyValuePair <string, int> >    fieldsToAdd    = new List <KeyValuePair <string, int> >();

                foreach (AmplifyColor.VolumeEffectField field in comp.fields)
                {
                    EditorGUILayout.BeginHorizontal();
                    GUILayout.Label("", GUILayout.MinWidth(minIndentWidth), GUILayout.MaxWidth(maxIndentWidth));
                    GUILayout.Space(0);

                    if (GUILayout.Button("", minusStyle, GUILayout.MinWidth(18), GUILayout.MaxWidth(18), GUILayout.Height(20)))
                    {
                        fieldsToDelete.Add(field);
                    }

                    Camera           selectedCamera = EditorGUILayout.ObjectField(effect.GetComponent <Camera>(), typeof(Camera), true, GUILayout.MinWidth(minColumnWidth * 1.5f), GUILayout.MaxWidth(maxColumnWidth * 1.5f)) as Camera;
                    AmplifyColorBase selectedEffect = (selectedCamera != null) ? selectedCamera.GetComponent <AmplifyColorBase>() : null;
                    if (selectedEffect != effect)
                    {
                        fieldsToDelete.Add(field);
                        dirtyVolumeFlags = true;
                        volumeLines.Add(new NewLineContainer(selectedEffect));
                    }

                    Component[]   compArray      = AmplifyColor.VolumeEffect.ListAcceptableComponents(effectVol.gameObject);
                    List <string> compFlagsArray = compArray.Select(s => s.GetType().Name).ToList();
                    compFlagsArray.Remove(comp.componentName);
                    string[] compNamesArray = new string[] { comp.componentName }.Concat(compFlagsArray).ToArray();
                    int      selectedComponent = 0;
                    selectedComponent = EditorGUILayout.Popup(selectedComponent, compNamesArray, GUILayout.MinWidth(minColumnWidth), GUILayout.MaxWidth(maxColumnWidth));
                    if (selectedComponent != 0)
                    {
                        volumeLines.Add(new NewLineContainer(effect, compNamesArray[selectedComponent]));
                        fieldsToDelete.Add(field);
                        dirtyVolumeFlags = true;
                    }

                    FieldInfo[] fieldArray      = AmplifyColor.VolumeEffectComponent.ListAcceptableFields(c);
                    string[]    fieldFlagsArray = fieldArray.Select(s => s.Name).ToArray();
                    string[]    fieldNamesArray = comp.GetFieldNames();
                    fieldFlagsArray = fieldFlagsArray.Except(fieldNamesArray).ToArray();

                    List <string> names = new List <string>();
                    names.Add(field.fieldName);
                    names.AddRange(fieldFlagsArray);
                    for (int i = 0; i < names.Count; i++)
                    {
                        if (i == 0)
                        {
                            continue;
                        }

                        FieldInfo fi = Array.Find(fieldArray, s => (names[i] == s.Name));
                        if (fi != null)
                        {
                            names[i] += " : " + fi.FieldType.Name;
                        }
                    }

                    int selectedField = 0;
                    selectedField = EditorGUILayout.Popup(selectedField, names.ToArray(), GUILayout.MinWidth(minColumnWidth), GUILayout.MaxWidth(maxColumnWidth));
                    if (selectedField != 0)
                    {
                        fieldsToAdd.Add(new KeyValuePair <string, int>(fieldFlagsArray[selectedField - 1], fieldPosition));
                        fieldsToDelete.Add(field);
                        dirtyVolumeFlags = true;
                    }
                    fieldPosition++;

                    switch (field.fieldType)
                    {
                    case "System.Single": field.valueSingle = EditorGUILayout.FloatField(field.valueSingle, GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth)); break;

                    case "System.Boolean": field.valueBoolean = EditorGUILayout.Toggle("", field.valueBoolean, GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth)); break;

                    case "UnityEngine.Vector2": field.valueVector2 = EditorGUILayout.Vector2Field("", field.valueVector2, GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth), GUILayout.MaxHeight(16)); break;

                    case "UnityEngine.Vector3": field.valueVector3 = EditorGUILayout.Vector3Field("", field.valueVector3, GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth), GUILayout.MaxHeight(16)); break;

                    case "UnityEngine.Vector4": field.valueVector4 = DrawFixedVector4Field(field.valueVector4); break;

                    case "UnityEngine.Color": field.valueColor = EditorGUILayout.ColorField(field.valueColor, GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth)); break;

                    default: EditorGUILayout.LabelField(field.fieldType, GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth)); break;
                    }

                    // COPY TO CLIPBOARD
                    string luid   = NewLineContainer.GenerateUniqueID(effect, comp.componentName, field.fieldName);
                    bool   copied = copyLines.ContainsKey(luid);
                    bool   keep   = GUILayout.Toggle(copied, "c", removeButtonStyle, GUILayout.Width(removeButtonSize), GUILayout.Height(removeButtonSize));
                    if (keep != copied)
                    {
                        if (keep)
                        {
                            object valueCopy = null;
                            switch (field.fieldType)
                            {
                            case "System.Single": valueCopy = field.valueSingle; break;

                            case "System.Boolean": valueCopy = field.valueBoolean; break;

                            case "UnityEngine.Vector2": valueCopy = field.valueVector2; break;

                            case "UnityEngine.Vector3": valueCopy = field.valueVector3; break;

                            case "UnityEngine.Vector4": valueCopy = field.valueVector4; break;

                            case "UnityEngine.Color": valueCopy = field.valueColor; break;
                            }
                            copyLines.Add(luid, new NewLineContainer(effect, comp.componentName, field.fieldName, field.fieldType, valueCopy));
                        }
                        else
                        {
                            copyLines.Remove(luid);
                        }

                        //Debug.Log( "CopyComplete: " + luid + ", " + keep + ", " + volume.name );
                    }

                    EditorGUILayout.EndHorizontal();
                    GUILayout.Space(2);
                }

                bool fieldRemoved = false;
                foreach (AmplifyColor.VolumeEffectField field in fieldsToDelete)
                {
                    comp.RemoveEffectField(field);
                    fieldRemoved = true;
                }

                foreach (KeyValuePair <string, int> pair in fieldsToAdd)
                {
                    FieldInfo pi = c.GetType().GetField(pair.Key);
                    if (pi != null)
                    {
                        comp.AddField(pi, c, pair.Value);
                    }
                }

                if (fieldRemoved && comp.fields.Count <= 0)
                {
                    compsToDelete.Add(comp);
                }
            }

            bool compRemoved = false;
            foreach (AmplifyColor.VolumeEffectComponent comp in compsToDelete)
            {
                effectVol.RemoveEffectComponent(comp);
                compRemoved = true;
            }

            if (compRemoved && effectVol.components.Count <= 0)
            {
                effectsToDelete.Add(effectVol);
            }
        }

        foreach (AmplifyColor.VolumeEffect effectVol in effectsToDelete)
        {
            volume.EffectContainer.RemoveVolumeEffect(effectVol);
        }
        #endregion CurrentEffectFields

        #region NewLines
        List <NewLineContainer> linesToDelete = new List <NewLineContainer>();
        foreach (NewLineContainer line in volumeLines)
        {
            EditorGUILayout.BeginHorizontal();
            GUILayout.Label("", GUILayout.MinWidth(minIndentWidth), GUILayout.MaxWidth(maxIndentWidth));
            GUILayout.Space(0);

            if (GUILayout.Button("", minusStyle, GUILayout.MinWidth(18), GUILayout.MaxWidth(18), GUILayout.Height(20)))
            {
                linesToDelete.Add(line);
            }

            Camera           selectedCamera = EditorGUILayout.ObjectField(line.camera, typeof(Camera), true, GUILayout.MinWidth(minColumnWidth * 1.5f), GUILayout.MaxWidth(maxColumnWidth * 1.5f)) as Camera;
            AmplifyColorBase selectedEffect = (selectedCamera != null) ? selectedCamera.GetComponent <AmplifyColorBase>() : null;
            if (selectedEffect != null && selectedEffect != line.camera)
            {
                line.SetCamera(selectedEffect);
            }

            AmplifyColor.VolumeEffect effectVol = null;
            if (line.camera != null)
            {
                effectVol = volume.EffectContainer.FindVolumeEffect(line.camera);
            }

            if (line.camera != null)
            {
                Component[]   compArray     = AmplifyColor.VolumeEffect.ListAcceptableComponents(line.camera);
                List <string> names         = compArray.Select(s => s.GetType().Name).ToList <string>();
                int           popupSelected = names.IndexOf(line.component) + 1;
                names.Insert(0, "<Component>");
                int selectedComponent = popupSelected;
                selectedComponent = EditorGUILayout.Popup(selectedComponent, names.ToArray(), GUILayout.MinWidth(minColumnWidth), GUILayout.MaxWidth(maxColumnWidth));
                if (selectedComponent != popupSelected)
                {
                    line.SetComponent(selectedComponent == 0 ? null : names[selectedComponent]);
                }
            }
            else
            {
                GUI.enabled = false;
                EditorGUILayout.Popup(0, new string[] { "<Component>" }, GUILayout.MaxWidth(maxColumnWidth));
                GUI.enabled = true;
            }

            Component c = (line.camera == null) ? null : line.camera.GetComponent(line.component);

            AmplifyColor.VolumeEffectComponent comp = null;
            if (effectVol != null)
            {
                comp = effectVol.FindEffectComponent(line.component);
            }

            if (c != null)
            {
                FieldInfo[] fieldArray      = AmplifyColor.VolumeEffectComponent.ListAcceptableFields(c);
                string[]    fieldFlagsArray = fieldArray.Select(s => s.Name).ToArray();
                if (comp != null)
                {
                    string[] fieldNamesArray = comp.GetFieldNames();
                    fieldFlagsArray = fieldFlagsArray.Except(fieldNamesArray).ToArray();
                }

                List <string> names = fieldFlagsArray.ToList();
                for (int i = 0; i < names.Count; i++)
                {
                    FieldInfo fi = Array.Find(fieldArray, s => (names[i] == s.Name));
                    if (fi != null)
                    {
                        names[i] += " : " + fi.FieldType.Name;
                    }
                }
                names.Insert(0, "<Field>");

                int selectedField = 0;
                selectedField = EditorGUILayout.Popup(selectedField, names.ToArray(), GUILayout.MinWidth(minColumnWidth), GUILayout.MaxWidth(maxColumnWidth));
                if (selectedField > 0)
                {
                    FieldInfo pi = c.GetType().GetField(fieldFlagsArray[selectedField - 1]);
                    if (pi != null)
                    {
                        if (effectVol == null)
                        {
                            effectVol = volume.EffectContainer.AddJustColorEffect(line.camera);
                        }

                        if (comp == null)
                        {
                            comp = effectVol.AddComponent(c, null);
                        }

                        comp.AddField(pi, c);
                        linesToDelete.Add(line);
                        dirtyVolumeFlags = true;
                    }
                }

                EditorGUILayout.LabelField("", GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth));
            }
            else
            {
                GUI.enabled = false;
                EditorGUILayout.Popup(0, new string[] { "<Field>" }, GUILayout.MaxWidth(maxColumnWidth));
                EditorGUILayout.TextField("", GUILayout.MinWidth(minValueWidth), GUILayout.MaxWidth(maxValueWidth));
                GUI.enabled = true;
            }

            if (line.camera != null)
            {
                string luid   = NewLineContainer.GenerateUniqueID(line.camera, line.component, line.fieldName);
                bool   copied = copyLines.ContainsKey(luid);
                bool   keep   = GUILayout.Toggle(copied, "c", removeButtonStyle, GUILayout.Width(removeButtonSize), GUILayout.Height(removeButtonSize));
                if (keep != copied)
                {
                    if (keep)
                    {
                        copyLines.Add(luid, new NewLineContainer(line.camera, line.component, line.fieldName, line.fieldType, line.value));
                    }
                    else
                    {
                        copyLines.Remove(luid);
                    }

                    //Debug.Log( "CopyIncomplete: " + luid + ", " + keep + ", " + volume.name );
                }
            }
            else
            {
                GUI.enabled = false;
                GUILayout.Button("c", removeButtonStyle, GUILayout.Width(removeButtonSize), GUILayout.Height(removeButtonSize));
                GUI.enabled = true;
            }

            EditorGUILayout.EndHorizontal();
            GUILayout.Space(2);
        }

        foreach (NewLineContainer line in linesToDelete)
        {
            copyLines.Remove(line.GenerateUniqueID());
            //Debug.Log( "Removed " + line.GenerateUniqueID() );
            volumeLines.Remove(line);
        }
        #endregion NewLines

        #region AddPaste
        EditorGUILayout.BeginHorizontal();
        GUILayout.Label("", GUILayout.MinWidth(minIndentWidth), GUILayout.MaxWidth(maxIndentWidth));
        GUILayout.Space(0);

        bool add = GUILayout.Button("", plusStyle, GUILayout.MinWidth(18), GUILayout.MaxWidth(18), GUILayout.Height(20));
        if (add || GUILayout.Button("Add New", GUILayout.MinWidth(minColumnWidth), GUILayout.MaxWidth(maxColumnWidth), GUILayout.Height(20)))
        {
            volumeLines.Add(new NewLineContainer());
        }

        GUI.enabled = (copyLines.Count > 0);
        if (GUILayout.Button("Paste", GUILayout.MinWidth(minColumnWidth), GUILayout.MaxWidth(maxColumnWidth), GUILayout.Height(20)))
        {
            foreach (var pair in copyLines)
            {
                NewLineContainer line = pair.Value;
                Component        c    = (line.camera == null) ? null : line.camera.GetComponent(line.component);
                FieldInfo        pi   = (c != null) ? c.GetType().GetField(line.fieldName) : null;

                if (pi == null)
                {
                    volumeLines.Add(new NewLineContainer(line.camera, line.component, line.fieldName, line.fieldType, line.value));
                }
                else
                {
                    AmplifyColor.VolumeEffect effectVol = volume.EffectContainer.FindVolumeEffect(line.camera);
                    if (effectVol == null)
                    {
                        effectVol = volume.EffectContainer.AddJustColorEffect(line.camera);
                    }

                    AmplifyColor.VolumeEffectComponent comp = effectVol.FindEffectComponent(line.component);
                    if (comp == null)
                    {
                        comp = effectVol.AddComponent(c, null);
                    }

                    AmplifyColor.VolumeEffectField field = comp.FindEffectField(line.fieldName);
                    if (field == null)
                    {
                        field = comp.AddField(pi, c);
                    }
                    else
                    {
                        Debug.LogWarning("[AmplifyColor] Blend Effect field already added to Volume " + volume.name + ".");
                    }

                    field.UpdateValue(line.value);
                }
            }

            dirtyVolumeFlags = true;
        }
        GUI.enabled = true;

        EditorGUILayout.EndHorizontal();
        GUILayout.Space(5);
        #endregion AddPaste
    }
Exemple #27
0
        public void SetValues(AmplifyColorBase targetColor)
        {
            VolumeEffectFlags effectFlags = targetColor.EffectFlags;
            GameObject        gameObject  = targetColor.gameObject;

            foreach (VolumeEffectComponentFlags volumeEffectComponentFlags in effectFlags.components)
            {
                if (volumeEffectComponentFlags.blendFlag)
                {
                    Component             component             = gameObject.GetComponent(volumeEffectComponentFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent = this.FindEffectComponent(volumeEffectComponentFlags.componentName);
                    if (!(component == null) && volumeEffectComponent != null)
                    {
                        foreach (VolumeEffectFieldFlags volumeEffectFieldFlags in volumeEffectComponentFlags.componentFields)
                        {
                            if (volumeEffectFieldFlags.blendFlag)
                            {
                                FieldInfo         field             = component.GetType().GetField(volumeEffectFieldFlags.fieldName);
                                VolumeEffectField volumeEffectField = volumeEffectComponent.FindEffectField(volumeEffectFieldFlags.fieldName);
                                if (field != null && volumeEffectField != null)
                                {
                                    string fullName = field.FieldType.FullName;
                                    if (fullName != null)
                                    {
                                        if (!(fullName == "System.Single"))
                                        {
                                            if (!(fullName == "System.Boolean"))
                                            {
                                                if (!(fullName == "UnityEngine.Vector2"))
                                                {
                                                    if (!(fullName == "UnityEngine.Vector3"))
                                                    {
                                                        if (!(fullName == "UnityEngine.Vector4"))
                                                        {
                                                            if (fullName == "UnityEngine.Color")
                                                            {
                                                                field.SetValue(component, volumeEffectField.valueColor);
                                                            }
                                                        }
                                                        else
                                                        {
                                                            field.SetValue(component, volumeEffectField.valueVector4);
                                                        }
                                                    }
                                                    else
                                                    {
                                                        field.SetValue(component, volumeEffectField.valueVector3);
                                                    }
                                                }
                                                else
                                                {
                                                    field.SetValue(component, volumeEffectField.valueVector2);
                                                }
                                            }
                                            else
                                            {
                                                field.SetValue(component, volumeEffectField.valueBoolean);
                                            }
                                        }
                                        else
                                        {
                                            field.SetValue(component, volumeEffectField.valueSingle);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
 public VolumeEffectFieldFlags(VolumeEffectField field)
 {
     fieldName = field.fieldName;
     fieldType = field.fieldType;
     blendFlag = true;     // why?...
 }
	public VolumeEffectFieldFlags( VolumeEffectField field )
	{
		fieldName = field.fieldName;
		fieldType = field.fieldType;
		blendFlag = true; // why?...
	}	
 public VolumeEffectFieldFlags(VolumeEffectField field)
 {
     this.fieldName = field.fieldName;
     this.fieldType = field.fieldType;
     this.blendFlag = true;
 }
Exemple #31
0
        public static VolumeEffect BlendValuesToVolumeEffect(VolumeEffectFlags flags, VolumeEffect volume1, VolumeEffect volume2, float blend)
        {
            VolumeEffect volumeEffect = new VolumeEffect(volume1.gameObject);

            foreach (VolumeEffectComponentFlags volumeEffectComponentFlags in flags.components)
            {
                if (volumeEffectComponentFlags.blendFlag)
                {
                    VolumeEffectComponent volumeEffectComponent  = volume1.FindEffectComponent(volumeEffectComponentFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent2 = volume2.FindEffectComponent(volumeEffectComponentFlags.componentName);
                    if (volumeEffectComponent != null && volumeEffectComponent2 != null)
                    {
                        VolumeEffectComponent volumeEffectComponent3 = new VolumeEffectComponent(volumeEffectComponent.componentName);
                        foreach (VolumeEffectFieldFlags volumeEffectFieldFlags in volumeEffectComponentFlags.componentFields)
                        {
                            if (volumeEffectFieldFlags.blendFlag)
                            {
                                VolumeEffectField volumeEffectField  = volumeEffectComponent.FindEffectField(volumeEffectFieldFlags.fieldName);
                                VolumeEffectField volumeEffectField2 = volumeEffectComponent2.FindEffectField(volumeEffectFieldFlags.fieldName);
                                if (volumeEffectField != null && volumeEffectField2 != null)
                                {
                                    VolumeEffectField volumeEffectField3 = new VolumeEffectField(volumeEffectField.fieldName, volumeEffectField.fieldType);
                                    string            fieldType          = volumeEffectField3.fieldType;
                                    if (fieldType != null)
                                    {
                                        if (!(fieldType == "System.Single"))
                                        {
                                            if (!(fieldType == "System.Boolean"))
                                            {
                                                if (!(fieldType == "UnityEngine.Vector2"))
                                                {
                                                    if (!(fieldType == "UnityEngine.Vector3"))
                                                    {
                                                        if (!(fieldType == "UnityEngine.Vector4"))
                                                        {
                                                            if (fieldType == "UnityEngine.Color")
                                                            {
                                                                volumeEffectField3.valueColor = Color.Lerp(volumeEffectField.valueColor, volumeEffectField2.valueColor, blend);
                                                            }
                                                        }
                                                        else
                                                        {
                                                            volumeEffectField3.valueVector4 = Vector4.Lerp(volumeEffectField.valueVector4, volumeEffectField2.valueVector4, blend);
                                                        }
                                                    }
                                                    else
                                                    {
                                                        volumeEffectField3.valueVector3 = Vector3.Lerp(volumeEffectField.valueVector3, volumeEffectField2.valueVector3, blend);
                                                    }
                                                }
                                                else
                                                {
                                                    volumeEffectField3.valueVector2 = Vector2.Lerp(volumeEffectField.valueVector2, volumeEffectField2.valueVector2, blend);
                                                }
                                            }
                                            else
                                            {
                                                volumeEffectField3.valueBoolean = volumeEffectField2.valueBoolean;
                                            }
                                        }
                                        else
                                        {
                                            volumeEffectField3.valueSingle = Mathf.Lerp(volumeEffectField.valueSingle, volumeEffectField2.valueSingle, blend);
                                        }
                                    }
                                    volumeEffectComponent3.fields.Add(volumeEffectField3);
                                }
                            }
                        }
                        volumeEffect.components.Add(volumeEffectComponent3);
                    }
                }
            }
            return(volumeEffect);
        }
 public void UpdateComponentFlags(VolumeEffectComponent comp)
 {
     foreach (VolumeEffectField field in comp.fields)
     {
         if (componentFields.Find(s => s.fieldName == field.fieldName) == null && VolumeEffectField.IsValidType(field.fieldType))
         {
             componentFields.Add(new VolumeEffectFieldFlags(field));
         }
     }
 }
 public void UpdateComponentFlags(Component c)
 {
     FieldInfo[] fields = c.GetType().GetFields();
     FieldInfo[] array  = fields;
     for (int i = 0; i < array.Length; i++)
     {
         FieldInfo pi = array[i];
         if (!this.componentFields.Exists((VolumeEffectFieldFlags s) => s.fieldName == pi.Name) && VolumeEffectField.IsValidType(pi.FieldType.FullName))
         {
             this.componentFields.Add(new VolumeEffectFieldFlags(pi));
         }
     }
 }
Exemple #34
0
        public void BlendValues(AmplifyColorBase targetColor, VolumeEffect other, float blendAmount)
        {
            VolumeEffectFlags effectFlags = targetColor.EffectFlags;
            GameObject        gameObject  = targetColor.gameObject;

            for (int i = 0; i < effectFlags.components.Count; i++)
            {
                VolumeEffectComponentFlags volumeEffectComponentFlags = effectFlags.components[i];
                if (volumeEffectComponentFlags.blendFlag)
                {
                    Component             component              = gameObject.GetComponent(volumeEffectComponentFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent  = this.FindEffectComponent(volumeEffectComponentFlags.componentName);
                    VolumeEffectComponent volumeEffectComponent2 = other.FindEffectComponent(volumeEffectComponentFlags.componentName);
                    if (!(component == null) && volumeEffectComponent != null && volumeEffectComponent2 != null)
                    {
                        for (int j = 0; j < volumeEffectComponentFlags.componentFields.Count; j++)
                        {
                            VolumeEffectFieldFlags volumeEffectFieldFlags = volumeEffectComponentFlags.componentFields[j];
                            if (volumeEffectFieldFlags.blendFlag)
                            {
                                FieldInfo         field              = component.GetType().GetField(volumeEffectFieldFlags.fieldName);
                                VolumeEffectField volumeEffectField  = volumeEffectComponent.FindEffectField(volumeEffectFieldFlags.fieldName);
                                VolumeEffectField volumeEffectField2 = volumeEffectComponent2.FindEffectField(volumeEffectFieldFlags.fieldName);
                                if (field != null && volumeEffectField != null && volumeEffectField2 != null)
                                {
                                    string fullName = field.FieldType.FullName;
                                    if (fullName != null)
                                    {
                                        if (!(fullName == "System.Single"))
                                        {
                                            if (!(fullName == "System.Boolean"))
                                            {
                                                if (!(fullName == "UnityEngine.Vector2"))
                                                {
                                                    if (!(fullName == "UnityEngine.Vector3"))
                                                    {
                                                        if (!(fullName == "UnityEngine.Vector4"))
                                                        {
                                                            if (fullName == "UnityEngine.Color")
                                                            {
                                                                field.SetValue(component, Color.Lerp(volumeEffectField.valueColor, volumeEffectField2.valueColor, blendAmount));
                                                            }
                                                        }
                                                        else
                                                        {
                                                            field.SetValue(component, Vector4.Lerp(volumeEffectField.valueVector4, volumeEffectField2.valueVector4, blendAmount));
                                                        }
                                                    }
                                                    else
                                                    {
                                                        field.SetValue(component, Vector3.Lerp(volumeEffectField.valueVector3, volumeEffectField2.valueVector3, blendAmount));
                                                    }
                                                }
                                                else
                                                {
                                                    field.SetValue(component, Vector2.Lerp(volumeEffectField.valueVector2, volumeEffectField2.valueVector2, blendAmount));
                                                }
                                            }
                                            else
                                            {
                                                field.SetValue(component, volumeEffectField2.valueBoolean);
                                            }
                                        }
                                        else
                                        {
                                            field.SetValue(component, Mathf.Lerp(volumeEffectField.valueSingle, volumeEffectField2.valueSingle, blendAmount));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }