{"id":2456,"date":"2011-09-25T02:17:22","date_gmt":"2011-09-25T00:17:22","guid":{"rendered":"https:\/\/iguanademos.com\/Jare\/wp\/?page_id=2456"},"modified":"2011-09-25T02:30:15","modified_gmt":"2011-09-25T00:30:15","slug":"rectangle-packing-code","status":"publish","type":"page","link":"https:\/\/iguanademos.com\/Jare\/wp\/?page_id=2456","title":{"rendered":"Rectangle Packing Code"},"content":{"rendered":"

(Note: this article first appeared as a Tip Of The Day<\/A> in Flipcode<\/A>. The C++ to HTML formating comes from Kurt’s internal tools)<\/p>\n

You have a bunch of rectangular pieces. You need to arrange them in a rectangular surface so that they don’t overlap, keeping the total area of the rectangle as small as possible. This is fairly common when arranging characters in a bitmapped font, lightmaps for a 3D engine, and I guess other situations as well.<\/p>\n

The idea of this algorithm is that, as we add rectangles, we can pre-select “interesting” places where we can try to add the next rectangles. For optimal results, the rectangles should be added in order. I initially tried using area as a sorting criteria, but it didn’t work well with very tall or very flat rectangles. I then tried using the longest dimension as a selector, and it worked much better. So much for intuition…<\/p>\n

These “interesting” places are just to the right and just below the currently added rectangle. The first rectangle, obviously, goes at the top left, the next one would go either to the right or below this one, and so on. It is a weird way to do it, but it seems to work very nicely.<\/p>\n

The way we search here is fairly brute-force, the fact being that for most off-line purposes the performance seems more than adequate. I have generated a japanese font with around 8500 characters and all the time was spent generating the bitmaps.<\/p>\n

Also, for all we care, we could grow the parent rectangle in a different way than power of two. It just happens that power of 2 is very convenient for graphics hardware textures.<\/p>\n

I’d be interested in hearing of other approaches to this problem. Make sure to post them on http:\/\/www.flipcode.com<\/A>.<\/p>\n

File: RectPlacement.h
\n
<\/p>\n
\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : RectPlacement.h<\/FONT>\r\n\/\/ Description : A class that allocates subrectangles into power-of-2 rectangles<\/FONT>\r\n\/\/               (C) Copyright 2000-2002 by Javier Arevalo<\/FONT>\r\n\/\/               This code is free to use and modify for all purposes<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\r\n#ifndef<\/FONT> _RECT_PLACEMENT_H_\r\n#define<\/FONT> _RECT_PLACEMENT_H_\r\n\r\n\r\n#include<\/FONT> <vector>\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\r\nclass<\/FONT> CRectPlacement\r\n{\r\n  public<\/FONT>:\r\n\r\n    \/\/ Helper classes<\/FONT>\r\n    struct<\/FONT> TPos\r\n    {\r\n      int<\/FONT> x, y;\r\n\r\n      TPos() { }\r\n      TPos(int<\/FONT> _x, int<\/FONT> _y): x(_x), y(_y) { }\r\n\r\n      bool<\/FONT> operator<\/FONT> ==(const<\/FONT> TPos &p) const<\/FONT> { return<\/FONT> x == p.x && y == p.y; }\r\n    };\r\n\r\n    struct<\/FONT> TRect: public<\/FONT> TPos\r\n    {\r\n      int<\/FONT> w, h;\r\n\r\n      TRect() { }\r\n      TRect(int<\/FONT> _x, int<\/FONT> _y, int<\/FONT> _w, int<\/FONT> _h): TPos(_x, _y), w(_w > 0? _w : 0), h(_h > 0? _h : 0) { }\r\n\r\n      bool<\/FONT> Contains   (const<\/FONT> TPos &p)  const<\/FONT> { return<\/FONT> (p.x >= x && p.y >= y &&\r\n                                                       p.x < (x+w) && p.y < (y+h)); }\r\n      bool<\/FONT> Contains   (const<\/FONT> TRect &r) const<\/FONT> { return<\/FONT> (r.x >= x && r.y >= y &&\r\n                                                       (r.x+r.w) <= (x+w) && (r.y+r.h) <= (y+h)); }\r\n      bool<\/FONT> Intersects (const<\/FONT> TRect &r) const<\/FONT> { return<\/FONT> w > 0 && h > 0 && r.w > 0 && r.h > 0 &&\r\n                                                      ((r.x+r.w) > x && r.x < (x+w) &&\r\n                                                       (r.y+r.h) > y && r.y < (y+h)); }\r\n\r\n    \/\/  Greater rect area. Not as good as the next heuristic<\/FONT>\r\n    \/\/  static bool Greater(const TRect &a, const TRect &b) { return a.w*a.h > b.w*b.h; }<\/FONT>\r\n\r\n      \/\/ Greater size in at least one dim.<\/FONT>\r\n      static<\/FONT> bool<\/FONT> Greater(const<\/FONT> TRect &a, const<\/FONT> TRect &b) { return<\/FONT> (a.w > b.w && a.w > b.h) ||\r\n                                                                   (a.h > b.w && a.h > b.h); }\r\n    };\r\n\r\n    \/\/ ---------------------<\/FONT>\r\n\r\n    typedef<\/FONT> std::vector<TPos>  CPosArray;\r\n    typedef<\/FONT> std::vector<TRect> CRectArray;\r\n\r\n    \/\/ ---------------------<\/FONT>\r\n\r\n    CRectPlacement()                    { Init(); }\r\n    ~CRectPlacement()                   { End(); }\r\n\r\n    void<\/FONT>      Init    (int<\/FONT> w = 1, int<\/FONT> h = 1);\r\n    void<\/FONT>      End     ();\r\n    bool<\/FONT>      IsOk    ()                      const<\/FONT> { return<\/FONT> m_size.w > 0; }\r\n\r\n    int<\/FONT>       GetW    ()                      const<\/FONT> { return<\/FONT> m_size.w; }\r\n    int<\/FONT>       GetH    ()                      const<\/FONT> { return<\/FONT> m_size.h; }\r\n    long<\/FONT>      GetArea ()                      const<\/FONT> { return<\/FONT> m_area; }\r\n    long<\/FONT>      GetTotalArea ()                 const<\/FONT> { return<\/FONT> m_size.w*m_size.h; }\r\n\r\n    bool<\/FONT> AddAtEmptySpotAutoGrow (TRect *pRect, int<\/FONT> maxW, int<\/FONT> maxH);\r\n\r\n  private<\/FONT>:\r\n    TRect       m_size;\r\n    CRectArray  m_vRects;\r\n    CPosArray   m_vPositions;\r\n    long<\/FONT>        m_area;\r\n\r\n    \/\/ ---------------------<\/FONT>\r\n\r\n    bool<\/FONT> IsFree                 (const<\/FONT> TRect &r) const<\/FONT>;\r\n    void<\/FONT> AddPosition            (const<\/FONT> TPos &p);\r\n    void<\/FONT> AddRect                (const<\/FONT> TRect &r);\r\n    bool<\/FONT> AddAtEmptySpot         (TRect &r);\r\n};\r\n\r\n\r\n#endif<\/FONT> \/\/_RECT_PLACEMENT_H_<\/FONT>\r\n <\/FONT><\/pre>\n
<\/TD><\/TR><\/TBODY><\/TABLE><\/p>\n
File: RectPlacement.cpp
\n
<\/p>\n
\/\/ ----------------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : RectPlacement.cpp<\/FONT>\r\n\/\/ Description : A class that fits subrectangles into a power-of-2 rectangle<\/FONT>\r\n\/\/               (C) Copyright 2000-2002 by Javier Arevalo<\/FONT>\r\n\/\/               This code is free to use and modify for all purposes<\/FONT>\r\n\/\/ ----------------------------------------------------------------------------------------<\/FONT>\r\n\r\n\/*\r\n  You have a bunch of rectangular pieces. You need to arrange them in a \r\n  rectangular surface so that they don't overlap, keeping the total area of the \r\n  rectangle as small as possible. This is fairly common when arranging characters \r\n  in a bitmapped font, lightmaps for a 3D engine, and I guess other situations as \r\n  well.\r\n\r\n  The idea of this algorithm is that, as we add rectangles, we can pre-select \r\n  \"interesting\" places where we can try to add the next rectangles. For optimal \r\n  results, the rectangles should be added in order. I initially tried using area \r\n  as a sorting criteria, but it didn't work well with very tall or very flat \r\n  rectangles. I then tried using the longest dimension as a selector, and it \r\n  worked much better. So much for intuition...\r\n\r\n  These \"interesting\" places are just to the right and just below the currently \r\n  added rectangle. The first rectangle, obviously, goes at the top left, the next \r\n  one would go either to the right or below this one, and so on. It is a weird way \r\n  to do it, but it seems to work very nicely.\r\n\r\n  The way we search here is fairly brute-force, the fact being that for most off-\r\n  line purposes the performance seems more than adequate. I have generated a \r\n  japanese font with around 8500 characters and all the time was spent generating \r\n  the bitmaps.\r\n\r\n  Also, for all we care, we could grow the parent rectangle in a different way \r\n  than power of two. It just happens that power of 2 is very convenient for \r\n  graphics hardware textures.\r\n\r\n  I'd be interested in hearing of other approaches to this problem. Make sure\r\n  to post them on http:\/\/www.flipcode.com\r\n*\/<\/FONT>\r\n\r\n#include<\/FONT> \"RectPlacement.h\"\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : <\/FONT>\r\n\/\/ Description : <\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nvoid<\/FONT> CRectPlacement::Init    (int<\/FONT> w, int<\/FONT> h)\r\n{\r\n  End();\r\n  m_size = TRect(0, 0, w, h);\r\n  m_vPositions.push_back(TPos(0,0));\r\n  m_area = 0;\r\n}\r\n\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : <\/FONT>\r\n\/\/ Description : <\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nvoid<\/FONT> CRectPlacement::End     ()\r\n{\r\n  m_vPositions.clear();\r\n  m_vRects.clear();\r\n  m_size.w = 0;\r\n}\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : IsFree<\/FONT>\r\n\/\/ Description : Check if the given rectangle is partially or totally used<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nbool<\/FONT> CRectPlacement::IsFree (const<\/FONT> TRect &r) const<\/FONT>\r\n{\r\n  if<\/FONT> (!m_size.Contains(r))\r\n    return<\/FONT> false<\/FONT>;\r\n  for<\/FONT> (CRectArray::const_iterator it = m_vRects.begin();\r\n       it != m_vRects.end();\r\n       ++it)\r\n    if<\/FONT> (it->Intersects(r))\r\n      return<\/FONT> false<\/FONT>;\r\n  return<\/FONT> true<\/FONT>;\r\n}\r\n\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : AddPosition<\/FONT>\r\n\/\/ Description : Add new anchor point<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nvoid<\/FONT> CRectPlacement::AddPosition    (const<\/FONT> TPos &p)\r\n{\r\n  \/\/ Try to insert anchor as close as possible to the top left corner<\/FONT>\r\n  \/\/ So it will be tried first<\/FONT>\r\n  bool<\/FONT> bFound = false<\/FONT>;\r\n  CPosArray::iterator it;\r\n  for<\/FONT> (it = m_vPositions.begin();\r\n       !bFound && it != m_vPositions.end();\r\n       ++it)\r\n  {\r\n    if<\/FONT> (p.x+p.y < it->x+it->y)\r\n      bFound = true<\/FONT>;\r\n  }\r\n  if<\/FONT> (bFound)\r\n    m_vPositions.insert(it, p);\r\n  else<\/FONT>\r\n\r\n    m_vPositions.push_back(p);\r\n}\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : AddRect<\/FONT>\r\n\/\/ Description : Add the given rect and updates anchor points<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nvoid<\/FONT> CRectPlacement::AddRect  (const<\/FONT> TRect &r)\r\n{\r\n  m_vRects.push_back(r);\r\n  m_area += r.w*r.h;\r\n\r\n  \/\/ Add two new anchor points<\/FONT>\r\n  AddPosition(TPos(r.x, r.y+r.h));\r\n  AddPosition(TPos(r.x+r.w, r.y));\r\n}\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : AddAtEmptySpot<\/FONT>\r\n\/\/ Description : Add the given rectangle<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nbool<\/FONT> CRectPlacement::AddAtEmptySpot   (TRect &r)\r\n{\r\n  \/\/ Find a valid spot among available anchors.<\/FONT>\r\n\r\n  bool<\/FONT> bFound = false<\/FONT>;\r\n  CPosArray::iterator it;\r\n  for<\/FONT> (it = m_vPositions.begin();\r\n       !bFound && it != m_vPositions.end();\r\n       ++it)\r\n  {\r\n    TRect Rect(it->x, it->y, r.w, r.h);\r\n\r\n    if<\/FONT> (IsFree(Rect))\r\n    {\r\n      r = Rect;\r\n      bFound = true<\/FONT>;\r\n      break<\/FONT>; \/\/ Don't let the loop increase the iterator.<\/FONT>\r\n    }\r\n  }\r\n  if<\/FONT> (bFound)\r\n  {\r\n    \/\/ Remove the used anchor point<\/FONT>\r\n    m_vPositions.erase(it);\r\n\r\n    \/\/ Sometimes, anchors end up displaced from the optimal position<\/FONT>\r\n    \/\/ due to irregular sizes of the subrects.<\/FONT>\r\n    \/\/ So, try to adjut it up & left as much as possible.<\/FONT>\r\n    for<\/FONT> (int<\/FONT> x = 1; x <= r.x; x++)\r\n      if<\/FONT> (!IsFree(TRect(r.x - x, r.y, r.w, r.h)))\r\n        break<\/FONT>;\r\n    for<\/FONT> (int<\/FONT> y = 1; y <= r.y; y++)\r\n      if<\/FONT> (!IsFree(TRect(r.x, r.y - y, r.w, r.h)))\r\n        break<\/FONT>;\r\n    if<\/FONT> (y > x)\r\n      r.y -= y-1;\r\n    else<\/FONT>\r\n\r\n      r.x -= x-1;\r\n    AddRect(r);\r\n  }\r\n  return<\/FONT> bFound;\r\n}\r\n\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : AddAtEmptySpotAutoGrow<\/FONT>\r\n\/\/ Description : Add a rectangle of the given size, growing our area if needed<\/FONT>\r\n\/\/               Area grows only until the max given.<\/FONT>\r\n\/\/               Returns the placement of the rect in the rect's x,y coords<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\r\nbool<\/FONT> CRectPlacement::AddAtEmptySpotAutoGrow   (TRect *pRect, int<\/FONT> maxW, int<\/FONT> maxH)\r\n{\r\n  if<\/FONT> (pRect->w <= 0)\r\n    return<\/FONT> true<\/FONT>;\r\n\r\n  int<\/FONT> orgW = m_size.w;\r\n  int<\/FONT> orgH = m_size.h;\r\n\r\n  \/\/ Try to add it in the existing space<\/FONT>\r\n  while<\/FONT> (!AddAtEmptySpot(*pRect))\r\n  {\r\n    int<\/FONT> pw = m_size.w;\r\n    int<\/FONT> ph = m_size.h;\r\n\r\n    \/\/ Sanity check - if area is complete.<\/FONT>\r\n    if<\/FONT> (pw >= maxW && ph >= maxH)\r\n    {\r\n      m_size.w = orgW;\r\n      m_size.h = orgH;\r\n      return<\/FONT> false<\/FONT>;\r\n    }\r\n\r\n    \/\/ Try growing the smallest dim<\/FONT>\r\n    if<\/FONT> (pw < maxW && (pw < ph || ((pw == ph) && (pRect->w >= pRect->h))))\r\n      m_size.w = pw*2;\r\n    else<\/FONT>\r\n      m_size.h = ph*2;\r\n    if<\/FONT> (AddAtEmptySpot(*pRect))\r\n      break<\/FONT>;\r\n\r\n    \/\/ Try growing the other dim instead<\/FONT>\r\n    if<\/FONT> (pw != m_size.w)\r\n    {\r\n      m_size.w = pw;\r\n      if<\/FONT> (ph < maxW)\r\n        m_size.h = ph*2;\r\n    }\r\n    else<\/FONT>\r\n    {\r\n      m_size.h = ph;\r\n      if<\/FONT> (pw < maxW)\r\n        m_size.w = pw*2;\r\n    }\r\n\r\n    if<\/FONT> (pw != m_size.w || ph != m_size.h)\r\n      if<\/FONT> (AddAtEmptySpot(*pRect))\r\n        break<\/FONT>;\r\n\r\n    \/\/ Grow both if possible, and reloop.<\/FONT>\r\n    m_size.w = pw;\r\n    m_size.h = ph;\r\n    if<\/FONT> (pw < maxW)\r\n      m_size.w = pw*2;\r\n    if<\/FONT> (ph < maxH)\r\n      m_size.h = ph*2;\r\n  }\r\n  return<\/FONT> true<\/FONT>;\r\n}\r\n <\/FONT><\/pre>\n
<\/TD><\/TR><\/TBODY><\/TABLE>
\nFile: Test.cpp
\n
<\/p>\n
\/\/ ----------------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : Test.cpp<\/FONT>\r\n\/\/ Description : Test the RectPlacement class<\/FONT>\r\n\/\/               (C) Copyright 2000-2002 by Javier Arevalo<\/FONT>\r\n\/\/               This code is free to use and modify for all purposes<\/FONT>\r\n\/\/ ----------------------------------------------------------------------------------------<\/FONT>\r\n\r\n#include<\/FONT> <stdio.h>\r\n#include<\/FONT> <algorithm>\r\n\r\n#include<\/FONT> \"RectPlacement.h\"\r\n\r\n#define<\/FONT> MAX_TEXTURE_W 256\r\n#define<\/FONT> MAX_TEXTURE_H 256\r\n\r\n#define<\/FONT> NUM_SUBRECTS  500\r\n#define<\/FONT> MIN_SUBRECT    15\r\n#define<\/FONT> MAX_SUBRECT    50\r\n\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\r\nstruct<\/FONT> TSubRect: public<\/FONT> CRectPlacement::TRect\r\n{\r\n  int<\/FONT> n;      \/\/ Original index of this subrect, before sorting<\/FONT>\r\n  int<\/FONT> nTex;   \/\/ Texture in which this subrect will be placed.<\/FONT>\r\n\r\n  TSubRect() { }\r\n  TSubRect(int<\/FONT> _w, int<\/FONT> _h, int<\/FONT> _n): TRect(0, 0, _w, _h), n(_n), nTex(0) { }\r\n};\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\r\ntypedef<\/FONT> std::vector<TSubRect>       CSubRectArray;\r\ntypedef<\/FONT> std::vector<CRectPlacement> CTextureArray;\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : CreateLetters<\/FONT>\r\n\/\/ Description : Here's where you calculate your rectangles,<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\r\nvoid<\/FONT> CreateLetters  (CSubRectArray &vecSubRects)\r\n{\r\n  vecSubRects.clear();\r\n\r\n  \/\/ Let's just fill this with random stuff<\/FONT>\r\n  for<\/FONT> (int<\/FONT> i = 0; i < NUM_SUBRECTS; i++)\r\n    vecSubRects.push_back(TSubRect((rand() % MAX_SUBRECT) + MIN_SUBRECT,\r\n                                   (rand() % MAX_SUBRECT) + MIN_SUBRECT, i));\r\n}\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : CreateTextures<\/FONT>\r\n\/\/ Description : Create array of textures containing all subrects<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nvoid<\/FONT> CreateTextures (CTextureArray &vecTextures, CSubRectArray &vecSubRects, int<\/FONT> maxTexW, int<\/FONT> maxTexH)\r\n{\r\n  \/\/ Sort the subRects based on dimensions, larger dimension goes first.<\/FONT>\r\n  std::sort(vecSubRects.begin(), vecSubRects.end(), CRectPlacement::TRect::Greater);\r\n\r\n  \/\/ Generate the first texture<\/FONT>\r\n  vecTextures.clear();\r\n  vecTextures.push_back(CRectPlacement());\r\n\r\n  \/\/ Add all subrects<\/FONT>\r\n  for<\/FONT> (CSubRectArray::iterator it = vecSubRects.begin();\r\n       it != vecSubRects.end();\r\n       ++it)\r\n  {\r\n    \/\/ We make sure we leave one pixel between subrects, so texels don't bleed with bilinear.<\/FONT>\r\n    CRectPlacement::TRect r(0, 0, it->w+1, it->h+1);\r\n\r\n    \/\/ If an existing texture has actual space<\/FONT>\r\n    bool<\/FONT> bPlaced = false<\/FONT>;\r\n    for<\/FONT> (int<\/FONT> i = 0; !bPlaced && i < vecTextures.size(); i++)\r\n    {\r\n      bPlaced = vecTextures[i].AddAtEmptySpotAutoGrow(&r, maxTexW, maxTexH);\r\n      if<\/FONT> (bPlaced)\r\n        it->nTex = i;\r\n    }\r\n\r\n    \/\/ Try starting a new texture and fit the rect in there<\/FONT>\r\n    if<\/FONT> (!bPlaced)\r\n    {\r\n      vecTextures.push_back(CRectPlacement());\r\n      bPlaced = vecTextures[vecTextures.size()-1].AddAtEmptySpotAutoGrow(&r, maxTexW, maxTexH);\r\n      if<\/FONT> (bPlaced)\r\n        it->nTex = vecTextures.size()-1;\r\n      else<\/FONT>\r\n        printf(\"ERROR: Subrect is too big to fit in texture!\", it->w, it->h);\r\n    }\r\n\r\n    \/\/ If correctly placed in a texture, the coords are returned in r.x and r.y<\/FONT>\r\n    \/\/ Store them.<\/FONT>\r\n    if<\/FONT> (bPlaced)\r\n    {\r\n      it->x = r.x;\r\n      it->y = r.y;\r\n    }\r\n  }\r\n}\r\n\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\n\/\/ Name        : main<\/FONT>\r\n\/\/ Description : heh<\/FONT>\r\n\/\/ --------------------------------------------------------------------------------<\/FONT>\r\nint<\/FONT> main()\r\n{\r\n  CTextureArray vecTextures;\r\n  CSubRectArray vecSubRects;\r\n\r\n  CreateLetters(vecSubRects);\r\n  CreateTextures(vecTextures, vecSubRects, MAX_TEXTURE_W, MAX_TEXTURE_H);\r\n\r\n  {\r\n    for<\/FONT> (CSubRectArray::const_iterator it = vecSubRects.begin();\r\n         it != vecSubRects.end();\r\n         ++it)\r\n    {\r\n      printf(\"Subrect %d (originally %d), size %dx%d, goes into texture %d at pos %d,%d\\n\",\r\n             it - vecSubRects.begin(), it->n, it->w, it->h, it->nTex, it->x, it->y);\r\n    }\r\n  }\r\n\r\n  printf(\"Created a total of %d textures\\n\", vecTextures.size());\r\n  {\r\n    for<\/FONT> (CTextureArray::const_iterator it = vecTextures.begin();\r\n         it != vecTextures.end();\r\n         ++it)\r\n    {\r\n      printf(\"  Texture %d, size %dx%d, Coverage %d \/ %d (%d%%)\\n\",\r\n             it - vecTextures.begin(), it->GetW(), it->GetH(),\r\n             it->GetArea(), it->GetTotalArea(), it->GetArea()*100\/it->GetTotalArea());\r\n    }\r\n  }\r\n  return<\/FONT> 0;\r\n}\r\n<\/FONT><\/pre>\n
<\/TD><\/TR><\/TBODY><\/TABLE><\/p>\n","protected":false},"excerpt":{"rendered":"
(Note: this article first appeared as a Tip Of The Day in Flipcode. The C++ to HTML formating comes from Kurt’s internal tools) You have a bunch of rectangular pieces. You need to arrange them in a rectangular surface so … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"parent":2432,"menu_order":0,"comment_status":"open","ping_status":"open","template":"","meta":{"footnotes":""},"class_list":["post-2456","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/pages\/2456","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2456"}],"version-history":[{"count":7,"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/pages\/2456\/revisions"}],"predecessor-version":[{"id":2461,"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/pages\/2456\/revisions\/2461"}],"up":[{"embeddable":true,"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=\/wp\/v2\/pages\/2432"}],"wp:attachment":[{"href":"https:\/\/iguanademos.com\/Jare\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2456"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}