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 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;
        }
    }
    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);
        }
    }
Beispiel #5
0
    private void OnAtlasSelect(SVGAtlas atlas)
    {
        if (this.m_EditedLoader.Atlas != atlas)
        {
            this.m_EditedLoader.Atlas           = atlas;
            this.m_EditedLoader.SpriteReference = null;

            SpriteRenderer renderer = this.m_EditedLoader.GetComponent <SpriteRenderer>();
            if (renderer != null)
            {
                renderer.sprite = null;
            }
        }
    }
    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);
    }
Beispiel #7
0
    // Draw an atlas preview
    private static void AtlasPreview(SVGAtlas atlas, Rect clipRect, int textureIndex)
    {
        int       idx          = textureIndex % atlas.TextureAssetsCount();
        AssetFile textureAsset = atlas.TextureAsset(idx);
        Texture2D atlasTexture = textureAsset.Object as Texture2D;

        if (atlasTexture != null)
        {
            Rect  uv            = new Rect(0, 0, 1, 1);
            float maxAtlasDim   = Math.Max(atlasTexture.width, atlasTexture.height);
            float previewWidth  = (atlasTexture.width / maxAtlasDim) * SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION;
            float previewHeight = (atlasTexture.height / maxAtlasDim) * SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION;
            float previewX      = (SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION - previewWidth) / 2;
            float previewY      = (SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION - previewHeight) / 2;
            Rect  previewRect   = new Rect(clipRect.xMin + previewX, clipRect.yMin + previewY, previewWidth, previewHeight);
            GUI.DrawTextureWithTexCoords(previewRect, atlasTexture, uv, true);
        }
    }
    private static void UpdatePivotHierarchy(GameObject gameObj, Vector2 delta, uint depthLevel)
    {
        SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();

        if (loader != null)
        {
            Vector2 realDelta = (depthLevel > 0) ? (new Vector2(-delta.x, -delta.y)) : (new Vector2(delta.x * gameObj.transform.localScale.x, delta.y * gameObj.transform.localScale.y));
            Vector2 newPos    = new Vector2(gameObj.transform.localPosition.x + realDelta.x, gameObj.transform.localPosition.y + realDelta.y);
            // modify the current node
            gameObj.transform.localPosition = newPos;
        }

        // traverse children
        int j = gameObj.transform.childCount;

        for (int i = 0; i < j; ++i)
        {
            GameObject child = gameObj.transform.GetChild(i).gameObject;
            SVGAtlas.UpdatePivotHierarchy(child, delta, depthLevel + 1);
        }
    }
    public override void OnInspectorGUI()
    {
        if (SVGAtlasEditor.m_Styles == null)
        {
            SVGAtlasEditor.m_Styles = new Styles();
        }

        // get the target object
        SVGAtlas atlas = target as SVGAtlas;

        if (atlas != null)
        {
            base.OnInspectorGUI();
            // we assign the Name property, so we can check if the user has renamed the atlas asset file
            atlas.Name = atlas.name;
            bool isDirty = this.DrawInspector(atlas);
            if (isDirty)
            {
                SVGUtils.MarkObjectDirty(atlas);
                SVGUtils.MarkSceneDirty();
            }
        }
    }
    // recalculate sorting orders of instantiated sprites: changing is due only to SVG index, so the lower part (group + zNatural) is left unchanged
    private void SortingOrdersUpdateSvgIndex()
    {
        // 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>();
            SpriteRenderer           renderer     = (SpriteRenderer)gameObj.GetComponent <SpriteRenderer>();
            if (renderer != null)
            {
                SVGSpriteRef spriteRef = spriteLoader.SpriteReference;
                int          svgIndex  = this.SvgAssetIndexGet(spriteRef.TxtAsset);
                if (svgIndex >= 0)
                {
                    int instance = renderer.sortingOrder & SPRITES_SORTING_INSTANCES_MASK;
                    renderer.sortingOrder = SVGAtlas.SortingOrderCalc(svgIndex, instance);
                }
            }
        }
    }
    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);
    }
Beispiel #12
0
    static private List <SVGAtlas> GetAtlasesList()
    {
        string[]        guids       = AssetDatabase.FindAssets("t:SVGAtlas");
        List <SVGAtlas> atlasesList = new List <SVGAtlas>();

        foreach (string assetGUID in guids)
        {
            string             assetPath = AssetDatabase.GUIDToAssetPath(assetGUID);
            UnityEngine.Object asset     = AssetDatabase.LoadAssetAtPath(assetPath, typeof(SVGAtlas));
            SVGAtlas           atlas     = asset as SVGAtlas;

            if (atlas != null)
            {
                atlasesList.Add(atlas);
            }
        }

        // sort atlases by name
        atlasesList.Sort(delegate(SVGAtlas atlas1, SVGAtlas atlas2) {
            return(string.Compare(atlas1.name, atlas2.name, StringComparison.OrdinalIgnoreCase));
        });

        return(atlasesList);
    }
    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);
    }
Beispiel #14
0
    private void OnAtlasSelect(SVGAtlas atlas)
    {
        if (this.m_EditedLoader.Atlas != atlas)
        {
            this.m_EditedLoader.Atlas = atlas;
            this.m_EditedLoader.SpriteReference = null;

            SpriteRenderer renderer = this.m_EditedLoader.GetComponent<SpriteRenderer>();
            if (renderer != null)
                renderer.sprite = null;
        }
    }
