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 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();
}
// 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;
}
protected bool UpdateButtonDraw(SVGBasicAtlas atlas)
{
bool pushed = false;
// update button
string updateStr = (atlas.NeedsUpdate()) ? "Update *" : "Update";
if (GUILayout.Button(updateStr))
{
// close all modal popup editors
SVGPivotEditor.CloseAll();
SVGSpriteSelector.CloseAll();
SVGAtlasSelector.CloseAll();
pushed = true;
}
return(pushed);
}
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);
}
}
// Draw the specified Image.
private void DrawSprite(Sprite sprite, Rect drawArea, Color color)
{
if ((sprite != null) || (sprite.texture != null))
{
Rect outer = sprite.rect;
Rect inner = outer;
inner.xMin += this.m_Border.x;
inner.yMin += this.m_Border.y;
inner.xMax -= this.m_Border.z;
inner.yMax -= this.m_Border.w;
Vector4 uv4 = UnityEngine.Sprites.DataUtility.GetOuterUV(sprite);
Rect uv = new Rect(uv4.x, uv4.y, uv4.z - uv4.x, uv4.w - uv4.y);
Vector4 padding = UnityEngine.Sprites.DataUtility.GetPadding(sprite);
padding.x /= outer.width;
padding.y /= outer.height;
padding.z /= outer.width;
padding.w /= outer.height;
SVGPivotEditor.DrawSprite(sprite.texture, drawArea, padding, outer, inner, uv, color);
}
}
static private Texture2D CreateContrastTexture()
{
return(SVGPivotEditor.CreateCheckerTex(new Color(0f, 0.0f, 0f, 0.5f), new Color(1f, 1f, 1f, 0.5f), "SVGPivotEditor.m_ContrastTexture"));
}
private void Draw(Rect region)
{
float mouseX, mouseY, px, py, y, h;
Rect spritePreviewRect = new Rect();
GUILayoutOption[] okButtonOptions = new GUILayoutOption[2] {
GUILayout.Width(this.m_WindowWidth / 2 - 8), GUILayout.Height(SVGPivotEditor.BUTTONS_HEIGHT - 3)
};
GUILayoutOption[] cancelButtonOptions = new GUILayoutOption[2] {
GUILayout.Width(this.m_WindowWidth / 2 - 3), GUILayout.Height(SVGPivotEditor.BUTTONS_HEIGHT - 3)
};
GUILayout.BeginArea(region);
{
// ----------------
// custom code here
// ----------------
if (this.m_SpriteAsset != null)
{
Sprite sprite = this.m_SpriteAsset.SpriteData.Sprite;
float spritePreviewWidth = this.m_SpritePreviewWidth;
float spritePreviewHeight = this.m_SpritePreviewHeight;
float spritePreviewX = 0;
float spritePreviewY = 0;
// draw the sprite preview
spritePreviewRect = new Rect(spritePreviewX, spritePreviewY, spritePreviewWidth, spritePreviewHeight);
this.DrawSprite(sprite, spritePreviewRect, new Color(1.0f, 1.0f, 1.0f, 1.0f));
// draw pivot
px = spritePreviewX + this.m_Pivot.x * spritePreviewWidth;
py = spritePreviewY + (1 - this.m_Pivot.y) * spritePreviewHeight;
GUI.DrawTexture(new Rect(px - SVGPivotEditor.PIVOT_CURSOR_DIMENSION * 0.5f, py - SVGPivotEditor.PIVOT_CURSOR_DIMENSION * 0.5f, SVGPivotEditor.PIVOT_CURSOR_DIMENSION, SVGPivotEditor.PIVOT_CURSOR_DIMENSION), SVGPivotEditor.PivotTexture);
}
// edit fields relative to sprite border
y = region.height - SVGPivotEditor.BUTTONS_HEIGHT - 3 * SVGPivotEditor.EDIT_FIELDS_HEIGHT;
h = 2 * SVGPivotEditor.EDIT_FIELDS_HEIGHT;
GUILayout.BeginArea(new Rect(3, y, region.width, h));
{
GUILayout.BeginHorizontal(GUILayout.Height(SVGPivotEditor.EDIT_FIELDS_HEIGHT));
{
GUILayout.Label("Border", GUILayout.Width(50));
GUILayout.Label("L", GUILayout.Width(15));
this.m_Border.x = EditorGUILayout.FloatField(this.m_Border.x, GUILayout.Width(40));
GUILayout.Label("B", GUILayout.Width(15));
this.m_Border.y = EditorGUILayout.FloatField(this.m_Border.y, GUILayout.Width(40));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(GUILayout.Height(SVGPivotEditor.EDIT_FIELDS_HEIGHT));
{
GUILayout.Label("", GUILayout.Width(50));
GUILayout.Label("R", GUILayout.Width(15));
this.m_Border.z = EditorGUILayout.FloatField(this.m_Border.z, GUILayout.Width(40));
GUILayout.Label("T", GUILayout.Width(15));
this.m_Border.w = EditorGUILayout.FloatField(this.m_Border.w, GUILayout.Width(40));
}
GUILayout.EndHorizontal();
}
GUILayout.EndArea();
// edit fields relative to sprite pivot
y = region.height - SVGPivotEditor.BUTTONS_HEIGHT - SVGPivotEditor.EDIT_FIELDS_HEIGHT;
h = SVGPivotEditor.EDIT_FIELDS_HEIGHT;
GUILayout.BeginArea(new Rect(3, y, region.width, h));
{
GUILayout.BeginHorizontal(GUILayout.Height(SVGPivotEditor.EDIT_FIELDS_HEIGHT));
{
GUILayout.Label("Pivot", GUILayout.Width(50));
this.m_Pivot.x = SVGPivotEditor.FloatField3DP("X", this.m_Pivot.x);
this.m_Pivot.y = SVGPivotEditor.FloatField3DP("Y", this.m_Pivot.y);
}
GUILayout.EndHorizontal();
}
GUILayout.EndArea();
// button bar
GUILayout.BeginArea(new Rect(3, region.height - SVGPivotEditor.BUTTONS_HEIGHT, region.width, SVGPivotEditor.BUTTONS_HEIGHT));
{
GUILayout.BeginHorizontal(GUILayout.Height(SVGPivotEditor.BUTTONS_HEIGHT));
{
if (GUILayout.Button("Cancel", cancelButtonOptions))
{
this.Cancel();
}
if (GUILayout.Button("Ok", okButtonOptions))
{
this.Ok();
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndArea();
}
GUILayout.EndArea();
// events handler
switch (Event.current.type)
{
// keyboard press
case EventType.KeyDown:
if (Event.current.keyCode == KeyCode.Return)
{
this.Ok();
}
if (Event.current.keyCode == KeyCode.Escape)
{
this.Cancel();
}
break;
// mouse left button
case EventType.MouseDown:
mouseX = Event.current.mousePosition.x;
mouseY = Event.current.mousePosition.y;
// clamp x coordinate
if (mouseX < spritePreviewRect.xMin + SVGPivotEditor.SNAP_CORNER_THRESHOLD)
{
mouseX = spritePreviewRect.xMin;
}
if (mouseX + SVGPivotEditor.SNAP_CORNER_THRESHOLD > spritePreviewRect.xMax)
{
mouseX = spritePreviewRect.xMax;
}
// clamp y coordinate
if (mouseY < spritePreviewRect.yMin + SVGPivotEditor.SNAP_CORNER_THRESHOLD)
{
mouseY = spritePreviewRect.yMin;
}
if (mouseY + SVGPivotEditor.SNAP_CORNER_THRESHOLD > spritePreviewRect.yMax)
{
mouseY = spritePreviewRect.yMax;
}
// assign the new pivot value
px = (mouseX - spritePreviewRect.xMin) / spritePreviewRect.width;
py = (mouseY - spritePreviewRect.yMin) / spritePreviewRect.height;
this.m_Pivot.Set(Mathf.Clamp(px, 0, 1), 1 - Mathf.Clamp(py, 0, 1));
// force a repaint
this.Repaint();
break;
}
}
// Draw the specified Image.
private static void DrawSprite(Texture tex, Rect drawArea, Vector4 padding, Rect outer, Rect inner, Rect uv, Color color)
{
// Create the texture rectangle that is centered inside rect.
Rect outerRect = drawArea;
outerRect.width = outer.width;
outerRect.height = outer.height;
if (outerRect.width > 0f)
{
float f = drawArea.width / outerRect.width;
outerRect.width *= f;
outerRect.height *= f;
}
if (drawArea.height > outerRect.height)
{
outerRect.y += (drawArea.height - outerRect.height) * 0.5f;
}
else
if (outerRect.height > drawArea.height)
{
float f = drawArea.height / outerRect.height;
outerRect.width *= f;
outerRect.height *= f;
}
if (drawArea.width > outerRect.width)
{
outerRect.x += (drawArea.width - outerRect.width) * 0.5f;
}
// Draw the background
EditorGUI.DrawTextureTransparent(outerRect, null, ScaleMode.ScaleToFit, outer.width / outer.height);
// Draw the Image
GUI.color = color;
Rect paddedTexArea = new Rect(outerRect.x + outerRect.width * padding.x,
outerRect.y + outerRect.height * padding.w,
outerRect.width - (outerRect.width * (padding.z + padding.x)),
outerRect.height - (outerRect.height * (padding.w + padding.y)));
GUI.DrawTextureWithTexCoords(paddedTexArea, tex, uv, true);
// Draw the border indicator lines
GUI.BeginGroup(outerRect);
{
tex = SVGPivotEditor.ContrastTexture;
GUI.color = Color.white;
if (inner.xMin != outer.xMin)
{
float x = (inner.xMin - outer.xMin) / outer.width * outerRect.width - 1;
SVGPivotEditor.DrawTiledTexture(new Rect(x, 0f, 1f, outerRect.height), tex);
}
if (inner.xMax != outer.xMax)
{
float x = (inner.xMax - outer.xMin) / outer.width * outerRect.width - 1;
SVGPivotEditor.DrawTiledTexture(new Rect(x, 0f, 1f, outerRect.height), tex);
}
if (inner.yMin != outer.yMin)
{
float y = (inner.yMin - outer.yMin) / outer.height * outerRect.height - 1;
SVGPivotEditor.DrawTiledTexture(new Rect(0f, outerRect.height - y, outerRect.width, 1f), tex);
}
if (inner.yMax != outer.yMax)
{
float y = (inner.yMax - outer.yMin) / outer.height * outerRect.height - 1;
SVGPivotEditor.DrawTiledTexture(new Rect(0f, outerRect.height - y, outerRect.width, 1f), tex);
}
}
GUI.EndGroup();
}
