Beispiel #1
0
    public void UpdateSpriteAnimations()
    {
        for (int index = 0; index < this.spriteAnimationList.Count; index++)
        {
            SpriteAnimationItem          spriteAnimationItem = this.spriteAnimationList[index];
            SpriteCollection.TextureData textureData         = GetTextureDataDirection(spriteAnimationItem.sprite);

            if (textureData.framesCount > 1)
            {
                if (Time.realtimeSinceStartup - spriteAnimationItem.lastUpdatedTime >= 1.0f / textureData.fps)
                {
                    spriteAnimationItem.lastUpdatedTime = Time.realtimeSinceStartup;
                    spriteAnimationItem.currentFrame++;
                    if (spriteAnimationItem.currentFrame >= textureData.framesCount)
                    {
                        spriteAnimationItem.currentFrame = 0;
                    }
                }
            }
            else
            {
                spriteAnimationItem.currentFrame = 0;
            }
        }
        Repaint();
    }
Beispiel #2
0
    public void InitSpriteAnimations()
    {
        if (selectedItemIndex == -1)
        {
            return;
        }

        ItemsCollection.ItemData itemData = itemsCollection.list[selectedItemIndex];

        this.spriteAnimationList = new List <SpriteAnimationItem>();
        foreach (int spriteId in itemData.GetSprites((Common.State)state))
        {
            SpriteCollection.SpriteData sprite = spriteCollection.GetSprite(spriteId);

            SpriteAnimationItem spriteAnimationData = new SpriteAnimationItem();
            spriteAnimationData.sprite          = sprite;
            spriteAnimationData.lastUpdatedTime = Time.realtimeSinceStartup;

            SpriteCollection.TextureData textureData = GetTextureDataDirection(sprite);

            spriteAnimationData.numberOfColumns = textureData.numberOfColumns;
            spriteAnimationData.numberOfRows    = textureData.numberOfRows;

            this.spriteAnimationList.Add(spriteAnimationData);
        }
        this.spriteAnimationList.Sort(SortByDepth);
    }
Beispiel #3
0
    private SpriteCollection.TextureData GetTextureDataDirection(SpriteCollection.SpriteData sprite)
    {
        SpriteCollection.TextureData selectedTextureData = sprite.bottomTexture;

        switch ((Common.Direction)direction)
        {
        case Common.Direction.BOTTOM:
            selectedTextureData = sprite.bottomTexture;
            break;

        case Common.Direction.BOTTOM_RIGHT:
            selectedTextureData = sprite.bottomRightTexture;
            break;

        case Common.Direction.RIGHT:
            selectedTextureData = sprite.rightTexture;
            break;

        case Common.Direction.TOP_RIGHT:
            selectedTextureData = sprite.topRightTexture;
            break;

        case Common.Direction.TOP:
            selectedTextureData = sprite.topTexture;
            break;
        }

        return(selectedTextureData);
    }
