various fixes

added fix for font cache (stb required size to be read switch back to libpng knocks the stream off)

Added extra control over the rendering of guibtimaps
If guibitmaps are a child of buttons the profile colors now affect how to the button is rendered.

Engine/source/gfx/gFont.cpp

@@ -705,10 +705,8 @@ bool GFont::read(Stream& io_rStream)
            delete bmp;
            return false;
        }*/
-       U32 len;
-       io_rStream.read(&len);
 
-       if (!bmp->readBitmapStream("png", io_rStream, len))
+       if (!bmp->readBitmapStream("png", io_rStream, U32_MAX))
        {
           delete bmp;
           return false;

Engine/source/gui/buttons/guiButtonBaseCtrl.cpp

@@ -303,7 +303,10 @@ void GuiButtonBaseCtrl::onMouseEnter(const GuiEvent& event)
          SFX->playOnce(mProfile->getSoundButtonOverProfile());
 
       mHighlighted = true;
-      messageSiblings(mRadioGroup);
+
+      if (mButtonType != ButtonTypeRadio)
+         messageSiblings(mRadioGroup);
+
       onHighlighted_callback(mHighlighted);
    }
 }
@@ -320,7 +323,9 @@ void GuiButtonBaseCtrl::onMouseLeave(const GuiEvent&)
       mDepressed = false;
    mHighlighted = false;
    onHighlighted_callback(mHighlighted);
-   messageSiblings(mRadioGroup);
+
+   if (mButtonType != ButtonTypeRadio)
+      messageSiblings(mRadioGroup);
 }
 
 //-----------------------------------------------------------------------------

Engine/source/gui/buttons/guiButtonBaseCtrl.h

@@ -96,6 +96,7 @@ public:
    bool getStateOn() const { return mStateOn; }
 
    void setDepressed(bool depressed) { mDepressed = depressed; }
+   bool isDepressed() { return mDepressed; }
    void resetState() { mDepressed = false; mHighlighted = false; }
 
    void setHighlighted(bool highlighted);

Engine/source/gui/controls/guiBitmapCtrl.cpp

@@ -28,6 +28,8 @@
 #include "console/engineAPI.h"
 #include "gfx/gfxDevice.h"
 #include "gfx/gfxDrawUtil.h"
+#include "gfx/gfxAPI.h"
+#include "gui/buttons/guiButtonBaseCtrl.h"
 
 #include "materials/matTextureTarget.h"
 
@@ -55,11 +57,26 @@ ConsoleDocClass(GuiBitmapCtrl,
    "@ingroup GuiControls"
 );
 
+ImplementEnumType(BitmapDrawMode,
+   "Draw Mode of the bitmap control.\n\n"
+   "@ingroup GuiControls")
+{
+   GuiBitmapCtrl::BitmapMode_Stretch, "Stretch", "Stretches the bitmap to fill the control extents. Aspect ratio is not preserved."
+},
+{ GuiBitmapCtrl::BitmapMode_Tile,   "Tile",     "Repeats the bitmap to fill the control extents without scaling." },
+{ GuiBitmapCtrl::BitmapMode_Fit,    "Fit",      "Scales the bitmap to fit entirely within the control while preserving aspect ratio. May result in letterboxing." },
+{ GuiBitmapCtrl::BitmapMode_Fill,   "Fill",     "Scales the bitmap to completely fill the control while preserving aspect ratio. Portions of the bitmap may be cropped." },
+{ GuiBitmapCtrl::BitmapMode_Center, "Center",   "Draws the bitmap at its original size centered within the control. No scaling is applied." },
+
+EndImplementEnumType;
+
 GuiBitmapCtrl::GuiBitmapCtrl(void)
    : mStartPoint(0, 0),
    mColor(ColorI::WHITE),
    mAngle(0),
    mWrap(false),
