Example #1
0
 public void DrawGizmos()
 {
     if (this.bestRoot != null)
     {
         MB2_TexturePacker.drawGizmosNode(this.bestRoot.root);
     }
 }
        public static AtlasPackingResult[] CalculateAtlasRectanglesStatic(MB3_TextureCombinerPipeline.TexturePipelineData data, bool doMultiAtlas, MB2_LogLevel LOG_LEVEL)
        {
            List <Vector2> imageSizes = new List <Vector2>();

            for (int i = 0; i < data.distinctMaterialTextures.Count; i++)
            {
                imageSizes.Add(new Vector2(data.distinctMaterialTextures[i].idealWidth, data.distinctMaterialTextures[i].idealHeight));
            }

            MB2_TexturePacker tp = MB3_TextureCombinerPipeline.CreateTexturePacker(data._packingAlgorithm);

            tp.atlasMustBePowerOfTwo = data._meshBakerTexturePackerForcePowerOfTwo;
            List <AtlasPadding> paddings = new List <AtlasPadding>();

            for (int i = 0; i < imageSizes.Count; i++)
            {
                AtlasPadding padding = new AtlasPadding();
                padding.topBottom = data._atlasPadding;
                padding.leftRight = data._atlasPadding;
                if (data._packingAlgorithm == MB2_PackingAlgorithmEnum.MeshBakerTexturePacker_Horizontal)
                {
                    padding.leftRight = 0;
                }
                if (data._packingAlgorithm == MB2_PackingAlgorithmEnum.MeshBakerTexturePacker_Vertical)
                {
                    padding.topBottom = 0;
                }
                paddings.Add(padding);
            }

            return(tp.GetRects(imageSizes, paddings, data._maxAtlasWidth, data._maxAtlasHeight, doMultiAtlas));
        }
Example #3
0
 private static void printTree(MB2_TexturePacker.Node r, string spc)
 {
     if (r.child[0] != null)
     {
         MB2_TexturePacker.printTree(r.child[0], spc + "  ");
     }
     if (r.child[1] != null)
     {
         MB2_TexturePacker.printTree(r.child[1], spc + "  ");
     }
 }
Example #4
0
        public AtlasPackingResult CalculateAtlasRectangles(MB3_TextureCombinerPipeline.TexturePipelineData data, MB2_LogLevel LOG_LEVEL)
        {
            if (data._packingAlgorithm == MB2_PackingAlgorithmEnum.UnitysPackTextures)
            {
                //with Unity texture packer we don't find the rectangles, Unity does. When packer is run
                return(new AtlasPackingResult(new AtlasPadding[0]));
            }
            AtlasPackingResult uvRects;

            if (data.distinctMaterialTextures.Count == 1 && data._fixOutOfBoundsUVs == false)
            {
                if (LOG_LEVEL >= MB2_LogLevel.debug)
                {
                    Debug.Log("Only one image per atlas. Will re-use original texture");
                }
                AtlasPadding[] paddings = new AtlasPadding[] { new AtlasPadding(data._atlasPadding) };
                uvRects          = new AtlasPackingResult(paddings);
                uvRects.rects    = new Rect[1];
                uvRects.rects[0] = new Rect(0f, 0f, 1f, 1f);
                uvRects.atlasX   = data.distinctMaterialTextures[0].idealWidth;
                uvRects.atlasY   = data.distinctMaterialTextures[0].idealHeight;
            }
            else
            {
                List <Vector2> imageSizes = new List <Vector2>();
                for (int i = 0; i < data.distinctMaterialTextures.Count; i++)
                {
                    imageSizes.Add(new Vector2(data.distinctMaterialTextures[i].idealWidth, data.distinctMaterialTextures[i].idealHeight));
                }
                MB2_TexturePacker tp = MB3_TextureCombinerPipeline.CreateTexturePacker(data._packingAlgorithm);
                tp.atlasMustBePowerOfTwo = data._meshBakerTexturePackerForcePowerOfTwo;
                int atlasMaxDimension        = data._maxAtlasSize;
                List <AtlasPadding> paddings = new List <AtlasPadding>();
                for (int i = 0; i < imageSizes.Count; i++)
                {
                    AtlasPadding padding = new AtlasPadding();
                    padding.topBottom = data._atlasPadding;
                    padding.leftRight = data._atlasPadding;
                    if (data._packingAlgorithm == MB2_PackingAlgorithmEnum.MeshBakerTexturePacker_Horizontal)
                    {
                        padding.leftRight = 0;
                    }
                    if (data._packingAlgorithm == MB2_PackingAlgorithmEnum.MeshBakerTexturePacker_Vertical)
                    {
                        padding.topBottom = 0;
                    }
                    paddings.Add(padding);
                }
                AtlasPackingResult[] packerRects = tp.GetRects(imageSizes, paddings, atlasMaxDimension, atlasMaxDimension, false);
                uvRects = packerRects[0];
            }
            return(uvRects);
        }
