예제 #1
0
	void RotationOptions(ProFlareElement element,int count){
        
		Rect  r  = EditorGUILayout.BeginVertical("box");
		Rect r2 = r;
		r2.height = 20;
		
		
		if (GUI.Button(r2, GUIContent.none,dropDownButton))
            element.RotationSetting = element.RotationSetting ? false : true;
		
		
		GUILayout.Label("Rotation Options");
		{
            
			if(element.RotationSetting){
				GUILayout.Space(5f);
				
				element.angle = EditorGUILayout.FloatField("Angle",element.angle);
                
				if(element.type == ProFlareElement.Type.Multi){
                    element.useStarRotation = EditorGUILayout.Toggle("Use Star Rotation",element.useStarRotation);
					element.useRandomAngle = EditorGUILayout.Toggle("Use Random Rotation",element.useRandomAngle);
					
					
					if(element.useStarRotation){
						for(int i = 0; i < element.subElements.Count; i++){
							element.subElements[i].angle = (180f/element.subElements.Count)*i;
							Updated = true;
						}
					}else{
						for(int i = 0; i < element.subElements.Count; i++){
							element.subElements[i].angle = 0;
							Updated = true;
						}
					}
					
					if(element.useRandomAngle){
						
						float minTemp = element.SubElementAngleRange_Min;
					 	float maxTemp = element.SubElementAngleRange_Max;
						
						EditorGUILayout.BeginHorizontal();
                        {
                            
                            EditorGUILayout.MinMaxSlider(ref  element.SubElementAngleRange_Min ,ref element.SubElementAngleRange_Max,-180f,180f);
                            
                            EditorGUILayout.FloatField(element.SubElementAngleRange_Min);
                            
                            EditorGUILayout.FloatField(element.SubElementAngleRange_Max);
                            
                            if((minTemp != element.SubElementAngleRange_Min)||(maxTemp != element.SubElementAngleRange_Max)||Updated){
                                for(int i = 0; i < element.subElements.Count; i++){
                                    
                                    element.subElements[i].angle = element.subElements[i].angle+Mathf.Lerp(-element.SubElementAngleRange_Min,element.SubElementAngleRange_Max,element.subElements[i].random2);
                                    Updated = true;
                                }
                                
                            }
                            
						}
						EditorGUILayout.EndHorizontal();
                        
					}
				}
				element.rotateToFlare = EditorGUILayout.Toggle("Rotate To Flare",element.rotateToFlare);
				element.rotationSpeed = EditorGUILayout.FloatField("Movement Based Rotation",element.rotationSpeed);
				element.rotationOverTime = EditorGUILayout.FloatField("Rotation Overtime Speed",element.rotationOverTime);
			}
		}
        EditorGUILayout.EndVertical();
	}