Beispiel #4
0
    void RenderPreviewArea()
    {
        if (gridTexture == null)
        {
            gridTexture = Resources.Load("grid_4x4", typeof(Texture2D)) as Texture2D;
        }

        //DRAW GRID
        Vector2 centerPointOfPreviewArea = new Vector2((WidthOfLetPanel + position.width - WidthOfRightPanel) / 2, position.height / 2);

        GUI.Label(new Rect(centerPointOfPreviewArea.x - defaultGridSize.x / 2, centerPointOfPreviewArea.y - defaultGridSize.y / 2, defaultGridSize.x, defaultGridSize.y), gridTexture);

        //DRAW ITEM SPRITE
        if (selectedItemIndex != -1)
        {
            for (int index = 0; index < this.spriteAnimationList.Count; index++)
            {
                SpriteAnimationItem spriteAnimationItem = this.spriteAnimationList[index];

                SpriteCollection.TextureData textureData = GetTextureDataDirection(spriteAnimationItem.sprite);
                Texture2D texture = textureData.texture;

                if (texture == null)
                {
                    continue;
                }

                float scale           = textureData.scale;
                int   numberOfColumns = spriteAnimationItem.numberOfColumns;
                int   numberOfRows    = spriteAnimationItem.numberOfRows;
                float offsetX         = textureData.offsetX;
                float offsetY         = textureData.offsetY;
                int   gridSize        = spriteAnimationItem.sprite.gridSize;

                defaultImgSize.x = 256 * scale / 100;
                defaultImgSize.x = 256 * scale / 100;

                float heightFactor = ((float)texture.height / (float)texture.width) * ((float)numberOfColumns / numberOfRows);

                float upFactor = Mathf.Cos(Mathf.Deg2Rad * 45) * gridSize / 2.0f;

                float x = (centerPointOfPreviewArea.x - defaultImgSize.x / 2) + offsetX;
                float y = (centerPointOfPreviewArea.y - defaultImgSize.x * heightFactor / 2) - offsetY;

                float framePaddingX = defaultImgSize.x * (spriteAnimationItem.currentFrame % numberOfColumns);
                float framePaddingY = defaultImgSize.x * heightFactor * (spriteAnimationItem.currentFrame / numberOfColumns);

                Rect imgRect = new Rect(x, y, defaultImgSize.x, defaultImgSize.x * heightFactor);

                GUI.BeginGroup(imgRect);
                GUI.DrawTexture(new Rect(-framePaddingX, -framePaddingY, defaultImgSize.x * numberOfColumns, defaultImgSize.x * spriteAnimationItem.numberOfRows * heightFactor), texture);
                GUI.EndGroup();
            }
        }
    }
    public void AddRenderQuad(SpriteCollection.TextureData textureData, int layer)
    {
        if (textureData == null)
        {
            return;
        }

        if (textureData.texture == null)
        {
            return;
        }

        RenderQuadScript renderQuadInstance = Utilities.CreateRenderQuad();

        renderQuadInstance.transform.SetParent(this.RenderQuadsContainer.transform);

        //POSITIONING AND SCALING
        Vector3 defaultImgSize = new Vector3(1.4142f, 1.4142f, 1.4142f) * 4 * textureData.scale / 100.0f / textureData.parent.gridSize;
        float   heightFactor   = ((float)textureData.texture.height / (float)textureData.texture.width) * ((float)textureData.numberOfColumns / textureData.numberOfRows);

        float offsetX = (1.414f / 256.0f) * textureData.offsetX * 4 / textureData.parent.gridSize;
        float offsetY = (1.414f / 256.0f) * textureData.offsetY * 4 / textureData.parent.gridSize;

        renderQuadInstance.transform.localPosition = new Vector3(offsetX, offsetY, 0);
        renderQuadInstance.transform.localRotation = Quaternion.Euler(Vector3.zero);
        renderQuadInstance.transform.localScale    = new Vector3(defaultImgSize.x, defaultImgSize.x * heightFactor, 1);

        renderQuadInstance.SetData(textureData, layer);
        renderQuadInstance.GetComponent <TextureSheetAnimationScript>()
        .SetTextureSheetData(textureData.numberOfColumns, textureData.numberOfRows, textureData.framesCount, textureData.fps);

        this._renderQuads.Add(renderQuadInstance);

        if (layer == 0)
        {
            //ground patch layer
            this._groundPatch = renderQuadInstance;
        }
    }
Beispiel #6
0
    private void UpdateDataValues()
    {
        if (selectedSpriteIndex == -1)
        {
            return;
        }
        SpriteCollection.SpriteData spriteData = spriteCollection.list [selectedSpriteIndex];

        spriteData.name = this.name;

        //update textures
        spriteData.bottomTexture.texture      = textureBottom;
        spriteData.bottomRightTexture.texture = textureBottomRight;
        spriteData.rightTexture.texture       = textureRight;
        spriteData.topRightTexture.texture    = textureTopRight;
        spriteData.topTexture.texture         = textureTop;

        SpriteCollection.TextureData selectedTextureData = spriteData.bottomTexture;
        if (direction == 0)
        {
            selectedTextureData = spriteData.bottomTexture;
        }
        else if (direction == 1)
        {
            selectedTextureData = spriteData.bottomRightTexture;
        }
        else if (direction == 2)
        {
            selectedTextureData = spriteData.rightTexture;
        }
        else if (direction == 3)
        {
            selectedTextureData = spriteData.topRightTexture;
        }
        else if (direction == 4)
        {
            selectedTextureData = spriteData.topTexture;
        }

        if (offsetX != selectedTextureData.offsetX)
        {
            selectedTextureData.offsetX = offsetX;
        }

        if (offsetY != selectedTextureData.offsetY)
        {
            selectedTextureData.offsetY = offsetY;
        }

        if (scale != selectedTextureData.scale)
        {
            selectedTextureData.scale = scale;
        }

        if (numberOfColumns != selectedTextureData.numberOfColumns)
        {
            selectedTextureData.numberOfColumns = numberOfColumns;
        }

        if (numberOfRows != selectedTextureData.numberOfRows)
        {
            selectedTextureData.numberOfRows = numberOfRows;
        }

        if (framesCount != selectedTextureData.framesCount)
        {
            selectedTextureData.framesCount = framesCount;
        }

        if (fps != selectedTextureData.fps)
        {
            selectedTextureData.fps = fps;
        }

        if (gridSize != spriteData.gridSize)
        {
            spriteData.gridSize = gridSize;
        }

        if (renderingLayer != (int)spriteData.renderingLayer)
        {
            spriteData.renderingLayer = (Common.RenderingLayer)renderingLayer;
        }

        if (renderingOrder != spriteData.renderingOrder)
        {
            spriteData.renderingOrder = renderingOrder;
        }

        EditorUtility.SetDirty(spriteCollection);
    }