Beispiel #15
0
    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) / SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION_PADDED), 1);
        int  rowsCount     = 1;
        int  atlasIdx      = 0;
        Rect rect          = new Rect(SVGAtlasSelector.ATLAS_PREVIEW_BORDER, SVGAtlasSelector.ATLAS_PREVIEW_BORDER,
                                      SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION, SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION);
        // draw header, with the name of atlas and the "search by name" toolbox
        List <SVGAtlas> atlasesList = this.Header();

        this.m_ScrollPos = GUILayout.BeginScrollView(this.m_ScrollPos);
        while (atlasIdx < atlasesList.Count)
        {
            // start a new row
            GUILayout.BeginHorizontal();
            {
                int currentColumn = 0;
                rect.x = SVGAtlasSelector.ATLAS_PREVIEW_BORDER;

                while (atlasIdx < atlasesList.Count)
                {
                    SVGAtlas atlas = atlasesList[atlasIdx];

                    // buttons are used to implement atlas selection (we use the atlas name as tooltip)
                    if (GUI.Button(rect, new GUIContent("", atlas.name)))
                    {
                        // mouse left button click
                        if (Event.current.button == 0)
                        {
                            if (this.m_Callback != null)
                            {
                                this.m_Callback(atlas);
                            }
                            close = true;
                        }
                    }
                    // draw atlas preview
                    if (Event.current.type == EventType.Repaint)
                    {
                        SVGAtlasSelector.AtlasPreview(atlas, rect, this.m_TextureIndex);
                    }
                    // draw atlas name
                    SVGAtlasSelector.AtlasLabel(atlas.name, rect);

                    // next atlas
                    atlasIdx++;
                    // next column
                    rect.x += SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION_PADDED;
                    if (++currentColumn >= columnsPerRow)
                    {
                        break;
                    }
                }
            }

            GUILayout.EndHorizontal();
            GUILayout.Space(SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION_PADDED);
            rect.y += SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION_PADDED + SVGAtlasSelector.ATLAS_NAME_HEIGHT;
            rowsCount++;
        }

        GUILayout.Space((rowsCount - 1) * SVGAtlasSelector.ATLAS_NAME_HEIGHT + SVGAtlasSelector.ATLAS_PREVIEW_BORDER);
        GUILayout.EndScrollView();

        return(close);
    }
Beispiel #16
0
 // Reset is called when the user hits the Reset button in the Inspector's context menu or when adding the component the first time.
 // This function is only called in editor mode. Reset is most commonly used to give good default values in the inspector.
 void Reset()
 {
     this.Camera = null;
     this.Background = null;
     this.Atlas = null;
     this.Cards = null;
     this.m_SelectedCard0 = null;
     this.m_SelectedCard1 = null;
     this.m_Animating = false;
 }
Beispiel #17
0
    // Draw an atlas preview
    private static void AtlasPreview(SVGAtlas atlas, Rect clipRect, int textureIndex)
    {
        List<AssetFile> texturesAssets = atlas.GeneratedTexturesFiles;
        int idx = textureIndex % texturesAssets.Count;
        Texture2D atlasTexture = texturesAssets[idx].Object as Texture2D;

        if (atlasTexture != null)
        {
            Rect uv = new Rect(0, 0, 1, 1);
            float maxAtlasDim = Math.Max(atlasTexture.width, atlasTexture.height);
            float previewWidth = (atlasTexture.width / maxAtlasDim) * SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION;
            float previewHeight = (atlasTexture.height / maxAtlasDim) * SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION;
            float previewX = (SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION - previewWidth) / 2;
            float previewY = (SVGAtlasSelector.ATLAS_PREVIEW_DIMENSION - previewHeight) / 2;
            Rect previewRect = new Rect(clipRect.xMin + previewX, clipRect.yMin + previewY, previewWidth, previewHeight);
            GUI.DrawTextureWithTexCoords(previewRect, atlasTexture, uv, true);
        }
    }
Beispiel #18
0
    // show the sprite selector
    public static void Show(SVGAtlas atlas, string spriteName, OnSpriteSelectionCallback callback)
    {
        // close the current selector instance, if any
        SVGSpriteSelector.CloseAll();

        if (atlas != null)
        {
            SVGSpriteSelector selector = ScriptableWizard.DisplayWizard<SVGSpriteSelector>("Select a sprite");
            selector.m_Atlas = atlas;
            selector.m_SearchString = spriteName;
            selector.m_Callback = callback;
            selector.m_ScrollPos = Vector2.zero;
            selector.m_SpritesList = SVGSpriteSelector.GetSpritesList(atlas);
            //selector.m_SelectedSprite = null;
        }
    }
 private static int SortingOrderCalc(int svgIndex, int instanceBaseIdx, int zOrder)
 {
     return(SVGAtlas.SortingOrderCalc(svgIndex, instanceBaseIdx + zOrder));
 }
    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);
    }
Beispiel #21
0
    private static List<SVGSpriteAssetFile> GetSpritesList(SVGAtlas atlas)
    {
        List<SVGSpriteAssetFile> spritesList = atlas.GeneratedSpritesFiles.Values();

        spritesList.Sort(delegate(SVGSpriteAssetFile spriteAsset1, SVGSpriteAssetFile spriteAsset2) {

            Sprite sprite1 = spriteAsset1.SpriteData.Sprite;
            Sprite sprite2 = spriteAsset2.SpriteData.Sprite;

            return string.Compare(sprite1.name, sprite2.name, StringComparison.OrdinalIgnoreCase);
        });

        return spritesList;
    }