예제 #2
0
	public override void OnInspectorGUI () {
		
		selectionCount = 0;
		
		Flares.Clear();
		
		foreach(GameObject go in Selection.gameObjects){
		
			ProFlare selectedFlare = go.GetComponent<ProFlare>();
			if(selectedFlare){
				Flares.Add(selectedFlare);
				selectionCount++;
			}
		}
		
		if(selectionCount > 1){
			EditorGUILayout.HelpBox("Multiple Flares selected.", MessageType.Warning,false);
			//EditorGUI.showMixedValue = true;
		}
		
		_flare = target as ProFlare;
		
        CheckUndo();

#if UNITY_4_3
		EditorGUI.BeginChangeCheck();
#endif
		
		FlareEditorHelper.DrawGuiDivider();
		
		bool error = false;
		
		title =  FlareEditorHelper.TitleStyle();
		thinButton = FlareEditorHelper.ThinButtonStyle();
		enumStyleButton = FlareEditorHelper.EnumStyleButton();
		thinButtonRed = FlareEditorHelper.ThinButtonRedStyle();
		
		EditorGUILayout.LabelField("Flare Setup :",title);
		
		GUILayout.Space(10f);
		
		dropDownButton = FlareEditorHelper.DropDownButtonStyle();
		
	 
		if(selectionCount <= 1)
		{
		EditorGUILayout.BeginHorizontal();
		if((!_flare.EditingAtlas)&&(_flare._Atlas != null))
			GUI.enabled = false;
		
		ProFlareAtlas _Atlas = EditorGUILayout.ObjectField("Flare Atlas", _flare._Atlas, typeof(ProFlareAtlas), false) as ProFlareAtlas;
		
		GUI.enabled = true;
		
		if(_flare._Atlas)
			if(GUILayout.Button("EDIT",GUILayout.Width(60))){
				_flare.EditingAtlas = 	_flare.EditingAtlas ? false : true;		
			}
	 
		EditorGUILayout.EndHorizontal();
		
		if((_flare.EditingAtlas)&&(_flare._Atlas != null)){
			
			EditorGUILayout.HelpBox("Changing atlas can cause data loss if elements do NOT exist in the new atlas.", MessageType.Warning,false);
		}
		
		GUI.enabled = true;
		
		if(_flare._Atlas != _Atlas){
            
			_flare._Atlas = _Atlas;
            
			
			ProFlareBatch[] flareBatchs = GameObject.FindObjectsOfType(typeof(ProFlareBatch)) as ProFlareBatch[];
			
			int matchCount = 0;
			foreach(ProFlareBatch flareBatch in flareBatchs){
				if(flareBatch._atlas == _Atlas){
					matchCount++;
				}
			}
			_flare.FlareBatches = new ProFlareBatch[matchCount];
			int count = 0;
			foreach(ProFlareBatch flareBatch in flareBatchs){
				if(flareBatch._atlas == _Atlas){
					_flare.FlareBatches[count] = flareBatch;
					_flare.FlareBatches[count].dirty = true;
					count++;
				}
			}
			if(count != 0){
				if(_flare.Elements.Count == 0){
						ProFlareElement element = new ProFlareElement();
						element.flare = _flare;
						element.SpriteName = _flare._Atlas.elementsList[0].name;
						element.flareAtlas = _flare._Atlas;
						element.position = -1;
						element.Scale = 1;
						_flare.Elements.Add(element);
				}
			}
		}
		
		 
		bool missing = false;
		for(int i = 0; i < _flare.FlareBatches.Length; i++){
		
			if(_flare.FlareBatches[i] == null)
				missing = true;
		}
		if(missing){
		
			ProFlareBatch[] flareBatchs = GameObject.FindObjectsOfType(typeof(ProFlareBatch)) as ProFlareBatch[];
			
			int matchCount = 0;
			foreach(ProFlareBatch flareBatch in flareBatchs){
				if(flareBatch._atlas == _Atlas){
					matchCount++;
				}
			}
			_flare.FlareBatches = new ProFlareBatch[matchCount];
			int count = 0;
			foreach(ProFlareBatch flareBatch in flareBatchs){
				if(flareBatch._atlas == _Atlas){
					_flare.FlareBatches[count] = flareBatch;
					_flare.FlareBatches[count].dirty = true;
					count++;
				}
			}
		}
		
		EditorGUILayout.LabelField("Rendered by : ");
		if(_flare.FlareBatches.Length != 0)
			for(int i = 0; i < _flare.FlareBatches.Length; i++){
			EditorGUILayout.BeginHorizontal();
				EditorGUILayout.LabelField("   "+_flare.FlareBatches[i].gameObject.name); 
			if(GUILayout.Button("Select",GUILayout.Width(60))){ 
					Selection.activeGameObject = _flare.FlareBatches[i].gameObject;
			}
			EditorGUILayout.EndHorizontal();
			}
		
		if(error){
			EditorGUILayout.HelpBox("Fix Errors before continuing.", MessageType.Error);
		}
		}
		FlareEditorHelper.DrawGuiDivider();
		
		EditorGUILayout.LabelField("Global Settings :",title);
		GUILayout.Space(10f);
		
		Rect  r  = EditorGUILayout.BeginVertical("box");
		{
			Rect r2 = r;
			r2.height = 20;
            
			if (GUI.Button(r2, GUIContent.none,dropDownButton))
				_flare.EditGlobals = _flare.EditGlobals ? false : true;
			
		 	GUILayout.Label("General");
            
            if(_flare.EditGlobals){
				
				GUILayout.Space(5f);
				
				//Scale
				float _flareGlobalScale = EditorGUILayout.Slider("Scale",_flare.GlobalScale,0f,2000f);
				
				if(_flareGlobalScale != _flare.GlobalScale){
					
					_flare.GlobalScale = _flareGlobalScale;
					
					foreach(ProFlare flare in Flares){
						flare.GlobalScale = _flare.GlobalScale;
					}
				}
				
				float _flareGlobalBrightness = EditorGUILayout.Slider("Brightness",_flare.GlobalBrightness,0f,1f);
                
				if(_flareGlobalBrightness != _flare.GlobalBrightness){
					_flare.GlobalBrightness = _flareGlobalBrightness;
					_flare.GlobalTintColor.a = _flare.GlobalBrightness;
					
					foreach(ProFlare flare in Flares){
						flare.GlobalBrightness = _flareGlobalBrightness;
						flare.GlobalTintColor.a = _flare.GlobalBrightness;
					}
				}
				
				Color _flareGlobalTintColor = EditorGUILayout.ColorField("Tint",_flare.GlobalTintColor);
				
				if(_flareGlobalTintColor != _flare.GlobalTintColor){
					_flare.GlobalTintColor = _flareGlobalTintColor;
					_flare.GlobalBrightness = _flare.GlobalTintColor.a;
					
					foreach(ProFlare flare in Flares){
						flare.GlobalTintColor = _flareGlobalTintColor;
						flare.GlobalBrightness = _flare.GlobalTintColor.a;
					}
				}
				
				FlareEditorHelper.DrawGuiInBoxDivider();
                
				//Angle Falloff Options
				if(selectionCount <= 1){
				GUILayout.BeginHorizontal();
				{
					_flare.UseAngleLimit = EditorGUILayout.Toggle("Use Angle Falloff",_flare.UseAngleLimit);
					GUI.enabled = _flare.UseAngleLimit;
					_flare.maxAngle =  Mathf.Clamp(EditorGUILayout.FloatField("Max Angle",_flare.maxAngle),0,360);
				}
				GUILayout.EndHorizontal();
				
				_flare.UseAngleScale = EditorGUILayout.Toggle("  Affect Scale",_flare.UseAngleScale);
				
				_flare.UseAngleBrightness = EditorGUILayout.Toggle("  Affect Brightness",_flare.UseAngleBrightness);
				
				GUILayout.BeginHorizontal();
				{
					_flare.UseAngleCurve = EditorGUILayout.Toggle("  Use Curve",_flare.UseAngleCurve);
					GUI.enabled = _flare.UseAngleCurve;
					_flare.AngleCurve = EditorGUILayout.CurveField(_flare.AngleCurve);
					if(GUILayout.Button("Reset",GUILayout.MaxWidth(50))){ _flare.AngleCurve = new AnimationCurve(new Keyframe(0, 0f), new Keyframe(1, 1.0f));}
					GUI.enabled = true;
				}
				GUILayout.EndHorizontal();
				GUI.enabled = true;
                
				FlareEditorHelper.DrawGuiInBoxDivider();
				//Max Distance Options -
				GUILayout.BeginHorizontal();
				{
					_flare.useMaxDistance = EditorGUILayout.Toggle("Use Distance Falloff",_flare.useMaxDistance);
					GUI.enabled = _flare.useMaxDistance;
					_flare.GlobalMaxDistance = EditorGUILayout.FloatField("  Max Distance",_flare.GlobalMaxDistance);
				}
				GUILayout.EndHorizontal();
				_flare.useDistanceScale = EditorGUILayout.Toggle("  Affect Scale",_flare.useDistanceScale);
				_flare.useDistanceFade = EditorGUILayout.Toggle("  Affect Brightness",_flare.useDistanceFade);
                
				
                GUI.enabled = true;
				FlareEditorHelper.DrawGuiInBoxDivider();
				_flare.OffScreenFadeDist = EditorGUILayout.FloatField("Off Screen Fade Distance",_flare.OffScreenFadeDist);
									FlareEditorHelper.DrawGuiInBoxDivider();

				 _flare.neverCull = EditorGUILayout.Toggle("Never Cull Flare",_flare.neverCull);
				}
			}
		}
		
		EditorGUILayout.EndVertical();
		
		
		if(selectionCount <= 1)
		{
			r  = EditorGUILayout.BeginVertical("box");
			Rect r2 = r;
			r2.height = 20;
            
            
			if (GUI.Button(r2, GUIContent.none,dropDownButton))
				_flare.EditDynamicTriggering = _flare.EditDynamicTriggering ? false : true;
			
            
		 	GUILayout.Label("Dynamics Triggering");
			
			if(_flare.EditDynamicTriggering){GUILayout.Space(5f);
				
				_flare.useDynamicEdgeBoost = EditorGUILayout.Toggle("Use Dynamic Edge Boost",_flare.useDynamicEdgeBoost);
				GUI.enabled = _flare.useDynamicEdgeBoost;
				_flare.DynamicEdgeBoost = EditorGUILayout.FloatField("  Dynamic Edge Scale",_flare.DynamicEdgeBoost);
				_flare.DynamicEdgeBrightness = EditorGUILayout.FloatField("  Dynamic Edge Brightness",_flare.DynamicEdgeBrightness);
				_flare.DynamicEdgeRange = EditorGUILayout.FloatField("  Dynamic Edge Range",_flare.DynamicEdgeRange);
				_flare.DynamicEdgeBias = EditorGUILayout.FloatField("  Dynamic Edge Bias",_flare.DynamicEdgeBias);
				
				GUILayout.BeginHorizontal();
				{
                    _flare.DynamicEdgeCurve = EditorGUILayout.CurveField("  Dynamic Edge Curve", _flare.DynamicEdgeCurve);
                    if(GUILayout.Button("Reset",GUILayout.MaxWidth(50))) _flare.DynamicEdgeCurve = new AnimationCurve(new Keyframe(0, 0f), new Keyframe(0.5f, 1), new Keyframe(1, 0f));
				}
				GUILayout.EndHorizontal();
				GUI.enabled = true;
				FlareEditorHelper.DrawGuiInBoxDivider();
				
				_flare.useDynamicCenterBoost = EditorGUILayout.Toggle("Use Dynamic Center Boost",_flare.useDynamicCenterBoost);
				
				GUI.enabled = _flare.useDynamicCenterBoost;
				_flare.DynamicCenterRange = EditorGUILayout.FloatField("  Dynamic Center Range",_flare.DynamicCenterRange);
				_flare.DynamicCenterBoost = EditorGUILayout.FloatField("  Dynamic Center Scale",_flare.DynamicCenterBoost);
				_flare.DynamicCenterBrightness = EditorGUILayout.FloatField("  Dynamic Center Brightness",_flare.DynamicCenterBrightness);
				
				GUI.enabled = true;
			}
			
			EditorGUILayout.EndVertical();
		}
		
		
		if(selectionCount <= 1)
		{
			r  = EditorGUILayout.BeginVertical("box");
			Rect r2 = r;
			r2.height = 20;
            
            
			if (GUI.Button(r2, GUIContent.none,dropDownButton))
				_flare.EditOcclusion = _flare.EditOcclusion ? false : true;
			
            
		 	GUILayout.Label("Occlusion");
			
			if(_flare.EditOcclusion){GUILayout.Space(5f);
				_flare.RaycastPhysics = EditorGUILayout.Toggle("Raycast Against Physics",_flare.RaycastPhysics);
				GUI.enabled = _flare.RaycastPhysics;
				_flare.mask = LayerMaskField(_flare.mask);
				
				FlareEditorHelper.DrawGuiInBoxDivider();
				EditorGUILayout.LabelField("Debug Info :");
				EditorGUILayout.Toggle("  Flare Occluded",_flare.Occluded);
				EditorGUILayout.ObjectField("  Occluding GameObject", _flare.OccludingObject, typeof(GameObject), true);
				GUI.enabled = true;
			}
			EditorGUILayout.EndVertical();
		}
		
		
		
		FlareEditorHelper.DrawGuiDivider();
		
		EditorGUILayout.LabelField("Element Settings :",title);
		GUILayout.Space(10f);
		
		if(selectionCount > 1){
			EditorGUILayout.HelpBox("Editing flare elements is not supported in while multiple flares selected.", MessageType.Warning,false);
		}else{
		 	if(_flare._Atlas != null)
	            for(int i = 0; i < _flare.Elements.Count;i++)
	                ElementEditor(_flare.Elements[i],(i+1));
			
			
			if(_flare._Atlas != null)
			if(GUILayout.Button("ADD NEW",thinButton)){
				ProFlareElement element = new ProFlareElement();
				
				element.flare = _flare;
				element.SpriteName = _flare._Atlas.elementsList[0].name;
				element.flareAtlas = _flare._Atlas;
				element.position = -1;
				element.Scale = 1;
				
				for(int i = 0; i < _flare.FlareBatches.Length; i++){
					_flare.FlareBatches[i].dirty = true;
				}
				//_flare._FlareBatch.dirty = true;
				_flare.Elements.Add(element);
			}
		}
		FlareEditorHelper.DrawGuiDivider();
        
		if (GUI.changed||Updated)
        {
			//Debug.Log("dirty:");
			Updated = false;
			guiChanged = true;
            EditorUtility.SetDirty (target);
			
			if(selectionCount > 1)
				foreach(GameObject go in Selection.gameObjects){
		
					ProFlare selectedFlare = go.GetComponent<ProFlare>();
					if(selectedFlare)
						EditorUtility.SetDirty(selectedFlare);
				}
        }
	}