Beispiel #7
0
    private void LoadDataValues()
    {
        if (selectedSpriteIndex == -1)
        {
            return;
        }
        SpriteCollection.SpriteData spriteData = spriteCollection.list [selectedSpriteIndex];

        name = spriteData.name;

        //update textures
        textureBottom      = spriteData.bottomTexture.texture;
        textureBottomRight = spriteData.bottomRightTexture.texture;
        textureRight       = spriteData.rightTexture.texture;
        textureTopRight    = spriteData.topRightTexture.texture;
        textureTop         = spriteData.topTexture.texture;

        SpriteCollection.TextureData selectedTextureData = spriteData.bottomTexture;
        if (direction == 0)
        {
            selectedTextureData = spriteData.bottomTexture;
        }
        else if (direction == 1)
        {
            selectedTextureData = spriteData.bottomRightTexture;
        }
        else if (direction == 2)
        {
            selectedTextureData = spriteData.rightTexture;
        }
        else if (direction == 3)
        {
            selectedTextureData = spriteData.topRightTexture;
        }
        else if (direction == 4)
        {
            selectedTextureData = spriteData.topTexture;
        }

        gridSize = spriteData.gridSize;
        if (gridSize == 0)
        {
            gridTexture = null;
        }
        else if (gridSize == 1)
        {
            gridTexture = Resources.Load("grid_1x1", typeof(Texture2D)) as Texture2D;
        }
        else if (gridSize == 2)
        {
            gridTexture = Resources.Load("grid_2x2", typeof(Texture2D)) as Texture2D;
        }
        else if (gridSize == 3)
        {
            gridTexture = Resources.Load("grid_3x3", typeof(Texture2D)) as Texture2D;
        }
        else if (gridSize == 4)
        {
            gridTexture = Resources.Load("grid_4x4", typeof(Texture2D)) as Texture2D;
        }
        else if (gridSize == 5)
        {
            gridTexture = Resources.Load("grid_5x5", typeof(Texture2D)) as Texture2D;
        }
        else if (gridSize == 6)
        {
            gridTexture = Resources.Load("grid_6x6", typeof(Texture2D)) as Texture2D;
        }

        renderingLayer = (int)spriteData.renderingLayer;

        renderingOrder       = spriteData.renderingOrder;
        renderingOrderString = spriteData.renderingOrder.ToString();


        offsetX       = (int)selectedTextureData.offsetX;
        offsetXString = offsetX.ToString();

        offsetY       = (int)selectedTextureData.offsetY;
        offsetYString = offsetY.ToString();

        scale       = (int)selectedTextureData.scale;
        scaleString = scale.ToString();


        numberOfColumns       = (int)selectedTextureData.numberOfColumns;
        numberOfColumnsString = numberOfColumns.ToString();

        numberOfRows       = (int)selectedTextureData.numberOfRows;
        numberOfRowsString = numberOfRows.ToString();

        framesCount       = (int)selectedTextureData.framesCount;
        framesCountString = framesCount.ToString();

        fps       = (int)selectedTextureData.fps;
        fpsString = fps.ToString();
    }
    /* private vars */

    public void SetData(SpriteCollection.TextureData textureData, int layer)
    {
        this.MeshRenderer.material = Sprites.GetTextureMaterial(textureData.texture, textureData.parent.renderingLayer, textureData.parent.renderingOrder);
    }