/// <summary>
/// Copy the inner rectangle from one sprite to another.
/// </summary>
/*
* static void CopyInnerRect (ProFlareAtlas.Element oldSprite, ProFlareAtlas.Element newElement)
* {
* float offsetX = oldSprite.inner.xMin - oldSprite.outer.xMin;
* float offsetY = oldSprite.inner.yMin - oldSprite.outer.yMin;
* float sizeX = oldSprite.inner.width;
* float sizeY = oldSprite.inner.height;
*
* if (Mathf.Approximately(newElement.outer.width, oldSprite.outer.width))
* {
* // The sprite has not been rotated or it's a square
* newElement.inner = new Rect(newElement.outer.xMin + offsetX, newElement.outer.yMin + offsetY, sizeX, sizeY);
* }
* else if (Mathf.Approximately(newElement.outer.width, oldSprite.outer.height))
* {
* // The sprite was rotated since the last time it was imported
* newElement.inner = new Rect(newElement.outer.xMin + offsetY, newElement.outer.yMin + offsetX, sizeY, sizeX);
* }
* }
*/
/// <summary>
/// Parses the string json into a value
/// </summary>
/// <param name="json">A JSON string.</param>
/// <returns>An ArrayList, a Hashtable, a double, a string, null, true, or false</returns>
public static object jsonDecode(string json)
{
// save the string for debug information
FlareJson.lastDecode = json;
if (json != null)
{
char[] charArray = json.ToCharArray();
int index = 0;
bool success = true;
object value = FlareJson.parseValue(charArray, ref index, ref success);
if (success)
{
FlareJson.lastErrorIndex = -1;
}
else
{
FlareJson.lastErrorIndex = index;
}
return(value);
}
else
{
return(null);
}
}
/// <summary>
/// Converts a Hashtable / ArrayList / Dictionary(string,string) object into a JSON string
/// </summary>
/// <param name="json">A Hashtable / ArrayList</param>
/// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
public static string jsonEncode(object json)
{
var builder = new StringBuilder(BUILDER_CAPACITY);
var success = FlareJson.serializeValue(json, builder);
return(success ? builder.ToString() : null);
}
public override void OnInspectorGUI()
{
_ProFlareAtlas = target as ProFlareAtlas;
CheckUndo();
// base.OnInspectorGUI();
FlareEditorHelper.DrawGuiDivider();
GUIStyle title = FlareEditorHelper.TitleStyle();
GUIStyle thinButton = FlareEditorHelper.ThinButtonStyle();
GUIStyle enumDropDown = FlareEditorHelper.EnumStyleButton();
GUIStyle redButton = FlareEditorHelper.ThinButtonRedStyle();
EditorGUILayout.LabelField("ProFlare Atlas Editor", title);
GUILayout.Space(10f);
_ProFlareAtlas.texture = EditorGUILayout.ObjectField("Flare Atlas Texture", _ProFlareAtlas.texture, typeof(Texture2D), false) as Texture2D;
if (_ProFlareAtlas.texture == null)
{
EditorGUILayout.HelpBox("Assign a texture to the atlas.", MessageType.Warning, true);
return;
}
TextAsset ta = EditorGUILayout.ObjectField("Atlas JSON Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
FlareJson.LoadSpriteData(_ProFlareAtlas, ta);
Updated = true;
}
FlareEditorHelper.DrawGuiDivider();
EditorGUILayout.LabelField("Atlas Elements", title);
GUILayout.Space(6f);
EditorGUILayout.BeginHorizontal();
if (_ProFlareAtlas.elementsList.Count < 1)
{
EditorGUILayout.HelpBox("No Elements in flare atlas", MessageType.Warning, true);
}
else
{
_ProFlareAtlas.elementNameList = new string[_ProFlareAtlas.elementsList.Count];
for (int i = 0; i < _ProFlareAtlas.elementNameList.Length; i++)
{
_ProFlareAtlas.elementNameList[i] = _ProFlareAtlas.elementsList[i].name;
}
int _ProFlareAtlasElementNumber = EditorGUILayout.Popup(_ProFlareAtlas.elementNumber, _ProFlareAtlas.elementNameList, enumDropDown);
if (_ProFlareAtlasElementNumber != _ProFlareAtlas.elementNumber)
{
_ProFlareAtlas.elementNumber = _ProFlareAtlasElementNumber;
renameString = _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].name;
}
if (GUILayout.Button("EDIT", thinButton))
{
Updated = true;
if (_ProFlareAtlas.editElements)
{
_ProFlareAtlas.editElements = false;
}
else
{
_ProFlareAtlas.editElements = true;
}
}
}
if (GUILayout.Button("ADD NEW", thinButton))
{
_ProFlareAtlas.editElements = true;
ProFlareAtlas.Element element = new ProFlareAtlas.Element();
element.name = "New Element " + _ProFlareAtlas.elementsList.Count;
renameString = element.name;
element.Imported = false;
_ProFlareAtlas.elementsList.Add(element);
_ProFlareAtlas.elementNumber = _ProFlareAtlas.elementsList.Count - 1;
Updated = true;
}
EditorGUILayout.EndHorizontal();
if (_ProFlareAtlas.elementsList.Count < 1)
{
return;
}
EditorGUILayout.BeginVertical("box");
GUILayout.Space(20f);
Rect lastRect = GUILayoutUtility.GetLastRect();
Rect outerRect2 = new Rect(lastRect.center.x, 0 + lastRect.yMin, 200, 200);
if (_ProFlareAtlas.elementsList.Count > 0)
{
GUI.DrawTextureWithTexCoords(outerRect2, _ProFlareAtlas.texture, _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV, false);
GUILayout.Space(200f);
}
GUI.enabled = _ProFlareAtlas.editElements;
if (_ProFlareAtlas.editElements)
{
int extra = 0;
#if UNITY_4_3
extra = 10;
#endif
Rect outerRect3 = new Rect(107 + extra, lastRect.yMin, 0.5f, 200);
Rect rect = new Rect(0, 0, 1, 1);
GUI.DrawTextureWithTexCoords(outerRect3, EditorGUIUtility.whiteTexture, rect, false);
Rect outerRect4 = new Rect(7 + extra, 100 + lastRect.yMin, 200, 0.5f);
GUI.DrawTextureWithTexCoords(outerRect4, EditorGUIUtility.whiteTexture, rect, true);
}
GUILayout.BeginHorizontal();
if (!_ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].Imported)
{
renameString = EditorGUILayout.TextField("Name", renameString);
if (GUILayout.Button("RENAME"))
{
Updated = true;
_ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].name = renameString;
}
}
else
{
EditorGUILayout.LabelField("Name - " + renameString);
}
GUILayout.EndHorizontal();
EditorGUILayout.Toggle("Imported :", _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].Imported);
float width = EditorGUILayout.Slider("Width", _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV.width, 0f, 1f);
float height = EditorGUILayout.Slider("Height", _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV.height, 0f, 1f);
float CenterX = EditorGUILayout.Slider("Center X", _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV.center.x, 0f, 1f);
float CenterY = EditorGUILayout.Slider("Center Y", _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV.center.y, 0f, 1f);
float xMin = _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV.xMin;
float yMin = _ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV.yMin;
Rect newRect = new Rect(xMin, yMin, width, height);
newRect.center = new Vector2(CenterX, CenterY);
GUILayout.Space(40f);
_ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber].UV = newRect;
if (GUILayout.Button("DELETE ELEMENT", redButton))
{
Updated = true;
_ProFlareAtlas.elementsList.Remove(_ProFlareAtlas.elementsList[_ProFlareAtlas.elementNumber]);
_ProFlareAtlas.elementNumber = 0;
}
EditorGUILayout.EndVertical();
GUI.enabled = true;
if (GUI.changed || Updated)
{
Updated = false;
guiChanged = true;
EditorUtility.SetDirty(target);
}
FlareEditorHelper.DrawGuiDivider();
}
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;
}
}