예제 #3
0
	void ScaleOptions(ProFlareElement element,int count){
        
		Rect  r  = EditorGUILayout.BeginVertical("box");
		Rect r2 = r;
		r2.height = 20;
		
		
		if (GUI.Button(r2, GUIContent.none,dropDownButton))
            element.ScaleSetting = element.ScaleSetting ? false : true;
		
		
		GUILayout.Label("Scale Options");
		
		{
			if(element.ScaleSetting){
				
				GUILayout.Space(5f);
				
				EditorGUILayout.BeginHorizontal();
				{
                    EditorGUILayout.LabelField("Scale");
                    element.Scale = EditorGUILayout.Slider(element.Scale,0f,5f);
				}
				EditorGUILayout.EndHorizontal();
				
				//EditorGUILayout.BeginHorizontal();
				{
                    EditorGUILayout.LabelField("Aspect",GUILayout.MinWidth(120));
                    element.size.x = Mathf.Max(0f, EditorGUILayout.FloatField("   X", element.size.x));
                    element.size.y = Mathf.Max(0f, EditorGUILayout.FloatField("   Y",element.size.y));
				}
				//EditorGUILayout.EndHorizontal();
				
				
				
				
				if(element.type == ProFlareElement.Type.Multi){
					
					element.ScaleRandom = EditorGUILayout.Slider("Random Scale",element.ScaleRandom,0,1f);
					
					EditorGUILayout.BeginHorizontal();
                    {
                        
                        element.useScaleCurve = EditorGUILayout.Toggle("Use Scale Range",element.useScaleCurve,GUILayout.MaxWidth(180));
                        
                        GUI.enabled = element.useScaleCurve;
                        
                        if(element.useScaleCurve)
                            Updated = true;
                        
                        if(element.type == ProFlareElement.Type.Multi){
                            element.ScaleCurve = EditorGUILayout.CurveField(element.ScaleCurve);
                        }
                        
                        if(GUILayout.Button("Reset",GUILayout.MaxWidth(50))){
                            element.ScaleCurve = new AnimationCurve(new Keyframe(0, 0.1f), new Keyframe(0.5f, 1.0f), new Keyframe(1.0f, 0.1f));
                        }
                        
                        GUI.enabled =  true;
					}
					EditorGUILayout.EndHorizontal();
				}
            }
		}
		
		if(element.type == ProFlareElement.Type.Multi){
            for(int i = 0; i < element.subElements.Count; i++){
             	if(element.useScaleCurve)
					element.subElements[i].scale =  (1+element.subElements[i].RandomScaleSeed*(element.ScaleRandom))*element.ScaleCurve.Evaluate(element.subElements[i].random);
				else
					element.subElements[i].scale = (1+element.subElements[i].RandomScaleSeed*(element.ScaleRandom));
            }
        }
		
        EditorGUILayout.EndVertical();
	}