+   mDrawMode(BitmapMode_Stretch),
+   mFilterType(GFXTextureFilterLinear),
    mBitmap(NULL),
    mBitmapName(StringTable->EmptyString())
 {
@@ -72,10 +89,12 @@ void GuiBitmapCtrl::initPersistFields()
 
    INITPERSISTFIELD_IMAGEASSET(Bitmap, GuiBitmapCtrl, "The bitmap to render in this BitmapCtrl.")
 
-   addField("color", TypeColorI, Offset(mColor, GuiBitmapCtrl), "color mul");
+      addField("color", TypeColorI, Offset(mColor, GuiBitmapCtrl), "color mul");
    addField("wrap", TypeBool, Offset(mWrap, GuiBitmapCtrl), "If true, the bitmap is tiled inside the control rather than stretched to fit.");
+   addField("drawMode", TYPEID<BitmapMode>(), Offset(mDrawMode, GuiBitmapCtrl), "Sets the mode to draw this bitmap in this control (wrap forces Tile mode).");
+   addField("filterType", TYPEID<GFXTextureFilterType>(), Offset(mFilterType, GuiBitmapCtrl), "Sets the bitmap texture filter mode.");
    addFieldV("angle", TypeRangedF32, Offset(mAngle, GuiBitmapCtrl), &CommonValidators::DegreeRange, "rotation");
-   endGroup( "Bitmap" );
+   endGroup("Bitmap");
 
    Parent::initPersistFields();
 }
@@ -91,6 +110,7 @@ bool GuiBitmapCtrl::onWake()
 
 void GuiBitmapCtrl::onSleep()
 {
+   mBitmap = NULL;
    Parent::onSleep();
 }
 
