private bool InstancesGroupWrap(SVGAssetInput svgAsset, int spritesCount)
{
int rangeLo = svgAsset.InstanceBaseIdx;
int rangeHi = rangeLo + spritesCount;
return((rangeHi >= SPRITES_SORTING_MAX_INSTANCES) ? true : false);
}
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);
}
public void SvgAssetSeparateGroupsSet(SVGAssetInput svgAsset, bool separateGroups)
{
if ((svgAsset != null) && (svgAsset.SeparateGroups != separateGroups))
{
svgAsset.SeparateGroups = separateGroups;
// recalculate atlas hash
this.UpdateAtlasHash();
}
}
public void SvgAssetScaleAdjustmentSet(SVGAssetInput svgAsset, float scale)
{
if ((svgAsset != null) && (svgAsset.Scale != scale))
{
svgAsset.Scale = scale;
// recalculate atlas hash
this.UpdateAtlasHash();
}
}
private void SortingOrdersCompact(SVGAssetInput svgAsset)
{
List <SpriteRenderer> spriteRenderers = new List <SpriteRenderer>();
// get the list of instantiated sprites relative to this atlas generator
List <GameObject> spritesInstances = new List <GameObject>();
this.GetSpritesInstances(spritesInstances);
foreach (GameObject gameObj in spritesInstances)
{
SVGSpriteLoaderBehaviour spriteLoader = (SVGSpriteLoaderBehaviour)gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
SVGSpriteRef spriteRef = spriteLoader.SpriteReference;
// if the sprite belongs to the specified SVG asset input, keep track of it
if (spriteRef.TxtAsset == svgAsset.TxtAsset)
{
SpriteRenderer renderer = (SpriteRenderer)gameObj.GetComponent <SpriteRenderer>();
if (renderer != null)
{
spriteRenderers.Add(renderer);
}
}
}
if (spriteRenderers.Count > 0)
{
// order the list by current sorting order
spriteRenderers.Sort(delegate(SpriteRenderer renderer1, SpriteRenderer renderer2) {
if (renderer1.sortingOrder < renderer2.sortingOrder)
{
return(-1);
}
if (renderer1.sortingOrder > renderer2.sortingOrder)
{
return(1);
}
return(0);
});
int j = spriteRenderers.Count;
for (int i = 0; i < j; ++i)
{
SpriteRenderer renderer = spriteRenderers[i];
int currentOrder = renderer.sortingOrder;
// isolate high part
int svgIndex = currentOrder & SPRITES_SORTING_DOCUMENTS_MASK;
// assign the new order
renderer.sortingOrder = SVGAtlas.SortingOrderCalc(svgIndex, i);
}
svgAsset.InstanceBaseIdx = j;
}
else
{
// there are no sprite instances relative to the specified SVG, so we can start from 0
svgAsset.InstanceBaseIdx = 0;
}
}
public override bool SvgAssetMove(SVGAssetInput svgAsset, int toIndex)
{
int fromIndex = this.SvgAssetIndexGet(svgAsset.TxtAsset);
bool moved = this.SvgAssetMove(svgAsset, fromIndex, toIndex);
if (moved)
{
// recalculate sorting orders of instantiated sprites
this.SortingOrdersUpdateSvgIndex();
}
return(moved);
}
protected int SvgAssetIndexGet(TextAsset txtAsset)
{
if (txtAsset != null)
{
// find the SVG index inside the SvgList
int j = this.m_SvgList.Count;
for (int i = 0; i < j; ++i)
{
SVGAssetInput svgAsset = this.m_SvgList[i];
if (svgAsset.TxtAsset == txtAsset)
{
return(i);
}
}
}
// if we have not found the svg index, return -1 as error
return(-1);
}
protected bool SvgAssetMove(SVGAssetInput svgAsset, int fromIndex, int toIndex)
{
if (fromIndex >= 0)
{
// clamp the destination index
toIndex = SVGUtils.Clamp(toIndex, 0, this.m_SvgList.Count);
// check if movement has sense
if (fromIndex != toIndex)
{
// perform the real movement
this.m_SvgList.Insert(toIndex, this.m_SvgList[fromIndex]);
if (toIndex <= fromIndex)
{
++fromIndex;
}
this.m_SvgList.RemoveAt(fromIndex);
return(true);
}
}
return(false);
}
private bool SvgInputAssetDraw(SVGBasicAtlas atlas, int index, out Rect rowRect)
{
bool isDirty;
SVGAssetInput svgAsset = atlas.SvgAsset(index);
bool highlight = (this.m_DragInfo.Dragging && this.m_DragInfo.DraggedObject == svgAsset) ? true : false;
if (this.m_DragInfo.InsertIdx == index && this.m_DragInfo.InsertBefore)
{
// draw a separator before the row
GUILayout.Box(GUIContent.none, this.m_BlueLine, GUILayout.ExpandWidth(true), GUILayout.Height(2));
}
// if the SVG row is the dragged one, change colors
if (highlight)
{
EditorGUILayout.BeginHorizontal(this.m_HighlightRow);
// a row: asset name, separate groups checkbox, remove button, instantiate button
EditorGUILayout.LabelField(svgAsset.TxtAsset.name, this.m_HighlightRow, GUILayout.MinWidth(10));
}
else
{
EditorGUILayout.BeginHorizontal();
// a row: asset name, separate groups checkbox, remove button, instantiate button
EditorGUILayout.LabelField(svgAsset.TxtAsset.name, GUILayout.MinWidth(10));
}
isDirty = this.SvgInputAssetDrawImplementation(atlas, svgAsset, index);
EditorGUILayout.EndHorizontal();
rowRect = GUILayoutUtility.GetLastRect();
if (this.m_DragInfo.InsertIdx == index && (!this.m_DragInfo.InsertBefore))
{
// draw a separator after the row
GUILayout.Box(GUIContent.none, this.m_BlueLine, GUILayout.ExpandWidth(true), GUILayout.Height(2));
}
return(isDirty);
}
private void NextInstancesGroup(SVGAssetInput svgAsset, SVGSpritesList spritesList, int instantiationCount)
{
int spritesCount = spritesList.Sprites.Count;
svgAsset.InstanceBaseIdx += spritesCount;
if (this.InstancesGroupWrap(svgAsset, spritesCount))
{
// try to compact used sorting orders (looping game objects that reference this svg)
this.SortingOrdersCompact(svgAsset);
// after compaction, if the instantiation of one or all sprites belonging to the new instances group will wrap
// we have two options:
//
// 1. to instantiate sprites in the normal consecutive way, wrapping aroung SPRITES_SORTING_MAX_INSTANCES: in this case a part of sprites will
// result (sortingOrder) consistent, but the whole sprites group won't
//
// 2. to reset the base index to 0 and generate the sprites according to their natural z-order: in this case the whole sprites group will
// be (sortingOrder) consistent, but it is not granted to be totally (z)separated from other sprites/instances
//
if (this.InstancesGroupWrap(svgAsset, spritesCount))
{
svgAsset.InstanceBaseIdx = 0;
/*
* // option 2
* if (instantiationCount > 1)
* packedSvg.InstanceBaseIdx = 0;
* // for single sprite instantiation we implicitly use option 1
*/
}
}
// now we can unflag sprites
this.ResetGroupFlags(spritesList);
}
public abstract bool SvgAssetMove(SVGAssetInput svgAsset, int toIndex);
public GameObject[] InstantiateGroups(SVGAssetInput svgAsset)
{
SVGSpritesList spritesList;
if (svgAsset != null && this.m_GeneratedSpritesLists.TryGetValue(svgAsset.TxtAsset.GetInstanceID(), out spritesList))
{
int spritesCount = spritesList.Sprites.Count;
int svgIndex = this.SvgAssetIndexGet(svgAsset.TxtAsset);
if (svgIndex >= 0 && spritesCount > 0)
{
// list of sprite assets (file) relative to the specified SVG; in this case we can set the right list capacity
List <SVGSpriteAssetFile> spriteAssets = new List <SVGSpriteAssetFile>(spritesCount);
bool advanceInstancesGroup = false;
// now we are sure that at least one valid sprite box exists
float xMin = float.MaxValue;
float yMin = float.MaxValue;
float xMax = float.MinValue;
float yMax = float.MinValue;
foreach (SVGSpriteRef spriteRef in spritesList.Sprites)
{
SVGSpriteAssetFile spriteAsset;
if (this.m_GeneratedSpritesFiles.TryGetValue(spriteRef, out spriteAsset))
{
SVGSpriteData spriteData = spriteAsset.SpriteData;
Sprite sprite = spriteData.Sprite;
//float scl = 1 / spriteData.Scale;
float scl = 1;
float ox = (float)spriteData.OriginalX;
float oy = (float)spriteData.OriginalY;
float spriteMinX = ox * scl;
float spriteMinY = oy * scl;
float spriteMaxX = (ox + sprite.rect.width) * scl;
float spriteMaxY = (oy + sprite.rect.height) * scl;
// update min corner
if (spriteMinX < xMin)
{
xMin = spriteMinX;
}
if (spriteMinY < yMin)
{
yMin = spriteMinY;
}
// update max corner
if (spriteMaxX > xMax)
{
xMax = spriteMaxX;
}
if (spriteMaxY > yMax)
{
yMax = spriteMaxY;
}
// if there is a single sprite already instantiated in the current group, we have to advance in the next instances group
if (spriteData.InCurrentInstancesGroup)
{
advanceInstancesGroup = true;
}
// keep track of this sprite asset
spriteAssets.Add(spriteAsset);
}
}
if (spriteAssets.Count > 0)
{
// because at least one valid sprite box exists, now we are sure that a valid "global" box has been calculated
float centerX = (xMin + xMax) / 2;
float centerY = (yMin + yMax) / 2;
float boxHeight = yMax - yMin;
List <GameObject> instances = new List <GameObject>();
if (advanceInstancesGroup)
{
// advance in the instances group, telling that we are going to instantiate N sprites
this.NextInstancesGroup(svgAsset, spritesList, spriteAssets.Count);
}
foreach (SVGSpriteAssetFile spriteAsset in spriteAssets)
{
SVGSpriteData spriteData = spriteAsset.SpriteData;
Sprite sprite = spriteData.Sprite;
Vector2 pivot = spriteData.Pivot;
//float scl = 1 / spriteData.Scale;
float scl = 1;
float px = (sprite.rect.width * pivot.x + (float)spriteData.OriginalX) * scl - centerX;
float py = boxHeight - (sprite.rect.height * (1 - pivot.y) + (float)spriteData.OriginalY) * scl - centerY;
Vector2 worldPos = new Vector2(px / SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT, py / SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT);
// instantiate the object
int sortingOrder = SVGAtlas.SortingOrderCalc(svgIndex, svgAsset.InstanceBaseIdx, spriteData.ZOrder);
//instances.Add(this.InstantiateSprite(spriteAsset, worldPos, sortingOrder));
GameObject newObj = this.InstantiateSprite(spriteAsset, worldPos, sortingOrder);
newObj.transform.localScale = new Vector3(scl, scl, 1);
spriteData.InCurrentInstancesGroup = true;
}
// return the created instances
return(instances.ToArray());
}
}
}
return(null);
}
protected override bool SvgInputAssetDrawImplementation(SVGBasicAtlas basicAtlas, SVGAssetInput svgAsset, int svgAssetIndex)
{
SVGUIAtlas uiAtlas = basicAtlas as SVGUIAtlas;
bool isDirty = false;
// scale adjustment for this SVG
EditorGUILayout.LabelField(new GUIContent("Scale adjustment", "An additional scale factor used to adjust this SVG content only"), GUILayout.Width(105));
float offsetScale = EditorGUILayout.FloatField(svgAsset.Scale, GUILayout.Width(45));
EditorGUILayout.LabelField("", GUILayout.Width(5));
if (offsetScale != svgAsset.Scale)
{
uiAtlas.SvgAssetScaleAdjustmentSet(svgAsset, Math.Abs(offsetScale));
isDirty = true;
}
// 'explode groups' flag
bool separateGroups = EditorGUILayout.Toggle("", svgAsset.SeparateGroups, GUILayout.Width(14));
EditorGUILayout.LabelField("Separate groups", GUILayout.Width(105));
// if group explosion flag has been changed, update it
if (separateGroups != svgAsset.SeparateGroups)
{
uiAtlas.SvgAssetSeparateGroupsSet(svgAsset, separateGroups);
isDirty = true;
}
// if 'Remove' button is clicked, remove the SVG entry
if (GUILayout.Button("Remove", EditorStyles.miniButton, GUILayout.Width(70)))
{
uiAtlas.SvgAssetRemove(svgAssetIndex);
isDirty = true;
}
return(isDirty);
}
private bool DrawInspector(SVGUIAtlas uiAtlas, Canvas canvas)
{
Rect scollRect;
bool isDirty = false;
// get current event
Event currentEvent = Event.current;
// show current options
EditorGUILayout.LabelField("Canvas scale factor", uiAtlas.CanvasScaleFactor.ToString());
float offsetScale = EditorGUILayout.FloatField(this.m_OffsetScaleContent, uiAtlas.OffsetScale);
bool pow2Textures = EditorGUILayout.Toggle(this.m_Pow2TexturesContent, uiAtlas.Pow2Textures);
int maxTexturesDimension = EditorGUILayout.IntField(this.m_MaxTexturesDimensionContent, uiAtlas.MaxTexturesDimension);
int border = EditorGUILayout.IntField(this.m_SpritesPaddingContent, uiAtlas.SpritesBorder);
Color clearColor = EditorGUILayout.ColorField(this.m_ClearColorContent, uiAtlas.ClearColor);
bool fastUpload = EditorGUILayout.Toggle(this.m_FastUploadContent, uiAtlas.FastUpload);
float spritesPreviewSize = (float)EditorGUILayout.IntField(this.m_SpritesPreviewSizeContent, (int)uiAtlas.SpritesPreviewSize);
// output folder
this.OutputFolderDraw(uiAtlas);
// draw the list of input SVG files / assets
isDirty |= this.SvgInputAssetsDraw(uiAtlas, currentEvent, out scollRect);
// update button
if (this.UpdateButtonDraw(uiAtlas))
{
// regenerate/update sprites
uiAtlas.UpdateEditorSprites();
isDirty = true;
}
GUILayout.Space(10);
if (uiAtlas.SvgAssetsCount() > 0)
{
// list of sprites, grouped by SVG document
//Vector2 spritesScrollPos = EditorGUILayout.BeginScrollView(this.m_SvgSpritesScrollPos, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
Vector2 spritesScrollPos = EditorGUILayout.BeginScrollView(this.m_SvgSpritesScrollPos, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true), GUILayout.MinHeight(uiAtlas.SpritesPreviewSize * 5));
bool separatorNeeded = false;
for (int i = 0; i < uiAtlas.SvgAssetsCount(); ++i)
{
SVGAssetInput svgAsset = uiAtlas.SvgAsset(i);
List <SVGSpriteAssetFile> spritesAssets = uiAtlas.GetGeneratedSpritesByDocument(svgAsset.TxtAsset);
if (spritesAssets != null && spritesAssets.Count > 0)
{
// line separator
if (separatorNeeded)
{
EditorGUILayout.Separator();
GUILayout.Box(GUIContent.none, this.m_GreyLine, GUILayout.ExpandWidth(true), GUILayout.Height(1));
EditorGUILayout.Separator();
}
// display sprites list
foreach (SVGSpriteAssetFile spriteAsset in spritesAssets)
{
this.SpritePreview(uiAtlas, canvas, spriteAsset);
}
// we have displayed some sprites, next time a line separator is needed
separatorNeeded = true;
}
}
EditorGUILayout.EndScrollView();
if (this.m_SvgSpritesScrollPos != spritesScrollPos)
{
this.m_SvgSpritesScrollPos = spritesScrollPos;
}
}
// events handler
isDirty |= this.HandleDragEvents(uiAtlas, currentEvent, scollRect);
// a negative value is not allowed for texture max dimension
maxTexturesDimension = (maxTexturesDimension < 0) ? 1024 : maxTexturesDimension;
// a negative value is not allowed for border
border = (border < 0) ? 0 : border;
// if offset additional scale has been changed, update it
if (uiAtlas.OffsetScale != offsetScale)
{
uiAtlas.OffsetScale = Math.Abs(offsetScale);
isDirty = true;
}
// if power-of-two forcing flag has been changed, update it
if (uiAtlas.Pow2Textures != pow2Textures)
{
uiAtlas.Pow2Textures = pow2Textures;
isDirty = true;
}
// if desired maximum texture dimension has been changed, update it
if (uiAtlas.MaxTexturesDimension != maxTexturesDimension)
{
uiAtlas.MaxTexturesDimension = maxTexturesDimension;
isDirty = true;
}
// if border between each packed SVG has been changed, update it
if (uiAtlas.SpritesBorder != border)
{
uiAtlas.SpritesBorder = border;
isDirty = true;
}
// if surface clear color has been changed, update it
if (uiAtlas.ClearColor != clearColor)
{
uiAtlas.ClearColor = clearColor;
isDirty = true;
}
// if "fast upload" flag has been changed, update it
if (uiAtlas.FastUpload != fastUpload)
{
uiAtlas.FastUpload = fastUpload;
isDirty = true;
}
// if sprites preview size has been changed, update it
if (uiAtlas.SpritesPreviewSize != spritesPreviewSize)
{
uiAtlas.SpritesPreviewSize = spritesPreviewSize;
isDirty = true;
}
return(isDirty);
}
// Constructor.
public PackedSvgAssetDocLink(SVGAssetInput svgAsset, SVGDocument document)
{
this.m_Asset = svgAsset;
this.m_Document = document;
}
protected abstract bool SvgInputAssetDrawImplementation(SVGBasicAtlas atlas, SVGAssetInput svgAsset, int svgAssetIndex);
protected override bool SvgInputAssetDrawImplementation(SVGBasicAtlas basicAtlas, SVGAssetInput svgAsset, int svgAssetIndex)
{
SVGAtlas atlas = basicAtlas as SVGAtlas;
bool isDirty = false;
// scale adjustment for this SVG
EditorGUILayout.LabelField(new GUIContent("Scale adjustment", "An additional scale factor used to adjust this SVG content only"), GUILayout.Width(105));
float offsetScale = EditorGUILayout.FloatField(svgAsset.Scale, GUILayout.Width(45));
EditorGUILayout.LabelField("", GUILayout.Width(5));
if (offsetScale != svgAsset.Scale)
{
atlas.SvgAssetScaleAdjustmentSet(svgAsset, Math.Abs(offsetScale));
isDirty = true;
}
// 'explode groups' flag
bool separateGroups = EditorGUILayout.Toggle("", svgAsset.SeparateGroups, GUILayout.Width(14));
EditorGUILayout.LabelField("Separate groups", GUILayout.Width(105));
// if group explosion flag has been changed, update it
if (separateGroups != svgAsset.SeparateGroups)
{
atlas.SvgAssetSeparateGroupsSet(svgAsset, separateGroups);
isDirty = true;
}
// if 'Remove' button is clicked, remove the SVG entry
if (GUILayout.Button("Remove", EditorStyles.miniButton, GUILayout.Width(70)))
{
atlas.SvgAssetRemove(svgAssetIndex);
isDirty = true;
}
// instantiate all groups
GUI.enabled = ((svgAsset.Instantiable && (!Application.isPlaying)) ? true : false);
if (GUILayout.Button("Instantiate", EditorStyles.miniButton, GUILayout.Width(80)))
{
GameObject[] gameObjs = atlas.InstantiateGroups(svgAsset);
// set the created instances as selected
if (gameObjs != null)
{
Selection.objects = gameObjs;
}
}
GUI.enabled = !Application.isPlaying;
return(isDirty);
}
private bool DrawInspector(SVGAtlas atlas)
{
Rect scollRect;
float match = atlas.Match;
bool isDirty = false;
// get current event
Event currentEvent = Event.current;
// show current options
int refWidth = EditorGUILayout.IntField(new GUIContent("Reference width", "The resolution the SVG files content is designed for. If the screen resolution is larger, SVG contents will be scaled up, and if it’s smaller, it will be scaled down."), atlas.ReferenceWidth);
int refHeight = EditorGUILayout.IntField(new GUIContent("Reference height", "The resolution the SVG files content is designed for. If the screen resolution is larger, SVG contents will be scaled up, and if it’s smaller, it will be scaled down."), atlas.ReferenceHeight);
int deviceTestWidth = EditorGUILayout.IntField("Device test width", atlas.DeviceTestWidth);
int deviceTestHeight = EditorGUILayout.IntField("Device test height", atlas.DeviceTestHeight);
SVGScalerMatchMode scaleType = (SVGScalerMatchMode)EditorGUILayout.EnumPopup(new GUIContent("Screen match mode", "A mode used to scale (i.e. generate) SVG sprites if the aspect ratio of the current resolution doesn’t fit the reference resolution."), atlas.ScaleType);
if (scaleType == SVGScalerMatchMode.MatchWidthOrHeight)
{
Rect r = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight + 12);
match = this.MatchSlider(r, atlas.Match);
}
float offsetScale = EditorGUILayout.FloatField(this.m_OffsetScaleContent, atlas.OffsetScale);
bool pow2Textures = EditorGUILayout.Toggle(this.m_Pow2TexturesContent, atlas.Pow2Textures);
int maxTexturesDimension = EditorGUILayout.IntField(this.m_MaxTexturesDimensionContent, atlas.MaxTexturesDimension);
int border = EditorGUILayout.IntField(this.m_SpritesPaddingContent, atlas.SpritesBorder);
Color clearColor = EditorGUILayout.ColorField(this.m_ClearColorContent, atlas.ClearColor);
bool fastUpload = EditorGUILayout.Toggle(this.m_FastUploadContent, atlas.FastUpload);
float spritesPreviewSize = (float)EditorGUILayout.IntField(this.m_SpritesPreviewSizeContent, (int)atlas.SpritesPreviewSize);
// output folder
this.OutputFolderDraw(atlas);
// draw the list of input SVG files / assets
isDirty |= this.SvgInputAssetsDraw(atlas, currentEvent, out scollRect);
// update button
if (this.UpdateButtonDraw(atlas))
{
// regenerate/update sprites
atlas.UpdateEditorSprites(true);
isDirty = true;
}
GUILayout.Space(10);
if (atlas.SvgAssetsCount() > 0)
{
// list of sprites, grouped by SVG document
Vector2 spritesScrollPos = EditorGUILayout.BeginScrollView(this.m_SvgSpritesScrollPos, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
bool separatorNeeded = false;
for (int i = 0; i < atlas.SvgAssetsCount(); ++i)
{
SVGAssetInput svgAsset = atlas.SvgAsset(i);
List <SVGSpriteAssetFile> spritesAssets = atlas.GetGeneratedSpritesByDocument(svgAsset.TxtAsset);
if (spritesAssets != null && spritesAssets.Count > 0)
{
// line separator
if (separatorNeeded)
{
EditorGUILayout.Separator();
GUILayout.Box(GUIContent.none, this.m_GreyLine, GUILayout.ExpandWidth(true), GUILayout.Height(1));
EditorGUILayout.Separator();
}
// display sprites list
foreach (SVGSpriteAssetFile spriteAsset in spritesAssets)
{
this.SpritePreview(atlas, spriteAsset);
}
// we have displayed some sprites, next time a line separator is needed
separatorNeeded = true;
}
}
EditorGUILayout.EndScrollView();
if (this.m_SvgSpritesScrollPos != spritesScrollPos)
{
this.m_SvgSpritesScrollPos = spritesScrollPos;
}
}
// events handler
isDirty |= this.HandleDragEvents(atlas, currentEvent, scollRect);
// negative values are not allowed for reference resolution
refWidth = (refWidth <= 0) ? Screen.currentResolution.width : refWidth;
refHeight = (refHeight <= 0) ? Screen.currentResolution.height : refHeight;
deviceTestWidth = (deviceTestWidth <= 0) ? refWidth : deviceTestWidth;
deviceTestHeight = (deviceTestHeight <= 0) ? refHeight : deviceTestHeight;
// a negative value is not allowed for texture max dimension
maxTexturesDimension = (maxTexturesDimension < 0) ? 1024 : maxTexturesDimension;
// a negative value is not allowed for border
border = (border < 0) ? 0 : border;
// if reference resolution has been changed, update it
if (atlas.ReferenceWidth != refWidth)
{
atlas.ReferenceWidth = refWidth;
isDirty = true;
}
if (atlas.ReferenceHeight != refHeight)
{
atlas.ReferenceHeight = refHeight;
isDirty = true;
}
// if device (test) resolution has been changed, update it
if (atlas.DeviceTestWidth != deviceTestWidth)
{
atlas.DeviceTestWidth = deviceTestWidth;
isDirty = true;
}
if (atlas.DeviceTestHeight != deviceTestHeight)
{
atlas.DeviceTestHeight = deviceTestHeight;
isDirty = true;
}
// if scale adaption method has been changed, update it
if (atlas.ScaleType != scaleType)
{
atlas.ScaleType = scaleType;
isDirty = true;
}
if (atlas.Match != match)
{
atlas.Match = match;
isDirty = true;
}
// if offset additional scale has been changed, update it
if (atlas.OffsetScale != offsetScale)
{
atlas.OffsetScale = Math.Abs(offsetScale);
isDirty = true;
}
// if power-of-two forcing flag has been changed, update it
if (atlas.Pow2Textures != pow2Textures)
{
atlas.Pow2Textures = pow2Textures;
isDirty = true;
}
// if desired maximum texture dimension has been changed, update it
if (atlas.MaxTexturesDimension != maxTexturesDimension)
{
atlas.MaxTexturesDimension = maxTexturesDimension;
isDirty = true;
}
// if border between each packed SVG has been changed, update it
if (atlas.SpritesBorder != border)
{
atlas.SpritesBorder = border;
isDirty = true;
}
// if surface clear color has been changed, update it
if (atlas.ClearColor != clearColor)
{
atlas.ClearColor = clearColor;
isDirty = true;
}
// if "fast upload" flag has been changed, update it
if (atlas.FastUpload != fastUpload)
{
atlas.FastUpload = fastUpload;
isDirty = true;
}
// if sprites preview size has been changed, update it
if (atlas.SpritesPreviewSize != spritesPreviewSize)
{
atlas.SpritesPreviewSize = spritesPreviewSize;
isDirty = true;
}
return(isDirty);
}
public override bool SvgAssetMove(SVGAssetInput svgAsset, int toIndex)
{
int fromIndex = this.SvgAssetIndexGet(svgAsset.TxtAsset);
return(this.SvgAssetMove(svgAsset, fromIndex, toIndex));
}