예제 #4
0
	void ColorOptions(ProFlareElement element,int count){
        
		Rect  r  = EditorGUILayout.BeginVertical("box");
		Rect r2 = r;
		r2.height = 20;
		
		
		if (GUI.Button(r2, GUIContent.none,dropDownButton))
            element.ColorSetting = element.ColorSetting ? false : true;
        
		
		GUILayout.Label("Color Options");
		{
			
			if(element.ColorSetting){
				GUILayout.Space(5f);
                if(element.type == ProFlareElement.Type.Single){
                    element.ElementTint = EditorGUILayout.ColorField("Tint",element.ElementTint);
                    
				}else{
                    
					EditorGUILayout.BeginHorizontal();
                    {
                        
                        element.useColorRange = EditorGUILayout.Toggle("Use Color Tint Range",element.useColorRange);
                        
                        if(!element.useColorRange){
                            element.ElementTint = EditorGUILayout.ColorField("Tint",element.ElementTint);
                        }else{
                            element.SubElementColor_Start = EditorGUILayout.ColorField(element.SubElementColor_Start);
                            element.SubElementColor_End = EditorGUILayout.ColorField(element.SubElementColor_End);
                        }
					}
					EditorGUILayout.EndHorizontal();
					
					EditorGUILayout.LabelField("Color Random");
					element.RandomColorAmount.x = EditorGUILayout.Slider("  R",element.RandomColorAmount.x,0f,1f);
					element.RandomColorAmount.y = EditorGUILayout.Slider("  G",element.RandomColorAmount.y,0f,1f);
					element.RandomColorAmount.z = EditorGUILayout.Slider("  B",element.RandomColorAmount.z,0f,1f);
					element.RandomColorAmount.w = EditorGUILayout.Slider("  Brightness",element.RandomColorAmount.w,0f,1f);
                }
			}
			
			if(element.type == ProFlareElement.Type.Single){
                
			}else{
				if(!element.useColorRange){
                    
                    for(int i = 0; i < element.subElements.Count; i++){
                        Color col = element.ElementTint;
                        
                        col.r = Mathf.Clamp01( col.r+(element.RandomColorAmount.x*element.subElements[i].RandomColorSeedR));
                        col.g = Mathf.Clamp01( col.g+(element.RandomColorAmount.y*element.subElements[i].RandomColorSeedG));
                        col.b = Mathf.Clamp01( col.b+(element.RandomColorAmount.z*element.subElements[i].RandomColorSeedB));
                        col.a = Mathf.Clamp01( col.a+(element.RandomColorAmount.w*element.subElements[i].RandomColorSeedA));
                        
                        element.subElements[i].color = col;
                    }
                }else{
                    
                    for(int i = 0; i < element.subElements.Count; i++){
                        Color col =  Color.Lerp(element.SubElementColor_Start,element.SubElementColor_End,element.subElements[i].random);
                        
                        col.r = Mathf.Clamp01(col.r+(element.RandomColorAmount.x*element.subElements[i].RandomColorSeedR));
                        col.g = Mathf.Clamp01(col.g+(element.RandomColorAmount.y*element.subElements[i].RandomColorSeedG));
                        col.b = Mathf.Clamp01(col.b+(element.RandomColorAmount.z*element.subElements[i].RandomColorSeedB));
                        col.a = Mathf.Clamp01(col.a+(element.RandomColorAmount.w*element.subElements[i].RandomColorSeedA));
                        
                        element.subElements[i].color = col;
                    }
                    
                }
			}
		}
		EditorGUILayout.EndVertical();
	}
예제 #5
0
	void OffsetOptions(ProFlareElement element,int count){
        
		Rect  r  = EditorGUILayout.BeginVertical("box");
		Rect r2 = r;
		r2.height = 20;
		
		
		if (GUI.Button(r2, GUIContent.none,dropDownButton))
            element.OffsetSetting = element.OffsetSetting ? false : true;
		
		
		GUILayout.Label("Offset Options");
        
		{
			if(element.OffsetSetting){
                GUILayout.Space(5f);
                if(element.type == ProFlareElement.Type.Single){
                    element.position = EditorGUILayout.Slider("OffSet",element.position,-1.5f,2.5f);
                    
                }else{
                    
                    EditorGUILayout.BeginHorizontal();
                    {
                        
                        element.useRangeOffset = EditorGUILayout.Toggle("Use offset range",element.useRangeOffset);
                        
                        if(element.useRangeOffset){
                            
                            float minTemp = element.SubElementPositionRange_Min;
                            float maxTemp = element.SubElementPositionRange_Max;
                            
                            
                            EditorGUILayout.MinMaxSlider(ref  element.SubElementPositionRange_Min ,ref element.SubElementPositionRange_Max,-4.5f,4.5f);
                            
                            if((minTemp != element.SubElementPositionRange_Min)||(maxTemp != element.SubElementPositionRange_Max)||Updated){
                                
                            }
                            
                            for(int i = 0; i < element.subElements.Count; i++){
                                element.subElements[i].position = Mathf.Lerp(element.SubElementPositionRange_Min,element.SubElementPositionRange_Max,element.subElements[i].random);
                                element.subElements[i].scale = Mathf.Lerp(-100f,100f,element.subElements[i].random2);
                                Updated = true;
                            }
                            
                            EditorGUILayout.FloatField(element.SubElementPositionRange_Min,GUILayout.MaxWidth(30));
                            
                            EditorGUILayout.FloatField(element.SubElementPositionRange_Max,GUILayout.MaxWidth(30));
                            
                        }else{
                            element.position = EditorGUILayout.Slider(element.position,-1.5f,2.5f);
                        }
					}
                    EditorGUILayout.EndHorizontal();
                }
				
                
				EditorGUILayout.LabelField("Anamorphic");
				float x = EditorGUILayout.Slider("Vertical ",element.Anamorphic.x,0f,1f);
				float y = EditorGUILayout.Slider("Horizontal ",element.Anamorphic.y,0f,1f);
				element.Anamorphic = new Vector2(x,y);
				
                
                element.OffsetPostion = EditorGUILayout.Vector2Field("Position Offset", element.OffsetPostion);
                
			}
			
			if(element.type == ProFlareElement.Type.Single){
				
			}
			if(element.type == ProFlareElement.Type.Multi){
				for(int i = 0; i < element.subElements.Count; i++){
                    element.subElements[i].position = Mathf.Lerp(element.SubElementPositionRange_Min,element.SubElementPositionRange_Max,element.subElements[i].random);
                    element.subElements[i].scale = Mathf.Lerp(-100f,100f,element.subElements[i].random2);
                }
			}
			
		}EditorGUILayout.EndVertical();
	}