@@ -171,36 +191,108 @@ void GuiBitmapCtrl::onRender(Point2I offset, const RectI& updateRect)
    {
       GFX->getDrawUtil()->clearBitmapModulation();
       GFX->getDrawUtil()->setBitmapModulation(mColor);
-      if (mWrap)
-      {
-         // We manually draw each repeat because non power of two textures will 
-         // not tile correctly when rendered with GFX->drawBitmapTile(). The non POT
-         // bitmap will be padded by the hardware, and we'll see lots of slack
-         // in the texture. So... lets do what we must: draw each repeat by itself:
-         GFXTextureObject* texture = mBitmap;
-         RectI srcRegion;
-         RectI dstRegion;
-         F32 xdone = ((F32)getExtent().x / (F32)texture->mBitmapSize.x) + 1;
-         F32 ydone = ((F32)getExtent().y / (F32)texture->mBitmapSize.y) + 1;
 
-         S32 xshift = mStartPoint.x % texture->mBitmapSize.x;
-         S32 yshift = mStartPoint.y % texture->mBitmapSize.y;
-         for (S32 y = 0; y < ydone; ++y)
-            for (S32 x = 0; x < xdone; ++x)
-            {
-               srcRegion.set(0, 0, texture->mBitmapSize.x, texture->mBitmapSize.y);
-               dstRegion.set(((texture->mBitmapSize.x * x) + offset.x) - xshift,
-                  ((texture->mBitmapSize.y * y) + offset.y) - yshift,
-                  texture->mBitmapSize.x,
-                  texture->mBitmapSize.y);
-               GFX->getDrawUtil()->drawBitmapStretchSR(texture, dstRegion, srcRegion, GFXBitmapFlip_None, GFXTextureFilterLinear, mAngle);
-            }
+      if (dynamic_cast<GuiButtonBaseCtrl*>(getParent()))
+      {
+         GuiButtonBaseCtrl* parent = static_cast<GuiButtonBaseCtrl*>(getParent());
+
+         GFX->getDrawUtil()->setBitmapModulation(mProfile->mFillColor);
+
+         if (parent->isHighlighted())
+            GFX->getDrawUtil()->setBitmapModulation(mProfile->mFillColorHL);
+         if (parent->isDepressed() || parent->getStateOn())
+            GFX->getDrawUtil()->setBitmapModulation(mProfile->mFillColorSEL);
+         if (!parent->isActive())
+            GFX->getDrawUtil()->setBitmapModulation(mProfile->mFillColorNA);
 
       }
-      else
+
+      if (mWrap && mDrawMode != BitmapMode_Tile)
+         mDrawMode = BitmapMode_Tile;
+
+      RectI ctrlRect(offset, getExtent());
+      GFXTextureObject* texture = mBitmap;
+
+      F32 texW = (F32)texture->getWidth();
+      F32 texH = (F32)texture->getHeight();
+      F32 ctrlW = (F32)getExtent().x;
+      F32 ctrlH = (F32)getExtent().y;
+
+      switch (mDrawMode)
       {
-         RectI rect(offset, getExtent());
-         GFX->getDrawUtil()->drawBitmapStretch(mBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false, mAngle);
+      case BitmapMode_Tile:
+      {
+         // How many repetitions needed (+1 ensures full coverage)
+         const S32 xCount = (ctrlW / texW) + 1;
+         const S32 yCount = (ctrlH / texH) + 1;
+
+         // Scroll offset (wrap-safe)
+         const S32 xShift = mStartPoint.x % (S32)texW;
+         const S32 yShift = mStartPoint.y % (S32)texH;
+
+         RectI srcRegion(0, 0, (S32)texW, (S32)texH);
+         RectI dstRegion;
+
+         for (S32 y = 0; y < yCount; ++y)
+         {
+            for (S32 x = 0; x < xCount; ++x)
+            {
+               dstRegion.set(
+                  offset.x + (x * texW) - xShift,
+                  offset.y + (y * texH) - yShift,
+                  texW,
+                  texH
+               );
+
+               GFX->getDrawUtil()->drawBitmapStretchSR(texture, dstRegion, srcRegion, GFXBitmapFlip_None, mFilterType, true, mAngle);
+            }
+         }
+
+         break;
+      }
+      case GuiBitmapCtrl::BitmapMode_Fit:
+      {
+         F32 scale = getMin(ctrlW / texW, ctrlH / texH);
+
+         S32 drawW = (S32)(texW * scale);
+         S32 drawH = (S32)(texH * scale);
+
+         S32 x = offset.x + (ctrlW - drawW) * 0.5f;
+         S32 y = offset.y + (ctrlH - drawH) * 0.5f;
+
+         RectI dst(x, y, drawW, drawH);
+         GFX->getDrawUtil()->drawBitmapStretch(texture, dst, GFXBitmapFlip_None, mFilterType, false, mAngle);
+         break;
+      }
+      case GuiBitmapCtrl::BitmapMode_Fill:
+      {
+         F32 scale = getMax(ctrlW / texW, ctrlH / texH);
+
+         S32 drawW = (S32)(texW * scale);
+         S32 drawH = (S32)(texH * scale);
+
+         S32 x = offset.x + (ctrlW - drawW) * 0.5f;
+         S32 y = offset.y + (ctrlH - drawH) * 0.5f;
+
+         RectI dst(x, y, drawW, drawH);
+         GFX->getDrawUtil()->drawBitmapStretch(texture, dst, GFXBitmapFlip_None, mFilterType, false, mAngle);
+         break;
+      }
+      case GuiBitmapCtrl::BitmapMode_Center:
+      {
+         S32 x = offset.x + (ctrlW - texW) * 0.5f;
+         S32 y = offset.y + (ctrlH - texH) * 0.5f;
+
+         RectI dst(x, y, texW, texH);
+
+         GFX->getDrawUtil()->drawBitmapStretch(texture, dst, GFXBitmapFlip_None, mFilterType, false, mAngle);
+         break;
+      }
+      default:
+      {
+         GFX->getDrawUtil()->drawBitmapStretch(texture, ctrlRect, GFXBitmapFlip_None, mFilterType, false, mAngle);
+         break;
+      }
       }
    }
 

Engine/source/gui/controls/guiBitmapCtrl.h

@@ -35,6 +35,15 @@ public:
 
    typedef GuiControl Parent;
 
+   enum BitmapMode
+   {
+      BitmapMode_Stretch,
+      BitmapMode_Tile,
+      BitmapMode_Fit,
+      BitmapMode_Fill,
+      BitmapMode_Center
+   };
+
 protected:
 
    /// Name of the bitmap file.  If this is 'texhandle' the bitmap is not loaded
@@ -47,6 +56,8 @@ protected:
 
    /// If true, bitmap tiles inside control.  Otherwise stretches.
    bool mWrap;
+   BitmapMode mDrawMode;
+   GFXTextureFilterType mFilterType;
 
 public:
    GFXTexHandle mBitmap;
@@ -74,4 +85,7 @@ public:
       "The bitmap can either be tiled or stretched inside the control.");
 };
 
+typedef GuiBitmapCtrl::BitmapMode BitmapDrawMode;
+DefineEnumType(BitmapDrawMode);
+
 #endif