Example #5
0
 private static void flattenTree(MB2_TexturePacker.Node r, List <MB2_TexturePacker.Image> putHere)
 {
     if (r.img != null)
     {
         r.img.x = r.r.x;
         r.img.y = r.r.y;
         putHere.Add(r.img);
     }
     if (r.child[0] != null)
     {
         MB2_TexturePacker.flattenTree(r.child[0], putHere);
     }
     if (r.child[1] != null)
     {
         MB2_TexturePacker.flattenTree(r.child[1], putHere);
     }
 }
Example #6
0
        private static void drawGizmosNode(MB2_TexturePacker.Node r)
        {
            Vector3 size   = new Vector3((float)r.r.w, (float)r.r.h, 0f);
            Vector3 center = new Vector3((float)r.r.x + size.x / 2f, (float)(-(float)r.r.y) - size.y / 2f, 0f);

            Gizmos.DrawWireCube(center, size);
            if (r.img != null)
            {
                Gizmos.color = Color.blue;
                size         = new Vector3((float)r.img.w, (float)r.img.h, 0f);
                center       = new Vector3((float)r.img.x + size.x / 2f, (float)(-(float)r.img.y) - size.y / 2f, 0f);
                Gizmos.DrawCube(center, size);
            }
            if (r.child[0] != null)
            {
                Gizmos.color = Color.red;
                MB2_TexturePacker.drawGizmosNode(r.child[0]);
            }
            if (r.child[1] != null)
            {
                Gizmos.color = Color.green;
                MB2_TexturePacker.drawGizmosNode(r.child[1]);
            }
        }