예제 #6
0
	void QuickEdit(ProFlareElement element,int count){
        
		EditorGUILayout.BeginVertical("box");
        
		EditorGUILayout.BeginHorizontal();
        {
            GUILayout.Label("Quick Edit -",GUILayout.MaxWidth(80));
            
            element.Scale = EditorGUILayout.Slider(element.Scale,0f,5f,GUILayout.MaxWidth(180));
			GUILayout.FlexibleSpace();
            if(!element.useColorRange){
                element.ElementTint = EditorGUILayout.ColorField(element.ElementTint,GUILayout.MaxWidth(60));
                
                if(GUI.changed)
                    element.colorTextureDirty = true;
                
              //  byte TintA = (byte)EditorGUILayout.Slider(element.Tint.a,0f,1f,GUILayout.MaxWidth(180));
				
              //  if(TintA != element.Tint.a){
              //      element.Tint.a = TintA;
              //  }
				
				float TintA = EditorGUILayout.Slider(element.ElementTint.a,0f,1f,GUILayout.MaxWidth(180));
				
                 if(TintA != element.ElementTint.a){
                     element.ElementTint.a = TintA;
                 }
                
            }else{
                element.SubElementColor_Start = EditorGUILayout.ColorField(element.SubElementColor_Start,GUILayout.MaxWidth(60));
                element.SubElementColor_End = EditorGUILayout.ColorField(element.SubElementColor_End,GUILayout.MaxWidth(60));

                if(GUI.changed)
                    element.colorTextureDirty = true;
                
                for(int i = 0; i < element.subElements.Count; i++){
                    element.subElements[i].color =	Color.Lerp(element.SubElementColor_Start,element.SubElementColor_End,element.subElements[i].random);
                }
            }
		}
		
		EditorGUILayout.EndHorizontal();
		
		EditorGUILayout.EndVertical();
	}
예제 #7
0
	void ElementOptions(ProFlareElement element,int count){
		
		Rect  r  = EditorGUILayout.BeginVertical("box");
		Rect r2 = r;
	
		r2.height = 20;

		if (GUI.Button(r2, GUIContent.none,dropDownButton))
            element.ElementSetting = element.ElementSetting ? false : true;
        
		GUILayout.Label("Multi Element Options");
        
		if(!element.ElementSetting){
			EditorGUILayout.EndVertical();
			return;
		}
		
		GUILayout.Space(5f);
		
		if(element.type == ProFlareElement.Type.Multi){
            
			EditorGUILayout.BeginHorizontal();
            {
                
                EditorGUILayout.LabelField("Sub Elements Count : "+element.subElements.Count);
                
                if(GUILayout.Button("+")){
                    SubElement sub = new SubElement();
                    
                    sub.random = Random.Range(0f,1f);
                    sub.random2 = Random.Range(0f,1f);
					 
                    sub.RandomScaleSeed = Random.Range(-1f,1f);
                    sub.RandomColorSeedR = Random.Range(-1f,1f);
                    sub.RandomColorSeedG = Random.Range(-1f,1f);
                    sub.RandomColorSeedB = Random.Range(-1f,1f);
                    sub.RandomColorSeedA = Random.Range(-1f,1f);
                    
                    element.subElements.Add(sub);
                     
                    for(int f = 0; f < element.flare.FlareBatches.Length; f++){ 
						element.flare.FlareBatches[f].dirty = true;
					}
                }
                if(GUILayout.Button("-")){
                    //SubElement sub = new SubElement();
                    if(element.subElements.Count > 0){
                        element.subElements.Remove(element.subElements[element.subElements.Count-1]);
                        
                        
                        for(int f = 0; f < element.flare.FlareBatches.Length; f++){ 
							element.flare.FlareBatches[f].dirty = true;
						}
                    }
                }
                
                if(GUILayout.Button("Update Random Seed")){
                    for(int i = 0; i < element.subElements.Count; i++){
                        Updated = true;
                        element.subElements[i].random = Random.Range(0f,1f);
                        element.subElements[i].random2 = Random.Range(0f,1f);
                        element.subElements[i].RandomScaleSeed = Random.Range(-1f,1f);
                        element.subElements[i].RandomColorSeedR = Random.Range(-1f,1f);
                        element.subElements[i].RandomColorSeedG = Random.Range(-1f,1f);
                        element.subElements[i].RandomColorSeedB = Random.Range(-1f,1f);
                        element.subElements[i].RandomColorSeedA = Random.Range(-1f,1f);
                    }
                }
			}
			EditorGUILayout.EndHorizontal();
		}
        EditorGUILayout.EndVertical();
	}
예제 #8
0
	void ElementEditor(ProFlareElement element,int count){
		
		ProFlareElement.Type elementType;
		
		EditorGUILayout.BeginHorizontal();
		{
            //
			if(GUILayout.Button("      ",thinButton,GUILayout.MaxWidth(35))){
                
			}
			if(GUILayout.Button(" ",thinButton,GUILayout.MaxWidth(32)))
				element.Visible = element.Visible ? false : true;
			
			
			Rect rect2 = GUILayoutUtility.GetLastRect();
			
			int extra = 0;
#if UNITY_4_3
			extra = 15;
#endif
			
			Rect outerRect = new Rect(35+extra,rect2.yMin-4,32,32);
		 	Rect final = new Rect(0,0,1,1);
			
			
			if( visibility_On == null) {
				visibility_On = Resources.Load("visibility-On") as Texture2D;
			}
			if( visibility_Off == null) {
				visibility_Off = Resources.Load("visibility-Off") as Texture2D;
			}
			
			if(element.Visible)
				GUI.DrawTextureWithTexCoords(outerRect,visibility_On, final, true);
			else
				GUI.DrawTextureWithTexCoords(outerRect,visibility_Off, final, true);
			
			_flare._Atlas.UpdateElementNameList();
			
			int id = EditorGUILayout.Popup(element.elementTextureID, _flare._Atlas.elementNameList,enumStyleButton,GUILayout.MaxWidth(200));
			
			
			if(element.elementTextureID != id){
				
				Debug.Log("Changing Sprite " + element.flareAtlas.elementsList[id].name);
				
				element.elementTextureID = id;
				element.SpriteName = element.flareAtlas.elementsList[id].name;
 
				for(int f = 0; f < element.flare.FlareBatches.Length; f++){ 
						element.flare.FlareBatches[f].dirty = true;
				}
			}
			
			
			elementType = (ProFlareElement.Type)EditorGUILayout.EnumPopup(element.type,enumStyleButton,GUILayout.MaxWidth(100));
            
			if(GUILayout.Button("EDIT",thinButton,GUILayout.MaxWidth(80))){
				if(element.Editing)
					element.Editing = false;
				else{
					
                    element.ElementSetting = false;
                    element.OffsetSetting = false;
                    element.ColorSetting = false;
                    element.ScaleSetting = false;
                    element.RotationSetting = false;
					element.OverrideSetting = false;
					
					element.Editing = true;
				}
			}
			
			if(GUILayout.Button("CLONE",thinButton)){
				element.Editing = false;
				_flare.Elements.Add(CloneElement(element));
				//_flare._FlareBatch.dirty = true;
				for(int i = 0; i < _flare.FlareBatches.Length; i++){
					_flare.FlareBatches[i].dirty = true;	
				}
			}
            
			
			if(GUILayout.Button("REMOVE",thinButtonRed)){
				for(int i = 0; i < _flare.FlareBatches.Length; i++){
					_flare.FlareBatches[i].dirty = true;	
				}
//				element.flare._FlareBatch.dirty = true;
				element.flare.Elements.Remove(element);
				return;
			}
		}
		EditorGUILayout.EndHorizontal();
		//Preview Texture Renderer
		{
			int extra = 0;
			#if UNITY_4_3
			extra = 15;
			#endif

			Rect rect2 = GUILayoutUtility.GetLastRect();
			
			Rect outerRect = new Rect(10+extra,rect2.yMin+1,22,22);
			
			if(_flare._Atlas)
				if(_flare._Atlas.texture)
					if((element.elementTextureID < _flare._Atlas.elementsList.Count))
						GUI.DrawTextureWithTexCoords(outerRect, _flare._Atlas.texture, _flare._Atlas.elementsList[element.elementTextureID].UV, false);
		}
        
		{
			if((element.colorTexture == null)||element.colorTextureDirty){
				if(element.useColorRange)
					element.colorTexture = CreateGradientTex(element,element.SubElementColor_Start,element.SubElementColor_End);
				else
					element.colorTexture = CreateGradientTex(element,element.ElementTint,element.ElementTint);
			}

			int extra = 0;
			#if UNITY_4_3
			extra = 15;
			#endif
			
			Rect rect2 = GUILayoutUtility.GetLastRect();
			Rect outerRect = new Rect(3+extra,rect2.yMin+1,6,22);
		 	Rect UV = new Rect(0,0,1,1);
			
			GUI.DrawTextureWithTexCoords(outerRect, element.colorTexture, UV, false);
			
		}
		
		if(element.type != elementType){
			element.type = elementType;
			
			
			switch(elementType){
				case(ProFlareElement.Type.Single):
                    break;
				case(ProFlareElement.Type.Multi):
                    
                    if(element.subElements.Count == 0)
                    {
						for(int i = 0; i < 5; i++){
	                        SubElement sub = new SubElement();
	                        sub.random = Random.Range(0f,1f);
	                        sub.random2 = Random.Range(0f,1f);
	                        sub.RandomColorSeedR = Random.Range(-1f,1f);
	                        sub.RandomColorSeedG = Random.Range(-1f,1f);
	                        sub.RandomColorSeedB = Random.Range(-1f,1f);
	                        element.subElements.Add(sub);
						}
						element.useRangeOffset = true;
						element.Editing = true;
                    }
                    break;
			}
			
			for(int f = 0; f < element.flare.FlareBatches.Length; f++){ 
					element.flare.FlareBatches[f].dirty = true;
			}
		}
		
 		if(element.Editing ){
	  		QuickEdit(element,count);
			
			if(element.type == ProFlareElement.Type.Multi)
 			   	ElementOptions(element,count);
			
 	 	  	OffsetOptions(element,count);
 	 	 	ColorOptions(element,count);
 	 	 	ScaleOptions(element,count);
 	 	 	RotationOptions(element,count);
 	 		OverrideOptions(element,count);
		}
	}
