Пример #1
0
    static public void MaskSpriteDepthWithAtlas(LightingBuffer2D buffer, LightingTile tile, LayerSetting layerSetting, LightingTilemapCollider2D id, Vector2D offset, float z)
    {
        if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite)
        {
            return;
        }

        if (id.maskType == LightingTilemapCollider2D.MaskType.None)
        {
            return;
        }

        if (tile.GetOriginalSprite() == null)
        {
            return;
        }

        Sprite sprite = tile.GetAtlasSprite();

        Vector2 scale = new Vector2(1, 1);

        if (sprite == null)
        {
            Sprite reqSprite = SpriteAtlasManager.RequestSprite(tile.GetOriginalSprite(), SpriteRequest.Type.WhiteMask);
            if (reqSprite == null)
            {
                PartiallyBatched_Tilemap batched = new PartiallyBatched_Tilemap();

                batched.virtualSpriteRenderer        = new VirtualSpriteRenderer();
                batched.virtualSpriteRenderer.sprite = tile.GetOriginalSprite();

                batched.polyOffset = offset.ToVector2();

                batched.tileSize = scale;

                batched.tilemap = id;

                buffer.partiallyBatchedList_Tilemap.Add(batched);
                return;
            }
            else
            {
                tile.SetAtlasSprite(reqSprite);
                sprite = reqSprite;
            }
        }

        VirtualSpriteRenderer spriteRenderer = new VirtualSpriteRenderer();

        spriteRenderer.sprite = sprite;

        Max2D.DrawSpriteBatched_Tris(spriteRenderer, layerSetting, id.maskMode, offset.ToVector2(), scale, id.transform.rotation.eulerAngles.z, z);

        LightingDebug.maskGenerations++;
    }
Пример #2
0
    static public void MaskSpriteWithAtlas(LightingBuffer2D buffer, LightingTilemapCollider2D id, Vector2D offset, float z)
    {
        if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite)
        {
            return;
        }

        if (id.map == null)
        {
            return;
        }

        SetupLocation(buffer, id);

        Sprite reqSprite;
        PartiallyBatched_Tilemap batched;

        for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
        {
            for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
            {
                if (x < 0 || y < 0)
                {
                    continue;
                }

                if (x >= id.area.size.x || y >= id.area.size.y)
                {
                    continue;
                }

                tile = id.map[x, y];
                if (tile == null)
                {
                    continue;
                }

                if (tile.GetOriginalSprite() == null)
                {
                    continue;
                }

                polyOffset.x = x + tilemapOffset.x;
                polyOffset.y = y + tilemapOffset.y;

                polyOffset.x *= scale.x;
                polyOffset.y *= scale.y;

                polyOffset2.x = (float)polyOffset.x;
                polyOffset2.y = (float)polyOffset.y;

                if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > 2 + buffer.lightSource.lightSize)
                {
                    LightingDebug.culled++;
                    continue;
                }

                polyOffset.x += offset.x;
                polyOffset.y += offset.y;

                spriteRenderer.sprite = tile.GetAtlasSprite();

                if (spriteRenderer.sprite == null)
                {
                    reqSprite = SpriteAtlasManager.RequestSprite(tile.GetOriginalSprite(), SpriteRequest.Type.WhiteMask);
                    if (reqSprite == null)
                    {
                        // Add Partialy Batched
                        batched = new PartiallyBatched_Tilemap();

                        batched.virtualSpriteRenderer        = new VirtualSpriteRenderer();
                        batched.virtualSpriteRenderer.sprite = tile.GetOriginalSprite();

                        batched.polyOffset = polyOffset.ToVector2();

                        batched.tileSize = tileSize;

                        buffer.partiallyBatchedList_Tilemap.Add(batched);
                        continue;
                    }
                    else
                    {
                        tile.SetAtlasSprite(reqSprite);
                        spriteRenderer.sprite = reqSprite;
                    }
                }

                polyOffset2.x = (float)polyOffset.x;
                polyOffset2.y = (float)polyOffset.y;

                Max2D.DrawSpriteBatched_Tris(spriteRenderer, buffer.lightSource.layerSetting[0], id.maskMode, polyOffset2, tileSize, 0, z);

                LightingDebug.maskGenerations++;
            }
        }
    }