Example #7
0
        private Rect[] _GetRects(List <Vector2> imgWidthHeights, int maxDimension, int padding, int minImageSizeX, int minImageSizeY, int masterImageSizeX, int masterImageSizeY, out int outW, out int outH, int recursionDepth)
        {
            if (this.LOG_LEVEL >= MB2_LogLevel.debug)
            {
                Debug.Log(string.Format("_GetRects numImages={0}, maxDimension={1}, padding={2}, minImageSizeX={3}, minImageSizeY={4}, masterImageSizeX={5}, masterImageSizeY={6}, recursionDepth={7}", new object[]
                {
                    imgWidthHeights.Count,
                    maxDimension,
                    padding,
                    minImageSizeX,
                    minImageSizeY,
                    masterImageSizeX,
                    masterImageSizeY,
                    recursionDepth
                }));
            }
            if (recursionDepth > 10)
            {
                Debug.LogError("Maximum recursion depth reached. Couldn't find packing for these textures.");
                outW = 0;
                outH = 0;
                return(new Rect[0]);
            }
            float num  = 0f;
            int   num2 = 0;
            int   num3 = 0;

            MB2_TexturePacker.Image[] array = new MB2_TexturePacker.Image[imgWidthHeights.Count];
            for (int i = 0; i < array.Length; i++)
            {
                MB2_TexturePacker.Image image = array[i] = new MB2_TexturePacker.Image(i, (int)imgWidthHeights[i].x, (int)imgWidthHeights[i].y, padding, minImageSizeX, minImageSizeY);
                num += (float)(image.w * image.h);
                num2 = Mathf.Max(num2, image.w);
                num3 = Mathf.Max(num3, image.h);
            }
            if ((float)num3 / (float)num2 > 2f)
            {
                if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                {
                    MB2_Log.LogDebug("Using height Comparer", new object[0]);
                }
                Array.Sort <MB2_TexturePacker.Image>(array, new MB2_TexturePacker.ImageHeightComparer());
            }
            else if ((double)((float)num3 / (float)num2) < 0.5)
            {
                if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                {
                    MB2_Log.LogDebug("Using width Comparer", new object[0]);
                }
                Array.Sort <MB2_TexturePacker.Image>(array, new MB2_TexturePacker.ImageWidthComparer());
            }
            else
            {
                if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                {
                    MB2_Log.LogDebug("Using area Comparer", new object[0]);
                }
                Array.Sort <MB2_TexturePacker.Image>(array, new MB2_TexturePacker.ImageAreaComparer());
            }
            int num4 = (int)Mathf.Sqrt(num);
            int num6;
            int num5;

            if (this.doPowerOfTwoTextures)
            {
                num5 = (num6 = this.RoundToNearestPositivePowerOfTwo(num4));
                if (num2 > num6)
                {
                    num6 = this.CeilToNearestPowerOfTwo(num6);
                }
                if (num3 > num5)
                {
                    num5 = this.CeilToNearestPowerOfTwo(num5);
                }
            }
            else
            {
                num6 = num4;
                num5 = num4;
                if (num2 > num4)
                {
                    num6 = num2;
                    num5 = Mathf.Max(Mathf.CeilToInt(num / (float)num2), num3);
                }
                if (num3 > num4)
                {
                    num6 = Mathf.Max(Mathf.CeilToInt(num / (float)num3), num2);
                    num5 = num3;
                }
            }
            if (num6 == 0)
            {
                num6 = 1;
            }
            if (num5 == 0)
            {
                num5 = 1;
            }
            int num7 = (int)((float)num6 * 0.15f);
            int num8 = (int)((float)num5 * 0.15f);

            if (num7 == 0)
            {
                num7 = 1;
            }
            if (num8 == 0)
            {
                num8 = 1;
            }
            int num9  = 2;
            int num10 = num5;

            while (num9 >= 1 && num10 < num4 * 1000)
            {
                bool flag = false;
                num9 = 0;
                int num11 = num6;
                while (!flag && num11 < num4 * 1000)
                {
                    MB2_TexturePacker.ProbeResult probeResult = new MB2_TexturePacker.ProbeResult();
                    if (this.LOG_LEVEL >= MB2_LogLevel.trace)
                    {
                        Debug.Log(string.Concat(new object[]
                        {
                            "Probing h=",
                            num10,
                            " w=",
                            num11
                        }));
                    }
                    if (this.Probe(array, num11, num10, num, maxDimension, probeResult))
                    {
                        flag = true;
                        if (this.bestRoot == null)
                        {
                            this.bestRoot = probeResult;
                        }
                        else if (probeResult.GetScore(this.doPowerOfTwoTextures) > this.bestRoot.GetScore(this.doPowerOfTwoTextures))
                        {
                            this.bestRoot = probeResult;
                        }
                    }
                    else
                    {
                        num9++;
                        num11 = this.StepWidthHeight(num11, num7, maxDimension);
                        if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                        {
                            MB2_Log.LogDebug(string.Concat(new object[]
                            {
                                "increasing Width h=",
                                num10,
                                " w=",
                                num11
                            }), new object[0]);
                        }
                    }
                }
                num10 = this.StepWidthHeight(num10, num8, maxDimension);
                if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                {
                    MB2_Log.LogDebug(string.Concat(new object[]
                    {
                        "increasing Height h=",
                        num10,
                        " w=",
                        num11
                    }), new object[0]);
                }
            }
            outW = 0;
            outH = 0;
            if (this.doPowerOfTwoTextures)
            {
                outW = Mathf.Min(this.CeilToNearestPowerOfTwo(this.bestRoot.w), maxDimension);
                outH = Mathf.Min(this.CeilToNearestPowerOfTwo(this.bestRoot.h), maxDimension);
                if (outH < outW / 2)
                {
                    outH = outW / 2;
                }
                if (outW < outH / 2)
                {
                    outW = outH / 2;
                }
            }
            else
            {
                outW = this.bestRoot.w;
                outH = this.bestRoot.h;
            }
            if (this.bestRoot == null)
            {
                return(null);
            }
            if (this.LOG_LEVEL >= MB2_LogLevel.debug)
            {
                MB2_Log.LogDebug(string.Concat(new object[]
                {
                    "Best fit found: atlasW=",
                    outW,
                    " atlasH",
                    outH,
                    " w=",
                    this.bestRoot.w,
                    " h=",
                    this.bestRoot.h,
                    " efficiency=",
                    this.bestRoot.efficiency,
                    " squareness=",
                    this.bestRoot.squareness,
                    " fits in max dimension=",
                    this.bestRoot.fitsInMaxSize
                }), new object[0]);
            }
            List <MB2_TexturePacker.Image> list = new List <MB2_TexturePacker.Image>();

            MB2_TexturePacker.flattenTree(this.bestRoot.root, list);
            list.Sort(new MB2_TexturePacker.ImgIDComparer());
            if (list.Count != array.Length)
            {
                Debug.LogError("Result images not the same lentgh as source");
            }
            int   minImageSizeX2 = minImageSizeX;
            int   minImageSizeY2 = minImageSizeY;
            bool  flag2          = false;
            float num12          = (float)padding / (float)outW;

            if (this.bestRoot.w > maxDimension)
            {
                num12 = (float)padding / (float)maxDimension;
                float num13 = (float)maxDimension / (float)this.bestRoot.w;
                if (this.LOG_LEVEL >= MB2_LogLevel.warn)
                {
                    Debug.LogWarning("Packing exceeded atlas width shrinking to " + num13);
                }
                for (int j = 0; j < list.Count; j++)
                {
                    MB2_TexturePacker.Image image2 = list[j];
                    if ((float)image2.w * num13 < (float)masterImageSizeX)
                    {
                        if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                        {
                            Debug.Log("Small images are being scaled to zero. Will need to redo packing with larger minTexSizeX.");
                        }
                        flag2          = true;
                        minImageSizeX2 = Mathf.CeilToInt((float)minImageSizeX / num13);
                    }
                    int num14 = (int)((float)(image2.x + image2.w) * num13);
                    image2.x = (int)(num13 * (float)image2.x);
                    image2.w = num14 - image2.x;
                }
                outW = maxDimension;
            }
            float num15 = (float)padding / (float)outH;

            if (this.bestRoot.h > maxDimension)
            {
                num15 = (float)padding / (float)maxDimension;
                float num16 = (float)maxDimension / (float)this.bestRoot.h;
                if (this.LOG_LEVEL >= MB2_LogLevel.warn)
                {
                    Debug.LogWarning("Packing exceeded atlas height shrinking to " + num16);
                }
                for (int k = 0; k < list.Count; k++)
                {
                    MB2_TexturePacker.Image image3 = list[k];
                    if ((float)image3.h * num16 < (float)masterImageSizeY)
                    {
                        if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                        {
                            Debug.Log("Small images are being scaled to zero. Will need to redo packing with larger minTexSizeY.");
                        }
                        flag2          = true;
                        minImageSizeY2 = Mathf.CeilToInt((float)minImageSizeY / num16);
                    }
                    int num17 = (int)((float)(image3.y + image3.h) * num16);
                    image3.y = (int)(num16 * (float)image3.y);
                    image3.h = num17 - image3.y;
                }
                outH = maxDimension;
            }
            Rect[] array2;
            if (!flag2)
            {
                array2 = new Rect[list.Count];
                for (int l = 0; l < list.Count; l++)
                {
                    MB2_TexturePacker.Image image4 = list[l];
                    Rect rect = array2[l] = new Rect((float)image4.x / (float)outW + num12, (float)image4.y / (float)outH + num15, (float)image4.w / (float)outW - num12 * 2f, (float)image4.h / (float)outH - num15 * 2f);
                    if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                    {
                        MB2_Log.LogDebug(string.Concat(new object[]
                        {
                            "Image: ",
                            l,
                            " imgID=",
                            image4.imgId,
                            " x=",
                            rect.x * (float)outW,
                            " y=",
                            rect.y * (float)outH,
                            " w=",
                            rect.width * (float)outW,
                            " h=",
                            rect.height * (float)outH,
                            " padding=",
                            padding
                        }), new object[0]);
                    }
                }
            }
            else
            {
                if (this.LOG_LEVEL >= MB2_LogLevel.debug)
                {
                    Debug.Log("==================== REDOING PACKING ================");
                }
                this.bestRoot = null;
                array2        = this._GetRects(imgWidthHeights, maxDimension, padding, minImageSizeX2, minImageSizeY2, masterImageSizeX, masterImageSizeY, out outW, out outH, recursionDepth + 1);
            }
            if (this.LOG_LEVEL >= MB2_LogLevel.debug)
            {
                MB2_Log.LogDebug("Done GetRects", new object[0]);
            }
            return(array2);
        }