예제 #9
0
	ProFlareElement CloneElement(ProFlareElement element){
		
		ProFlareElement _element = new ProFlareElement();
		
		_element.Editing = true;
        
        _element.Visible = element.Visible;
        
        _element.elementTextureID = element.elementTextureID;
        
        _element.SpriteName = element.SpriteName;
        
        _element.flare = element.flare;
        
        _element.flareAtlas = element.flareAtlas;
        
        _element.Brightness = element.Brightness;
        _element.Scale = element.Scale;
        _element.ScaleRandom = element.ScaleRandom;
        _element.ScaleFinal = element.ScaleFinal;
        
        _element.RandomColorAmount = element.RandomColorAmount;
        
        //Element OffSet Properties
        _element.position = element.position;
        
        _element.useRangeOffset = element.useRangeOffset;
        
        _element.SubElementPositionRange_Min = element.SubElementPositionRange_Min;
        _element.SubElementPositionRange_Max = element.SubElementPositionRange_Max;
        
        _element.SubElementAngleRange_Min = element.SubElementAngleRange_Min;
        _element.SubElementAngleRange_Max = element.SubElementAngleRange_Max;
        
        
        _element.OffsetPosition = element.OffsetPosition;
        
        _element.Anamorphic = element.Anamorphic;
        
        _element.OffsetPostion = element.OffsetPostion;
        
        _element.angle = element.angle;
        _element.FinalAngle = element.FinalAngle;
        _element.useRandomAngle = element.useRandomAngle;
        _element.useStarRotation = element.useStarRotation;
        _element.AngleRandom_Min = element.AngleRandom_Min;
        _element.AngleRandom_Max = element.AngleRandom_Max;
        _element.OrientToSource = element.OrientToSource;
        _element.rotateToFlare = element.rotateToFlare;
        _element.rotationSpeed = element.rotationSpeed;
        _element.rotationOverTime = element.rotationOverTime;
        
        _element.useColorRange = element.useColorRange;
        
        _element.ElementFinalColor = element.ElementFinalColor;
        
        _element.ElementTint = element.ElementTint;
        
        _element.SubElementColor_Start = element.SubElementColor_Start;
        _element.SubElementColor_End = element.SubElementColor_End;
        
        _element.useScaleCurve = element.useScaleCurve;
        _element.ScaleCurve = new AnimationCurve(element.ScaleCurve.keys);
        
	
        _element.OverrideDynamicEdgeBoost = element.OverrideDynamicEdgeBoost;
        _element.DynamicEdgeBoostOverride = element.DynamicEdgeBoostOverride;
        
        _element.OverrideDynamicCenterBoost = element.OverrideDynamicCenterBoost;
        _element.DynamicCenterBoostOverride = element.DynamicCenterBoostOverride;
        
        _element.OverrideDynamicEdgeBrightness = element.OverrideDynamicEdgeBrightness;
        _element.DynamicEdgeBrightnessOverride = element.DynamicEdgeBrightnessOverride;
        
        _element.OverrideDynamicCenterBrightness = element.OverrideDynamicCenterBrightness;
        _element.DynamicCenterBrightnessOverride = element.DynamicCenterBrightnessOverride;
        
        _element.size = element.size;
        
        for(int i = 0; i < element.subElements.Count; i++){
            
            SubElement Sub = new SubElement();
            
            Sub.color = element.subElements[i].color;
            Sub.position = element.subElements[i].position;
            Sub.offset = element.subElements[i].offset;
            Sub.angle = element.subElements[i].angle;
            Sub.scale = element.subElements[i].scale;
            Sub.random = element.subElements[i].random;
            Sub.random2= element.subElements[i].random2;
            
			
            Sub.RandomScaleSeed = element.subElements[i].RandomScaleSeed;
            Sub.RandomColorSeedR = element.subElements[i].RandomColorSeedR;
            Sub.RandomColorSeedG = element.subElements[i].RandomColorSeedG;
            Sub.RandomColorSeedB = element.subElements[i].RandomColorSeedB;
            Sub.RandomColorSeedA = element.subElements[i].RandomColorSeedA;
			
            _element.subElements.Add(Sub);
        }
        
        _element.type = element.type;
		
		return  _element;
		
	}
