private int SortingOrderGenerate(SVGSpriteAssetFile spriteAsset)
{
if (spriteAsset != null)
{
SVGSpriteRef spriteRef = spriteAsset.SpriteRef;
SVGSpriteData spriteData = spriteAsset.SpriteData;
int svgIndex = this.SvgAssetIndexGet(spriteRef.TxtAsset);
if (svgIndex >= 0)
{
SVGSpritesList spritesList;
SVGAssetInput svgAsset = this.m_SvgList[svgIndex];
// if needed, advance in the instances group
if (spriteData.InCurrentInstancesGroup)
{
// get the list of sprites (references) relative to the SVG input asset
if (this.m_GeneratedSpritesLists.TryGetValue(svgAsset.TxtAsset.GetInstanceID(), out spritesList))
{
// advance instances group, telling that we are going to instantiate one sprite only
this.NextInstancesGroup(svgAsset, spritesList, 1);
}
}
return(SVGAtlas.SortingOrderCalc(svgIndex, svgAsset.InstanceBaseIdx, spriteData.ZOrder));
}
}
return(-1);
}
private void OnSpriteSelect(SVGSpriteAssetFile spriteAsset)
{
if (!this.m_EditedLoader.SpriteReference.Equals(spriteAsset.SpriteRef))
{
// set the selected sprite (reference)
this.m_EditedLoader.SpriteReference.TxtAsset = spriteAsset.SpriteRef.TxtAsset;
this.m_EditedLoader.SpriteReference.ElemIdx = spriteAsset.SpriteRef.ElemIdx;
// set the selected sprite into the Image component
Image uiImage = this.m_EditedLoader.GetComponent <Image>();
if (uiImage != null)
{
RectTransform rectTransform = uiImage.gameObject.GetComponent <RectTransform>();
Sprite sprite = spriteAsset.SpriteData.Sprite;
uiImage.sprite = sprite;
// Unity editor won't display immediately the new sprite if it has the same dimensions of the previous one
// so in order to refresh the game view, we set a temporary value and restore the previous one (or a new one)
if ((rectTransform.anchorMin == Vector2.zero) && (rectTransform.anchorMax == Vector2.one))
{
Vector2 tmp = rectTransform.sizeDelta;
rectTransform.sizeDelta = tmp + Vector2.one;
rectTransform.sizeDelta = tmp;
}
else
{
rectTransform.sizeDelta = Vector2.zero;
rectTransform.sizeDelta = new Vector2(sprite.rect.width, sprite.rect.height);
}
}
}
}
// border editing callback
private void OnSpriteEdited(PivotEditingResult result, SVGSpriteAssetFile spriteAsset, Vector2 editedPivot, Vector4 editedBorder)
{
SVGCanvasBehaviour svgCanvas = target as SVGCanvasBehaviour;
if ((svgCanvas != null) && (result == PivotEditingResult.Ok))
{
SVGUIAtlas uiAtlas = svgCanvas.UIAtlas;
if (uiAtlas != null)
{
// assign the new border
uiAtlas.UpdateBorder(spriteAsset, editedBorder);
SVGUtils.MarkObjectDirty(uiAtlas);
SVGUtils.MarkSceneDirty();
// get the list of instantiated SVG sprites that reference the edited one
List <GameObject> spritesInstances = new List <GameObject>();
uiAtlas.GetSpritesInstances(spritesInstances, spriteAsset.SpriteRef);
foreach (GameObject gameObj in spritesInstances)
{
Image uiImage = (Image)gameObj.GetComponent <Image>();
if (uiImage != null)
{
// the Image component won't recognize the change of sprite border, so in order to refresh
// instantiated objects we have to unset-set the sprite property
uiImage.sprite = null;
uiImage.sprite = spriteAsset.SpriteData.Sprite;
}
}
}
}
}
private void SpritePreview(SVGUIAtlas uiAtlas, Canvas canvas, SVGSpriteAssetFile spriteAsset)
{
SVGUIWidgetType widgetType;
Sprite sprite = spriteAsset.SpriteData.Sprite;
Texture2D texture = sprite.texture;
Rect spriteRect = sprite.textureRect;
Rect uv = new Rect(spriteRect.x / texture.width, spriteRect.y / texture.height, spriteRect.width / texture.width, spriteRect.height / texture.height);
GUILayoutOption[] spriteTextureOptions = new GUILayoutOption[2] {
GUILayout.Width(uiAtlas.SpritesPreviewSize), GUILayout.Height(uiAtlas.SpritesPreviewSize)
};
EditorGUILayout.BeginHorizontal(GUILayout.MinHeight(uiAtlas.SpritesPreviewSize + 5));
{
EditorGUILayout.LabelField(sprite.name, GUILayout.MinWidth(10));
// reserve space for drawing sprite
EditorGUILayout.LabelField("", spriteTextureOptions);
Rect guiRect = GUILayoutUtility.GetLastRect();
float maxSpriteDim = Math.Max(spriteRect.width, spriteRect.height);
float previewWidth = (spriteRect.width / maxSpriteDim) * uiAtlas.SpritesPreviewSize;
float previewHeight = (spriteRect.height / maxSpriteDim) * uiAtlas.SpritesPreviewSize;
float previewX = (uiAtlas.SpritesPreviewSize - previewWidth) / 2;
float previewY = 0;
Rect previewRect = new Rect(guiRect.xMin + previewX, guiRect.yMin + previewY, previewWidth, previewHeight);
GUI.DrawTextureWithTexCoords(previewRect, texture, uv, true);
EditorGUILayout.Space();
// sprite dimensions
EditorGUILayout.LabelField("[" + spriteRect.width + " x " + spriteRect.height + "]", GUILayout.MaxWidth(120));
if (GUILayout.Button("Edit", EditorStyles.miniButton))
{
// show pivot editor
SVGPivotEditor.Show(spriteAsset, this.OnSpriteEdited);
}
widgetType = (SVGUIWidgetType)EditorGUILayout.EnumPopup("", spriteAsset.InstantiatedWidgetType, new GUILayoutOption[] { GUILayout.Width(80) });
// instantiate
if (GUILayout.Button("Instantiate", EditorStyles.miniButton))
{
GameObject gameObj = uiAtlas.InstantiateWidget(canvas, spriteAsset.SpriteRef, widgetType);
// set the created instance as selected
if (gameObj != null)
{
Selection.objects = new UnityEngine.Object[1] {
gameObj as UnityEngine.Object
};
}
}
EditorGUILayout.Space();
}
EditorGUILayout.EndHorizontal();
if (widgetType != spriteAsset.InstantiatedWidgetType)
{
spriteAsset.InstantiatedWidgetType = widgetType;
}
}
private GameObject InstantiateSprite(SVGSpriteAssetFile spriteAsset, Vector3 worldPos, int sortingOrder)
{
GameObject gameObj = this.Instantiate(spriteAsset, sortingOrder);
// assign world position
gameObj.transform.position = worldPos;
return(gameObj);
}
protected void DeleteSprites()
{
foreach (KeyValuePair <SVGSpriteRef, SVGSpriteAssetFile> file in this.m_GeneratedSpritesFiles)
{
SVGSpriteAssetFile spriteAsset = file.Value;
AssetDatabase.DeleteAsset(spriteAsset.Path);
}
this.m_GeneratedSpritesFiles.Clear();
}
private void SpritePreview(SVGAtlas atlas, SVGSpriteAssetFile spriteAsset)
{
Sprite sprite = spriteAsset.SpriteData.Sprite;
Texture2D texture = sprite.texture;
Rect spriteRect = sprite.textureRect;
Rect uv = new Rect(spriteRect.x / texture.width, spriteRect.y / texture.height, spriteRect.width / texture.width, spriteRect.height / texture.height);
GUILayoutOption[] spriteTextureOptions = new GUILayoutOption[2] {
GUILayout.Width(atlas.SpritesPreviewSize), GUILayout.Height(atlas.SpritesPreviewSize)
};
EditorGUILayout.BeginHorizontal(GUILayout.MinHeight(atlas.SpritesPreviewSize + 5));
{
EditorGUILayout.LabelField(sprite.name, GUILayout.MinWidth(10));
// reserve space for drawing sprite
EditorGUILayout.LabelField("", spriteTextureOptions);
Rect guiRect = GUILayoutUtility.GetLastRect();
float maxSpriteDim = Math.Max(spriteRect.width, spriteRect.height);
float previewWidth = (spriteRect.width / maxSpriteDim) * atlas.SpritesPreviewSize;
float previewHeight = (spriteRect.height / maxSpriteDim) * atlas.SpritesPreviewSize;
float previewX = (atlas.SpritesPreviewSize - previewWidth) / 2;
//float previewY = (SVGAtlasEditor.SPRITE_PREVIEW_DIMENSION - previewHeight) / 2;
//float previewY = (previewWidth > previewHeight) ? 0 : ((SVGAtlasEditor.SPRITE_PREVIEW_DIMENSION - previewHeight) / 2);
float previewY = 0;
Rect previewRect = new Rect(guiRect.xMin + previewX, guiRect.yMin + previewY, previewWidth, previewHeight);
GUI.DrawTextureWithTexCoords(previewRect, texture, uv, true);
EditorGUILayout.Space();
// sprite dimensions
EditorGUILayout.LabelField("[" + spriteRect.width + " x " + spriteRect.height + "]", GUILayout.MaxWidth(100));
EditorGUILayout.Space();
// current pivot
EditorGUILayout.LabelField("Pivot [" + string.Format("{0:0.00}", spriteAsset.SpriteData.Pivot.x) + " , " + string.Format("{0:0.00}", spriteAsset.SpriteData.Pivot.y) + "]", GUILayout.Width(120));
EditorGUILayout.Space();
// edit pivot
if (GUILayout.Button("Edit", EditorStyles.miniButton))
{
// show pivot editor
SVGPivotEditor.Show(spriteAsset, this.OnPivotEdited);
}
// instantiate
if (GUILayout.Button("Instantiate", EditorStyles.miniButton, GUILayout.Width(80)))
{
GameObject gameObj = atlas.InstantiateSprite(spriteAsset.SpriteRef);
// set the created instance as selected
if (gameObj != null)
{
Selection.objects = new UnityEngine.Object[1] {
gameObj as UnityEngine.Object
};
}
}
EditorGUILayout.Space();
}
EditorGUILayout.EndHorizontal();
}
// pivot editing callback
private void OnPivotEdited(PivotEditingResult result, SVGSpriteAssetFile spriteAsset, Vector2 editedPivot, Vector4 editedBorder)
{
SVGAtlas atlas = target as SVGAtlas;
if ((atlas != null) && (result == PivotEditingResult.Ok))
{
// assign the new pivot
atlas.UpdatePivot(spriteAsset, editedPivot);
SVGUtils.MarkObjectDirty(atlas);
}
}
// show the sprite selector
static public void Show(SVGSpriteAssetFile spriteAsset, OnPivotEditedCallback callback)
{
// close the current selector instance, if any
SVGPivotEditor.CloseAll();
if (spriteAsset != null)
{
SVGPivotEditor pivotEditor = SVGPivotEditor.CreateInstance <SVGPivotEditor>();
SVGPivotEditor.Init(pivotEditor, spriteAsset, spriteAsset.SpriteData.Pivot, spriteAsset.SpriteData.Border, callback);
pivotEditor.ShowEditor();
}
}
private static void Init(SVGPivotEditor editor, SVGSpriteAssetFile spriteAsset, Vector2 pivot, Vector4 border, OnPivotEditedCallback callback)
{
float v;
Rect spriteRect = spriteAsset.SpriteData.Sprite.rect;
float minDim = Math.Min(spriteRect.width, spriteRect.height);
// keep track of the sprite and the input/output pivot
editor.m_SpriteAsset = spriteAsset;
editor.m_Pivot.Set(pivot.x, pivot.y);
editor.m_Border = border;
editor.m_SpritePreviewWidth = spriteRect.width;
editor.m_SpritePreviewHeight = spriteRect.height;
// adapt window dimension
if (minDim < SVGPivotEditor.SPRITE_PREVIEW_MIN_DIMENSION)
{
float scl = SVGPivotEditor.SPRITE_PREVIEW_MIN_DIMENSION / minDim;
editor.m_SpritePreviewWidth *= scl;
editor.m_SpritePreviewHeight *= scl;
}
// we must not exceed screen resolution (width)
v = Screen.currentResolution.width * 0.9f;
if (editor.m_SpritePreviewWidth > v)
{
float scl = v / editor.m_SpritePreviewWidth;
editor.m_SpritePreviewWidth *= scl;
editor.m_SpritePreviewHeight *= scl;
}
v = Screen.currentResolution.height * 0.9f;
if (editor.m_SpritePreviewHeight > v)
{
float scl = v / editor.m_SpritePreviewHeight;
editor.m_SpritePreviewWidth *= scl;
editor.m_SpritePreviewHeight *= scl;
}
editor.m_SpritePreviewWidth = Mathf.Round(editor.m_SpritePreviewWidth);
editor.m_SpritePreviewHeight = Mathf.Round(editor.m_SpritePreviewHeight);
editor.m_WindowWidth = editor.m_SpritePreviewWidth;
// we must ensure that pivot and border controls are already visible
if (editor.m_WindowWidth < 190)
{
editor.m_WindowWidth = 190;
}
editor.m_WindowHeight = editor.m_SpritePreviewHeight + SVGPivotEditor.BUTTONS_HEIGHT + (SVGPivotEditor.EDIT_FIELDS_HEIGHT * 3);
// set title
editor.titleContent = new GUIContent("Sprite editor");
// set callback
editor.m_Callback = callback;
}
private void OnSpriteSelect(SVGSpriteAssetFile spriteAsset)
{
if (this.m_EditedLoader.SpriteReference.TxtAsset != spriteAsset.SpriteRef.TxtAsset ||
this.m_EditedLoader.SpriteReference.ElemIdx != spriteAsset.SpriteRef.ElemIdx)
{
// set the selected sprite (reference)
this.m_EditedLoader.SpriteReference.TxtAsset = spriteAsset.SpriteRef.TxtAsset;
this.m_EditedLoader.SpriteReference.ElemIdx = spriteAsset.SpriteRef.ElemIdx;
// set the selected sprite into the renderer
SpriteRenderer renderer = this.m_EditedLoader.GetComponent <SpriteRenderer>();
if (renderer != null)
{
renderer.sprite = spriteAsset.SpriteData.Sprite;
}
}
}
public void UpdateBorder(SVGSpriteAssetFile spriteAsset, Vector4 newBorder)
{
SVGSpriteData spriteData = spriteAsset.SpriteData;
Sprite oldSprite = spriteData.Sprite;
// create a new sprite (same texture, same rectangle, same pivot, different border)
Sprite newSprite = Sprite.Create(oldSprite.texture, oldSprite.rect, spriteData.Pivot, SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT, 0, SpriteMeshType.FullRect, newBorder);
spriteData.Border = newBorder;
newSprite.name = oldSprite.name;
// serialized copy from the new sprite (i.e. the sprite with updated border) to the old sprite (i.e. the sprite to be updated)
// NB: we use this technique because there isn't an explicit sprite method that allows the change of border property
EditorUtility.CopySerialized(newSprite, oldSprite);
SVGUtils.MarkObjectDirty(oldSprite);
// destroy the temporary sprite
GameObject.DestroyImmediate(newSprite);
}
private GameObject Instantiate(SVGSpriteAssetFile spriteAsset, int sortingOrder)
{
SVGSpriteRef spriteRef = spriteAsset.SpriteRef;
SVGSpriteData spriteData = spriteAsset.SpriteData;
GameObject gameObj = new GameObject();
SpriteRenderer renderer = (SpriteRenderer)gameObj.AddComponent <SpriteRenderer>();
SVGSpriteLoaderBehaviour spriteLoader = (SVGSpriteLoaderBehaviour)gameObj.AddComponent <SVGSpriteLoaderBehaviour>();
renderer.sprite = spriteData.Sprite;
renderer.sortingOrder = sortingOrder;
spriteLoader.Atlas = this;
spriteLoader.SpriteReference = spriteRef;
spriteLoader.ResizeOnStart = true;
gameObj.name = spriteData.Sprite.name;
spriteData.InCurrentInstancesGroup = true;
return(gameObj);
}
private void DrawInspector()
{
bool resizeOnStart = EditorGUILayout.Toggle("Resize on Start()", this.m_EditedLoader.ResizeOnStart);
bool updateTransform = EditorGUILayout.Toggle("Update transform", this.m_EditedLoader.UpdateTransform);
string atlasName = (this.m_EditedLoader.Atlas != null) ? this.m_EditedLoader.Atlas.name : "<select>";
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Atlas");
if (GUILayout.Button(atlasName, "DropDown"))
{
SVGAtlasSelector.Show("", this.OnAtlasSelect);
}
}
EditorGUILayout.EndHorizontal();
if (this.m_EditedLoader.Atlas != null && this.m_EditedLoader.SpriteReference != null)
{
SVGSpriteAssetFile spriteAsset = this.m_EditedLoader.Atlas.GetGeneratedSprite(this.m_EditedLoader.SpriteReference);
string buttonText = (spriteAsset != null) ? spriteAsset.SpriteData.Sprite.name : "<select>";
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Sprite");
if (GUILayout.Button(buttonText, "DropDown"))
{
SVGSpriteSelector.Show(this.m_EditedLoader.Atlas, "", this.OnSpriteSelect);
}
}
EditorGUILayout.EndHorizontal();
}
if (this.m_EditedLoader.ResizeOnStart != resizeOnStart)
{
this.m_EditedLoader.ResizeOnStart = resizeOnStart;
SVGUtils.MarkObjectDirty(this.m_EditedLoader);
}
if (this.m_EditedLoader.UpdateTransform != updateTransform)
{
this.m_EditedLoader.UpdateTransform = updateTransform;
SVGUtils.MarkObjectDirty(this.m_EditedLoader);
}
}
// Given a text asset representing an SVG file, return the list of generated sprites relative to that document
public List <SVGSpriteAssetFile> GetGeneratedSpritesByDocument(TextAsset txtAsset)
{
if (txtAsset == null)
{
return(null);
}
// create the output list
List <SVGSpriteAssetFile> result = new List <SVGSpriteAssetFile>();
foreach (KeyValuePair <SVGSpriteRef, SVGSpriteAssetFile> file in this.m_GeneratedSpritesFiles)
{
SVGSpriteAssetFile spriteAsset = file.Value;
if (spriteAsset.SpriteRef.TxtAsset == txtAsset)
{
result.Add(spriteAsset);
}
}
return(result);
}
private void DrawInspector()
{
bool resizeOnStart;
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Resize on Start()");
resizeOnStart = EditorGUILayout.Toggle(this.m_EditedLoader.ResizeOnStart);
}
EditorGUILayout.EndHorizontal();
SVGUIAtlas uiAtlas = this.m_EditedLoader.UIAtlas;
if ((uiAtlas != null) && (this.m_EditedLoader.SpriteReference != null))
{
SVGSpriteAssetFile spriteAsset = uiAtlas.GetGeneratedSprite(this.m_EditedLoader.SpriteReference);
string buttonText = (spriteAsset != null) ? spriteAsset.SpriteData.Sprite.name : "<select>";
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Sprite");
if (GUILayout.Button(buttonText, "DropDown"))
{
SVGSpriteSelector.Show(uiAtlas, "", this.OnSpriteSelect);
}
if (GUILayout.Button("Edit", GUILayout.Width(80)))
{
// show pivot editor
SVGPivotEditor.Show(spriteAsset, this.OnSpriteEdited);
}
}
EditorGUILayout.EndHorizontal();
}
if (this.m_EditedLoader.ResizeOnStart != resizeOnStart)
{
this.m_EditedLoader.ResizeOnStart = resizeOnStart;
SVGUtils.MarkObjectDirty(this.m_EditedLoader);
}
}
// border editing callback
private void OnSpriteEdited(PivotEditingResult result, SVGSpriteAssetFile spriteAsset, Vector2 editedPivot, Vector4 editedBorder)
{
SVGUISpriteLoaderBehaviour spriteLoader = target as SVGUISpriteLoaderBehaviour;
if ((spriteLoader != null) && (result == PivotEditingResult.Ok))
{
SVGUIAtlas uiAtlas = spriteLoader.UIAtlas;
if (uiAtlas != null)
{
// assign the new border
uiAtlas.UpdateBorder(spriteAsset, editedPivot, editedBorder);
SVGUtils.MarkObjectDirty(uiAtlas);
Image uiImage = spriteLoader.GetComponent <Image>();
if (uiImage != null)
{
// the Image component does not recognize the change of sprite border, so in order to refresh
// instantiated objects we have to unset-set the sprite property
uiImage.sprite = null;
uiImage.sprite = spriteAsset.SpriteData.Sprite;
}
}
}
}
public void UpdatePivot(SVGSpriteAssetFile spriteAsset, Vector2 newPivot)
{
SVGSpriteRef spriteRef = spriteAsset.SpriteRef;
SVGSpriteData spriteData = spriteAsset.SpriteData;
Sprite oldSprite = spriteData.Sprite;
// keep track of pivot movement
Vector2 deltaPivot = newPivot - spriteData.Pivot;
Vector2 deltaMovement = (new Vector2(deltaPivot.x * oldSprite.rect.width, deltaPivot.y * oldSprite.rect.height)) / SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT;
// create a new sprite (same texture, same rectangle, different pivot)
Sprite newSprite = Sprite.Create(oldSprite.texture, oldSprite.rect, newPivot, SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT, 0, SpriteMeshType.FullRect, spriteData.Border);
GameObject[] allObjects = GameObject.FindObjectsOfType <GameObject>();
foreach (GameObject gameObj in allObjects)
{
if (gameObj.activeInHierarchy)
{
SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
// we must be sure that the loader component must refer to this atlas
if (loader != null && loader.Atlas == this)
{
// check if the instance uses the specified sprite
if (loader.SpriteReference.TxtAsset == spriteRef.TxtAsset && loader.SpriteReference.ElemIdx == spriteRef.ElemIdx)
{
SVGAtlas.UpdatePivotHierarchy(gameObj, deltaMovement, 0);
}
}
}
}
spriteData.Pivot = newPivot;
newSprite.name = oldSprite.name;
EditorUtility.CopySerialized(newSprite, oldSprite);
SVGUtils.MarkObjectDirty(oldSprite);
// destroy the temporary sprite
GameObject.DestroyImmediate(newSprite);
}
private void OnSpriteSelect(SVGSpriteAssetFile spriteAsset)
{
//if (this.m_EditedLoader.SpriteReference != spriteAsset.SpriteRef)
if (this.m_EditedLoader.SpriteReference.TxtAsset != spriteAsset.SpriteRef.TxtAsset ||
this.m_EditedLoader.SpriteReference.ElemIdx != spriteAsset.SpriteRef.ElemIdx)
{
// set the selected sprite (reference)
this.m_EditedLoader.SpriteReference.TxtAsset = spriteAsset.SpriteRef.TxtAsset;
this.m_EditedLoader.SpriteReference.ElemIdx = spriteAsset.SpriteRef.ElemIdx;
// set the selected sprite into the renderer
SpriteRenderer renderer = this.m_EditedLoader.GetComponent<SpriteRenderer>();
if (renderer != null)
renderer.sprite = spriteAsset.SpriteData.Sprite;
}
}
private bool DrawGUI()
{
bool close = false;
#if UNITY_EDITOR_WIN
// take care of dpi scaling factor on Windows (Display Settings --> Advanced scaling settings)
float dpi = Screen.dpi;
// dpi 96 == 1.00
// dpi 120 == 1.25
// dpi 144 == 1.50
// dpi 168 == 1.75
// ... and so on
float dpiAdjust = (((dpi - 96.0f) / 24.0f) * 0.25f) + 1.0f;
#else
float dpiAdjust = 1.0f;
#endif
int columnsPerRow = Math.Max(Mathf.FloorToInt((Screen.width / dpiAdjust) / SVGSpriteSelector.SPRITE_PREVIEW_DIMENSION_PADDED), 1);
int rowsCount = 1;
int spriteIdx = 0;
Rect rect = new Rect(SVGSpriteSelector.SPRITE_PREVIEW_BORDER, SVGSpriteSelector.SPRITE_PREVIEW_BORDER,
SVGSpriteSelector.SPRITE_PREVIEW_DIMENSION, SVGSpriteSelector.SPRITE_PREVIEW_DIMENSION);
// draw header, with the name of atlas and the "search by name" toolbox
List <SVGSpriteAssetFile> spritesList = this.Header();
this.m_ScrollPos = GUILayout.BeginScrollView(this.m_ScrollPos);
while (spriteIdx < spritesList.Count)
{
// start a new row
GUILayout.BeginHorizontal();
{
int currentColumn = 0;
rect.x = SVGSpriteSelector.SPRITE_PREVIEW_BORDER;
while (spriteIdx < spritesList.Count)
{
SVGSpriteAssetFile spriteAsset = spritesList[spriteIdx];
Sprite sprite = spriteAsset.SpriteData.Sprite;
// buttons are used to implement sprite selection (we use the sprite name as tooltip)
if (GUI.Button(rect, new GUIContent("", sprite.name)))
{
// mouse left button click
if (Event.current.button == 0)
{
if (this.m_Callback != null)
{
this.m_Callback(spriteAsset);
}
close = true;
}
}
// show sprite preview, taking care to highlight the currently selected one
if (Event.current.type == EventType.Repaint)
{
SVGSpriteSelector.SpritePreview(sprite, rect);
}
// draw sprite name
SVGSpriteSelector.SpriteLabel(sprite.name, rect);
// next sprite
spriteIdx++;
// next column
rect.x += SVGSpriteSelector.SPRITE_PREVIEW_DIMENSION_PADDED;
if (++currentColumn >= columnsPerRow)
{
break;
}
}
}
GUILayout.EndHorizontal();
GUILayout.Space(SVGSpriteSelector.SPRITE_PREVIEW_DIMENSION_PADDED);
rect.y += SVGSpriteSelector.SPRITE_PREVIEW_DIMENSION_PADDED + SVGSpriteSelector.SPRITE_NAME_HEIGHT;
rowsCount++;
}
GUILayout.Space((rowsCount - 1) * SVGSpriteSelector.SPRITE_NAME_HEIGHT + SVGSpriteSelector.SPRITE_PREVIEW_BORDER);
GUILayout.EndScrollView();
return(close);
}
private GameObject InstantiateWidget(Canvas canvas, SVGSpriteAssetFile spriteAsset, SVGUIWidgetType widgetType)
{
Image uiImage;
InputField inputField = null;
SVGSpriteRef spriteRef = spriteAsset.SpriteRef;
SVGSpriteData spriteData = spriteAsset.SpriteData;
GameObject gameObj = new GameObject();
gameObj.layer = LayerMask.NameToLayer("UI");
// add Image component; NB: it will add a RectTransform component too
uiImage = gameObj.AddComponent <Image>();
uiImage.fillCenter = true;
uiImage.material = null;
uiImage.color = new Color(1.0f, 1.0f, 1.0f, 1.0f);
uiImage.sprite = spriteData.Sprite;
switch (widgetType)
{
case SVGUIWidgetType.Button:
gameObj.AddComponent <Button>();
break;
case SVGUIWidgetType.InputField:
inputField = gameObj.AddComponent <InputField>();
break;
default:
break;
}
// get RectTransform component and set size according to the associated sprite
RectTransform rectTransform = gameObj.GetComponent <RectTransform>();
rectTransform.SetParent(canvas.transform);
// attach SVGUISpriteLoaderBehaviour component
SVGUISpriteLoaderBehaviour spriteLoader = (SVGUISpriteLoaderBehaviour)gameObj.AddComponent <SVGUISpriteLoaderBehaviour>();
spriteLoader.UIAtlas = this;
spriteLoader.SpriteReference = spriteRef;
spriteLoader.ResizeOnStart = true;
// anchor presets
if (widgetType == SVGUIWidgetType.Panel)
{
rectTransform.anchorMin = Vector2.zero;
rectTransform.anchorMax = Vector2.one;
rectTransform.localPosition = Vector3.zero;
rectTransform.sizeDelta = Vector2.zero;
}
else
{
rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
rectTransform.sizeDelta = new Vector2(spriteData.Sprite.rect.width, spriteData.Sprite.rect.height);
}
// set image type
uiImage.type = (spriteData.Sprite.border != Vector4.zero) ? Image.Type.Sliced : Image.Type.Simple;
if (widgetType == SVGUIWidgetType.InputField)
{
this.PopulateInputField(canvas, gameObj, inputField);
}
gameObj.name = spriteData.Sprite.name;
gameObj.SetActive(true);
return(gameObj);
}
