SO3BitmapWidget.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Renderer/SO3BitmapWidget.h"
#include "SO3Material/SO3Material.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include <OgreBitwise.h>
 
namespace SO3
{
SBitmapWidget::SBitmapWidget(SScene* targetScene, const std::string& bitmapWidgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport, const unsigned int& widgetZOrder) : SWidget(targetScene, bitmapWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, widgetZOrder, SO3_BITMAP_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
SBitmapWidget::SBitmapWidget(SScene* targetScene, const std::string& bitmapWidgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport) : SWidget(targetScene, bitmapWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, SO3_BITMAP_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
SBitmapWidget::SBitmapWidget(SScene* targetScene, const std::string& bitmapWidgetName, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SMaterial* targetMaterial, const unsigned short& targetTechnique, const unsigned short& targetPass, const unsigned short& targetTextureUnit) : SWidget(targetScene, bitmapWidgetName, widgetWidth, widgetHeight, targetMaterial, targetTechnique, targetPass, targetTextureUnit, SO3_BITMAP_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
void SBitmapWidget::CommonConstructorSequence()
{
  iLastWidth = 0;
  iLastHeight = 0;
  pixelsData = 0;
  bLastAlphaState = false;
}
 
SBitmapWidget::~SBitmapWidget()
{
  if (pixelsData)
    SAFE_FREE(pixelsData);
}
 
void SBitmapWidget::LoadURL(const std::string& url)
{
  // Throw exception, catch in scol bind, and return nil.
  SWidgetManager::getSingleton()._FireOnLoadError(this, 0, url);
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Cannot directly load an URL in a Bitmap widget, use \"UpdateRawData\" function!", "SBitmapWidget::LoadURL");
}
 
void SBitmapWidget::LoadFile(const std::string& file)
{
  // Throw exception, catch in scol bind, and return nil.
  SWidgetManager::getSingleton()._FireOnLoadError(this, 0, file);
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Cannot load a file directly in a Bitmap widget, use \"UpdateRawData\" function!", "SBitmapWidget::LoadFile");
}
 
void SBitmapWidget::UpdateRawData(unsigned char* buffer, int width, int height, int bitperpixel)
{
  // only on rgb or rgba
  if (bitperpixel < 3)
    return;
 
  // Test if the scolBitmap is valid
  if ((width > 0) && (height > 0))
  {
    CheckSizeAndAlloc(width, height, (bitperpixel == 4) ? true : false);
 
    if (!renderingTexture)
    {
      MMechostr(MSKDEBUG, ">>>> SBitmapWidget : Texture creation failed.");
      return;
    }
 
    // Lock the pixel buffer and get a pixel box
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
 
    SWidgetManager::getSingleton()._FireOnLoadStart(this);
 
    int align = width * bitperpixel;
    //if (align % 4 != 0)
    //  align += 4 - (align % 4);
    //bool aligned = (align == (bitperpixel * width)) ? true : false;
 
    if ((pixelBuffer->getWidth() == width) && ((pixelBuffer->getHeight() == height)))// && aligned)
    {
      memcpy(pixelsData, buffer, width * height * bitperpixel);
      
      // Create an Ogre pixel box with our scol bitmap data for easy streching.
      /*
      Ogre::PixelFormat format = Ogre::PF_A8R8G8B8;
      SRoot::getSingleton().GetRttPixelFormat(format, (bitperpixel == 4) ? true : false);
      const Ogre::PixelBox scolPixelBox(width, height, 1, format, pixelsData);
      */
      const Ogre::PixelBox scolPixelBox(width, height, 1, (bitperpixel == 4) ? Ogre::PF_BYTE_BGRA : Ogre::PF_BYTE_BGR, pixelsData);
      pixelBuffer->blitFromMemory(scolPixelBox);
    }
    else
    {
#ifdef APPLE_IOS
      const Ogre::PixelBox scolPixelBox(width, height, 1, (bitperpixel == 4) ? Ogre::PF_BYTE_BGRA : Ogre::PF_BYTE_BGR, buffer);
#else
      ConversionTools::ScolBitmapGetRGBA(buffer, width, height, bitperpixel, align, pixelBuffer->getWidth(), pixelBuffer->getHeight(), pixelBuffer->getFormat(), static_cast<Ogre::uint32*>(pixelsData));
 
      // Create an Ogre pixel box with our scol bitmap data for easy streching.
      const Ogre::PixelBox scolPixelBox(pixelBuffer->getWidth(), pixelBuffer->getHeight(), 1, pixelBuffer->getFormat(), pixelsData);
#endif
      pixelBuffer->blitFromMemory(scolPixelBox);
    }
    
    SWidgetManager::getSingleton()._FireOnLoadEnd(this);
  }
}
 
void SBitmapWidget::UpdateRawData(PtrObjBitmap scolBitmap)
{
  // Test if the scolBitmap is valid
  if((scolBitmap->TailleW > 0) && (scolBitmap->TailleH > 0))
  {
    CheckSizeAndAlloc(scolBitmap->TailleW, scolBitmap->TailleH, false);
 
    if (!renderingTexture)
    {
      MMechostr(MSKDEBUG, ">>>> SBitmapWidget : Texture creation failed.");
      return;
    }
 
    // Lock the pixel buffer and get a pixel box
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
 
    SWidgetManager::getSingleton()._FireOnLoadStart(this);
 
    // copy last bitmap state
    ConversionTools::ScolBitmapGetRGBA(scolBitmap, 0, pixelBuffer->getWidth(), pixelBuffer->getHeight(), pixelBuffer->getFormat(), static_cast<Ogre::uint32*>(pixelsData));
 
    // Create an Ogre pixel box with our scol bitmap data for easy streching.
    const Ogre::PixelBox scolPixelBox(pixelBuffer->getWidth(), pixelBuffer->getHeight(), 1, pixelBuffer->getFormat(), pixelsData);
    pixelBuffer->blitFromMemory(scolPixelBox);
 
    SWidgetManager::getSingleton()._FireOnLoadEnd(this);
  }
}
 
void SBitmapWidget::UpdateRawData(PtrObjBitmap scolBitmap, PtrObjBitmap scolAlphaBitmap)
{
  if (scolAlphaBitmap == 0)
  {
    UpdateRawData(scolBitmap);
    return;
  }
 
  // Test if the scolBitmap is valid
  if((scolBitmap->TailleW > 0) && (scolBitmap->TailleH > 0))
  {
    CheckSizeAndAlloc(scolBitmap->TailleW, scolBitmap->TailleH, true);
    
    if (!renderingTexture)
    {
      MMechostr(MSKDEBUG, ">>>> SBitmapWidget : Texture creation failed.");
      return;
    }
 
    // Lock the pixel buffer and get a pixel box
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
 
    SWidgetManager::getSingleton()._FireOnLoadStart(this);
 
    // copy last bitmap state
    ConversionTools::ScolBitmapGetRGBA(scolBitmap, scolAlphaBitmap, pixelBuffer->getWidth(), pixelBuffer->getHeight(), pixelBuffer->getFormat(), static_cast<Ogre::uint32*>(pixelsData));
    // Create an Ogre pixel box with our scol bitmap data for easy streching.
    const Ogre::PixelBox scolPixelBox(pixelBuffer->getWidth(), pixelBuffer->getHeight(), 1, pixelBuffer->getFormat(), pixelsData);
    pixelBuffer->blitFromMemory(scolPixelBox);
 
    SWidgetManager::getSingleton()._FireOnLoadEnd(this);
  }
}
 
void SBitmapWidget::InjectMouseMove(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectMouseWheel(const int& scrollX, const int& scrollY, const int& relativeScroll)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectMouseDown(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectMouseUp(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectTouchAdd(const int& xPos, const int& yPos, const int& touchid)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectTouchRemove(const int& touchid)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectTouchUpdate(const int& xPos, const int& yPos, const int& vx, const int& vy, const int& touchid)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectKeyEvent(const UINT& msg, const ScolWindowHandle& hwnd, const WPARAM& wParam, const LPARAM& lParam)
{
  // Nothing to do
}
 
void SBitmapWidget::InjectTextEvent(const std::string& utf8)
{
  // Nothing to do
}
 
void SBitmapWidget::SetFocusImpl(const bool& focusOnWidget)
{
  // Nothing to do
}
 
void SBitmapWidget::SetTransparencyImpl(const bool& enableTransparency)
{
  // Nothing to do
}
void SBitmapWidget::RunScriptFunction(const std::string& functionName, const std::vector<std::string>& argumentList)
{
  // Nothing to do, no script for bitmap!
}
 
void SBitmapWidget::SetKeyboardEnableImpl(const bool& enableKeyboardOnWidget)
{
  // Nothing to do
}
 
void SBitmapWidget::SetMouseEnableImpl(const bool& enableMouseOnWidget)
{
  // Nothing to do
}
 
void SBitmapWidget::SetSizeImpl(const unsigned short& newWidth, const unsigned short& newHeight)
{
  CheckSizeAndAlloc(newWidth, newHeight, bLastAlphaState);
}
 
bool SBitmapWidget::CheckPixelAlpha(const int& posX, const int& posY)
{
  bool result = false;
  if ((mTextureWidth > 0) && (mTextureHeight > 0) && (width > 0) && (height > 0))
  {
    int nxpos = static_cast<int>((float)posX / (float)width * (float)mTextureWidth);
    int nypos = static_cast<int>((float)posY / (float)height * (float)mTextureHeight);
    if((nxpos < mTextureWidth) && (nypos < mTextureHeight))
    {
      if(bLastAlphaState)
      {
        Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
        pixelBuffer->lock(Ogre::HardwareBuffer::HBL_READ_ONLY);
        Ogre::PixelBox pixelBox = pixelBuffer->getCurrentLock();
      
        Ogre::ColourValue tempColor = pixelBox.getColourAt(nxpos, nypos, 0);
        if (tempColor.a > transparentTresholdColor)
          result = true;
 
        pixelBuffer->unlock();
      }
      else
      {
        result = true;
      }
    }
  }
  return result;
}
 
void SBitmapWidget::CheckSizeAndAlloc(const unsigned int& newWidth, const unsigned int& newHeight, const bool& alpha)
{
  unsigned short nCalcTexWidth = 0;
  unsigned short nCalcTexHeight = 0;
  if (compensateNPOT)
  {
    nCalcTexWidth = Ogre::Bitwise::firstPO2From(static_cast <unsigned short>(newWidth * textureRatio));
    nCalcTexHeight = Ogre::Bitwise::firstPO2From(static_cast <unsigned short>(newHeight * textureRatio));
 
#if defined(ANDROID) || defined(APPLE_IOS)
    if (nCalcTexWidth > 512 || nCalcTexHeight > 512)
    {
      nCalcTexWidth = nCalcTexWidth / 2;
      nCalcTexHeight = nCalcTexHeight / 2;
    }
#endif
  }
  else
  {
    nCalcTexWidth = static_cast <unsigned short>(newWidth * textureRatio);
    nCalcTexHeight = static_cast <unsigned short>(newHeight * textureRatio);
  }
 
  if ((nCalcTexWidth != iLastWidth) || (nCalcTexHeight != iLastHeight) || (alpha != bLastAlphaState))
  {
    mTextureWidth = newWidth;
    mTextureHeight = newHeight;
 
    if (pixelsData)
      SAFE_FREE(pixelsData);
 
    CreateTexture(alpha);
 
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
 
    iLastWidth = pixelBuffer->getWidth();
    iLastHeight = pixelBuffer->getHeight();
    bLastAlphaState = alpha;
 
    //MMechostr(MSKDEBUG, ">>>> SBitmapWidget Bitmap size: %ix%i\n", newWidth, newHeight);
 
    int size = sizeof(Ogre::uint32*); // (alpha) ? 4 : 3;
    pixelsData = (void*)malloc(iLastWidth * iLastHeight * size);
  }
}
 
void SBitmapWidget::loadResource(Ogre::Resource* resource)
{
  /*Ogre::Texture* tex = static_cast<Ogre::Texture*>(resource);
  tex->setTextureType(Ogre::TEX_TYPE_2D);
  tex->setWidth(mTextureWidth);
  tex->setHeight(mTextureHeight);
  tex->setNumMipmaps(0);
  tex->setFormat(Ogre::PF_BYTE_BGRA);
  tex->setUsage(Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
  tex->createInternalResources();
  */
  if(pixelsData)
  {
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
 
    // Create an Ogre pixel box with our scol bitmap data for easy streching.
    const Ogre::PixelBox scolPixelBox(iLastWidth, iLastHeight, 1, pixelBuffer->getFormat(), pixelsData);
    pixelBuffer->blitFromMemory(scolPixelBox);
 
    /*
    pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
    const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
 
    // Streching scolBitmap data to Ogre texture size. Nb that the scale function takes an optional filter parameter if we wants other filtering than bilinear 
    try
    {
      Ogre::Image::scale(scolPixelBox, pixelBox);
    }
    catch(Ogre::Exception &e)
    {
      MMechostr(MSKRUNTIME, "Error on bitmap ressource: %s\n", e.what());
    }
   
    // No mipmap generation with widget.
    pixelBuffer->unlock();
    */
  }
 
  forceRenderingUpdate = true;
}
 
}