예제 #10
0
	Texture2D CreateGradientTex (ProFlareElement element, Color c0, Color c1)
	{
		if(element.colorTexture != null){
			DestroyImmediate(element.colorTexture);
			element.colorTexture = null;
		}
		
		element.colorTexture = new Texture2D(1, 16);
		element.colorTexture.name = "[ProFlare] Gradient Texture";
		element.colorTexture.hideFlags = HideFlags.DontSave;
        
        
		for (int i = 0; i < 16; ++i)
		{
			float f = i*(1f/16f);
			element.colorTexture.SetPixel(0, i, Color.Lerp(c0, c1, f));
		}
        
		element.colorTexture.Apply();
		element.colorTexture.filterMode = FilterMode.Bilinear;
		return element.colorTexture;
	}
예제 #11
0
	void OverrideOptions(ProFlareElement element,int count){
        
		
		Rect  r  = EditorGUILayout.BeginVertical("box");
		Rect r2 = r;
		r2.height = 20;
		
		
		if (GUI.Button(r2, GUIContent.none,dropDownButton))
            element.OverrideSetting = element.OverrideSetting ? false : true;
		
		
		GUILayout.Label("Override Options");
		{
			
			if(element.OverrideSetting){
				GUILayout.Space(5f);
				GUI.enabled = element.flare.useDynamicEdgeBoost;
				EditorGUILayout.BeginHorizontal();
				{
                    element.OverrideDynamicEdgeBoost = EditorGUILayout.Toggle("Dynamic Edge Scale",element.OverrideDynamicEdgeBoost);
					GUILayout.FlexibleSpace();
                    if(element.OverrideDynamicEdgeBoost)
                        element.DynamicEdgeBoostOverride = EditorGUILayout.FloatField("    ",element.DynamicEdgeBoostOverride);
				}
				EditorGUILayout.EndHorizontal();
				
				EditorGUILayout.BeginHorizontal();{
                    element.OverrideDynamicEdgeBrightness = EditorGUILayout.Toggle("Dynamic Edge Brightness",element.OverrideDynamicEdgeBrightness);
                    
                    if(element.OverrideDynamicEdgeBrightness)
                        element.DynamicEdgeBrightnessOverride = EditorGUILayout.FloatField("    ",element.DynamicEdgeBrightnessOverride);
				}
				EditorGUILayout.EndHorizontal();
				
				GUI.enabled = true;
				GUI.enabled = element.flare.useDynamicCenterBoost;
				
				EditorGUILayout.BeginHorizontal();
				{
                    element.OverrideDynamicCenterBoost = EditorGUILayout.Toggle("Dynamic Center Scale",element.OverrideDynamicCenterBoost);
                    
                    if(element.OverrideDynamicCenterBoost)
                        element.DynamicCenterBoostOverride = EditorGUILayout.FloatField("    ",element.DynamicCenterBoostOverride);
				}
				EditorGUILayout.EndHorizontal();
				
				
				EditorGUILayout.BeginHorizontal();
				{
                    element.OverrideDynamicCenterBrightness = EditorGUILayout.Toggle("Dynamic Center Brightness",element.OverrideDynamicCenterBrightness);
                    
                    if(element.OverrideDynamicCenterBrightness)
                        element.DynamicCenterBrightnessOverride = EditorGUILayout.FloatField("    ",element.DynamicCenterBrightnessOverride);
				}
				EditorGUILayout.EndHorizontal();
				
				GUI.enabled = true;
			}
			
		}
		EditorGUILayout.EndVertical();
	}
예제 #12
0
    public static void LoadFlareData(ProFlare flare, TextAsset asset)
    {
        string jsonString = asset.text;

//		Debug.Log ("LoadFlareData");

        Hashtable decodedHash = jsonDecode(jsonString) as Hashtable;

        if (decodedHash == null)
        {
            Debug.LogWarning("Unable to parse Json file: " + asset.name);
            return;
        }

        Hashtable meta = (Hashtable)decodedHash["meta"];

        flare.GlobalScale = float.Parse(meta["GlobalScale"].ToString());

        flare.GlobalBrightness = float.Parse(meta["GlobalBrightness"].ToString());

        flare.GlobalTintColor = FlareJson.decodeColor((Hashtable)meta["GlobalTintColor"]);

        flare.MultiplyScaleByTransformScale = FlareJson.decodeBool(meta["MultiplyScaleByTransformScale"].ToString());

        //Distance Fall off
        flare.useMaxDistance = FlareJson.decodeBool(meta["useMaxDistance"].ToString());

        flare.useDistanceScale = FlareJson.decodeBool(meta["useDistanceScale"].ToString());

        flare.useDistanceFade = FlareJson.decodeBool(meta["useDistanceFade"].ToString());

        flare.GlobalMaxDistance = float.Parse(meta["GlobalMaxDistance"].ToString());


        //Angle Culling Properties
        flare.UseAngleLimit = FlareJson.decodeBool(meta["UseAngleLimit"].ToString());

        flare.maxAngle = float.Parse(meta["maxAngle"].ToString());

        flare.UseAngleScale = FlareJson.decodeBool(meta["UseAngleScale"].ToString());

        flare.UseAngleBrightness = FlareJson.decodeBool(meta["UseAngleBrightness"].ToString());

        flare.UseAngleCurve = FlareJson.decodeBool(meta["UseAngleCurve"].ToString());

        flare.AngleCurve = FlareJson.decodeAnimCurve((Hashtable)meta ["AngleCurve"]);

        //			public LayerMask mask = 1;

        flare.RaycastPhysics = FlareJson.decodeBool(meta["RaycastPhysics"].ToString());

        flare.OffScreenFadeDist = float.Parse(meta["OffScreenFadeDist"].ToString());

        flare.useDynamicEdgeBoost = FlareJson.decodeBool(meta["useDynamicEdgeBoost"].ToString());

        flare.DynamicEdgeBoost = float.Parse(meta["DynamicEdgeBoost"].ToString());

        flare.DynamicEdgeBrightness = float.Parse(meta["DynamicEdgeBrightness"].ToString());

        flare.DynamicEdgeRange = float.Parse(meta["DynamicEdgeRange"].ToString());

        flare.DynamicEdgeBias = float.Parse(meta["DynamicEdgeBias"].ToString());

        flare.DynamicEdgeCurve = FlareJson.decodeAnimCurve((Hashtable)meta ["DynamicEdgeCurve"]);

        flare.useDynamicCenterBoost = FlareJson.decodeBool(meta["useDynamicCenterBoost"].ToString());

        flare.DynamicCenterBoost = float.Parse(meta["DynamicCenterBoost"].ToString());

        flare.DynamicCenterBrightness = float.Parse(meta["DynamicCenterBrightness"].ToString());

        flare.DynamicCenterRange = float.Parse(meta["DynamicCenterRange"].ToString());

        flare.DynamicCenterBias = float.Parse(meta["DynamicCenterBias"].ToString());

        flare.neverCull = FlareJson.decodeBool(meta["neverCull"].ToString());

        flare.Elements.Clear();

        Hashtable elements = (Hashtable)meta["Elements"];

        foreach (System.Collections.DictionaryEntry item in elements)
        {
            Hashtable element = (Hashtable)elements[item.Key];

            ProFlareElement elementNew = new ProFlareElement();

            elementNew.Editing = FlareJson.decodeBool(element["Editing"].ToString());

            elementNew.Visible = FlareJson.decodeBool(element["Visible"].ToString());

            elementNew.SpriteName = element["SpriteName"].ToString();

            elementNew.flare = flare;

            elementNew.flareAtlas = flare._Atlas;

            elementNew.Brightness = float.Parse(element["Brightness"].ToString());

            elementNew.Scale = float.Parse(element["Scale"].ToString());

            elementNew.ScaleRandom = float.Parse(element["ScaleRandom"].ToString());

            elementNew.ScaleFinal = float.Parse(element["ScaleFinal"].ToString());

            elementNew.RandomColorAmount = FlareJson.decodeVector4((Hashtable)element["RandomColorAmount"]);

//			//Element OffSet Properties
            elementNew.position = float.Parse(element["position"].ToString());

            elementNew.useRangeOffset = FlareJson.decodeBool(element["useRangeOffset"].ToString());

            elementNew.SubElementPositionRange_Min = float.Parse(element["SubElementPositionRange_Min"].ToString());

            elementNew.SubElementPositionRange_Max = float.Parse(element["SubElementPositionRange_Max"].ToString());

            elementNew.SubElementAngleRange_Min = float.Parse(element["SubElementAngleRange_Min"].ToString());

            elementNew.SubElementAngleRange_Max = float.Parse(element["SubElementAngleRange_Max"].ToString());

            elementNew.OffsetPosition = FlareJson.decodeVector3((Hashtable)element["OffsetPosition"]);

            elementNew.Anamorphic = FlareJson.decodeVector3((Hashtable)element["Anamorphic"]);

            elementNew.OffsetPostion = FlareJson.decodeVector3((Hashtable)element["OffsetPostion"]);

//			//Element Rotation Properties
            elementNew.angle = float.Parse(element["angle"].ToString());

            elementNew.useRandomAngle = FlareJson.decodeBool(element["useRandomAngle"].ToString());

            elementNew.useStarRotation = FlareJson.decodeBool(element["useStarRotation"].ToString());

            elementNew.AngleRandom_Min = float.Parse(element["AngleRandom_Min"].ToString());

            elementNew.AngleRandom_Max = float.Parse(element["AngleRandom_Max"].ToString());

            elementNew.OrientToSource = FlareJson.decodeBool(element["OrientToSource"].ToString());

            elementNew.rotateToFlare = FlareJson.decodeBool(element["rotateToFlare"].ToString());

            elementNew.rotationSpeed = float.Parse(element["rotationSpeed"].ToString());

            elementNew.rotationOverTime = float.Parse(element["rotationOverTime"].ToString());

//			//Colour Properties,
            elementNew.useColorRange = FlareJson.decodeBool(element["useColorRange"].ToString());

            elementNew.OffsetPosition = FlareJson.decodeVector3((Hashtable)element["OffsetPosition"]);

            elementNew.ElementTint = FlareJson.decodeColor((Hashtable)element["ElementTint"]);

            elementNew.SubElementColor_Start = FlareJson.decodeColor((Hashtable)element["SubElementColor_Start"]);

            elementNew.SubElementColor_End = FlareJson.decodeColor((Hashtable)element["SubElementColor_End"]);

//			//Scale Curve
            elementNew.useScaleCurve = FlareJson.decodeBool(element["useScaleCurve"].ToString());

            elementNew.ScaleCurve = FlareJson.decodeAnimCurve((Hashtable)element ["ScaleCurve"]);

//			//Override Properties
            elementNew.OverrideDynamicEdgeBoost = FlareJson.decodeBool(element["OverrideDynamicEdgeBoost"].ToString());

            elementNew.DynamicEdgeBoostOverride = float.Parse(element["DynamicEdgeBoostOverride"].ToString());

            elementNew.OverrideDynamicCenterBoost = FlareJson.decodeBool(element["OverrideDynamicCenterBoost"].ToString());

            elementNew.DynamicCenterBoostOverride = float.Parse(element["DynamicCenterBoostOverride"].ToString());

            elementNew.OverrideDynamicEdgeBrightness = FlareJson.decodeBool(element["OverrideDynamicEdgeBrightness"].ToString());

            elementNew.DynamicEdgeBrightnessOverride = float.Parse(element["DynamicEdgeBrightnessOverride"].ToString());

            elementNew.OverrideDynamicCenterBrightness = FlareJson.decodeBool(element["OverrideDynamicCenterBrightness"].ToString());

            elementNew.DynamicCenterBrightnessOverride = float.Parse(element["DynamicCenterBrightnessOverride"].ToString());

            elementNew.type = (ProFlareElement.Type)(int.Parse(element["type"].ToString()));


            elementNew.size = FlareJson.decodeVector2((Hashtable)element["size"]);

            Hashtable subElements = (Hashtable)element["subElements"];

            if (subElements != null)
            {
                foreach (System.Collections.DictionaryEntry subItem in subElements)
                {
                    Hashtable subElement = (Hashtable)subElements[subItem.Key];

                    SubElement subElementNew = new SubElement();

                    subElementNew.color = FlareJson.decodeColor((Hashtable)subElement["color"]);

                    subElementNew.position = float.Parse(subElement["position"].ToString());

                    subElementNew.offset = FlareJson.decodeVector3((Hashtable)subElement["offset"]);

                    subElementNew.angle = float.Parse(subElement["angle"].ToString());

                    subElementNew.scale = float.Parse(subElement["scale"].ToString());

                    subElementNew.random = float.Parse(subElement["random"].ToString());

                    subElementNew.random2 = float.Parse(subElement["random2"].ToString());

                    subElementNew.RandomScaleSeed = float.Parse(subElement["RandomScaleSeed"].ToString());

                    subElementNew.RandomColorSeedR = float.Parse(subElement["RandomColorSeedR"].ToString());

                    subElementNew.RandomColorSeedG = float.Parse(subElement["RandomColorSeedG"].ToString());

                    subElementNew.RandomColorSeedB = float.Parse(subElement["RandomColorSeedB"].ToString());

                    subElementNew.RandomColorSeedA = float.Parse(subElement["RandomColorSeedA"].ToString());

                    elementNew.subElements.Add(subElementNew);
                }
            }

            bool Found = false;

            for (int i2 = 0; i2 < flare._Atlas.elementsList.Count; i2++)
            {
                if (elementNew.SpriteName == flare._Atlas.elementsList[i2].name)
                {
                    Found = true;
                    elementNew.elementTextureID = i2;
                }
            }

            if (Found)
            {
                flare.Elements.Add(elementNew);
            }
            else
            {
                Debug.LogWarning("ProFlares - Flare Element Missing From Atlas Not Adding - " + elementNew.SpriteName);
            }
        }

        foreach (ProFlareBatch batch in flare.FlareBatches)
        {
            batch.dirty = true;
        }
    }