SO3Engine/SO3Renderer/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "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 "SO3WidgetManager.h"

namespace SO3
{

SBitmapWidget::SBitmapWidget(SScene* targetScene, std::string bitmapWidgetName, int xPos, int yPos, unsigned short widgetWidth, unsigned short widgetHeight, SViewPort* targetViewport, unsigned int widgetZOrder) : SWidget(targetScene, bitmapWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, widgetZOrder, SO3_BITMAP_WIDGET_TYPE)
{
  CommonConstructorSequence();
}

SBitmapWidget::SBitmapWidget(SScene* targetScene, std::string bitmapWidgetName, int xPos, int yPos, unsigned short widgetWidth, unsigned short widgetHeight, SViewPort* targetViewport) : SWidget(targetScene, bitmapWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, SO3_BITMAP_WIDGET_TYPE)
{
  CommonConstructorSequence();
}

SBitmapWidget::SBitmapWidget(SScene* targetScene, std::string bitmapWidgetName, unsigned short widgetWidth, unsigned short widgetHeight, SMaterial* targetMaterial, unsigned short targetTechnique, unsigned short targetPass, 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)
    free(pixelsData);
}

void SBitmapWidget::LoadURL(const std::string& url)
{
  // Throw exception, catch in scol bind, and return nil.
  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.
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Cannot directly load a file directly in a Bitmap widget, use \"UpdateRawData\" function!", "SBitmapWidget::LoadFile");
}

void SBitmapWidget::UpdateRawData(PtrObjBitmap scolBitmap)
{
  // Test if the scolBitmap is valid
  if((scolBitmap->TailleW > 0) && (scolBitmap->TailleH > 0))
  {
    CheckSizeAndAlloc(scolBitmap->TailleW, scolBitmap->TailleH, false);

    // Lock the pixel buffer and get a pixel box
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
    pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
          const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
  
    // copy last bitmap state
    ConversionTools::ScolBitmapGetRGB(scolBitmap, static_cast<unsigned char*>(pixelsData));

    // Create an Ogre pixel box with our scol bitmap data for easy streching.
    const Ogre::PixelBox scolPixelBox(scolBitmap->TailleW, scolBitmap->TailleH, 1, Ogre::PF_R8G8B8, pixelsData);

    // Streching scolBitmap data to Ogre texture size. Nb that the scale function takes an optional filter parameter if we wants other filtering than bilinear
    Ogre::Image::scale(scolPixelBox, pixelBox);
    
    // No mipmap generation with widget.
    pixelBuffer->unlock();
  }
}

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))
  {
    // Lock the pixel buffer and get a pixel box
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
    pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
          const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
    
    CheckSizeAndAlloc(scolBitmap->TailleW, scolBitmap->TailleH, true);

    // copy last bitmap state
    ConversionTools::ScolBitmapGetRGBA(scolBitmap, scolAlphaBitmap, static_cast<Ogre::uint32*>(pixelsData));

    // Create an Ogre pixel box with our scol bitmap data for easy streching.
    const Ogre::PixelBox finalPixelBox(scolBitmap->TailleW, scolBitmap->TailleH, 1, Ogre::PF_R8G8B8A8, pixelsData);

    // Streching scolBitmap data to Ogre texture size. Nb that the scale function takes an optional filter parameter if we wants other filtering than bilinear 
    Ogre::Image::scale(finalPixelBox, pixelBox);
    
    // No mipmap generation with widget.
    pixelBuffer->unlock();
  }
}

void SBitmapWidget::InjectMouseMove(int xPos, int yPos, MouseButtonId button)
{
  // Nothing to do
}

void SBitmapWidget::InjectMouseWheel(int scrollX, int scrollY, int relativeScroll)
{
  // Nothing to do
}

void SBitmapWidget::InjectMouseDown(int xPos, int yPos, MouseButtonId button)
{
  // Nothing to do
}

void SBitmapWidget::InjectMouseUp(int xPos, int yPos, MouseButtonId button)
{
  // Nothing to do
}

void SBitmapWidget::InjectKeyEvent(UINT msg, WindowHandle hwnd, WPARAM wParam, LPARAM lParam)
{
  // Nothing to do
}

void SBitmapWidget::InjectTextEvent(std::string utf8)
{
  // Nothing to do
}

void SBitmapWidget::SetFocusImpl(bool focusOnWidget)
{
  // Nothing to do
}

void SBitmapWidget::SetTransparencyImpl(bool enableTransparency)
{
  // Nothing to do
}
void SBitmapWidget::RunScriptFunction(std::string functionName, std::vector<std::string> argumentList)
{
  // Nothing to do, no script for bitmap!
}

void SBitmapWidget::SetKeyboardEnableImpl(bool enableKeyboardOnWidget)
{
  // Nothing to do
}

void SBitmapWidget::SetMouseEnableImpl(bool enableMouseOnWidget)
{
  // Nothing to do
}

void SBitmapWidget::SetSizeImpl(unsigned short newWidth, unsigned short newHeight)
{
  // Nothing to do
}

int SBitmapWidget::GetPixelUnder(int posX, int posY)
{
  // TODO
  /*if((posX <= SWidget::width) && (posY <= SWidget::height))
  {
    int color = renderBuffer->getBuffer()[posY*renderBuffer->rowSpan + posX*4 + 3];
    if (color > transparentTresholdColor * 255)
      return color;
  }*/
  return -1;
}

void SBitmapWidget::CheckSizeAndAlloc(unsigned int newWidth, unsigned int newHeight, bool alpha)
{
  if ((newWidth != iLastWidth) || (newHeight != iLastHeight) || (alpha != bLastAlphaState))
  {
    if (pixelsData)
      free(pixelsData);

    iLastWidth = newWidth;
    iLastHeight = newHeight;
    bLastAlphaState = alpha;
    
    int nbBytes = alpha ? 4 : 3;
    int size = alpha ? sizeof(Ogre::uint32*) : (sizeof(unsigned char*) * nbBytes);
    pixelsData = (void*)malloc(newWidth * newHeight * size);
  }
}

void SBitmapWidget::loadResource(Ogre::Resource* resource)
{
  Ogre::Texture* tex = static_cast<Ogre::Texture*>(resource);
  tex->setTextureType(Ogre::TEX_TYPE_2D);
  tex->setWidth(textureWidth);
  tex->setHeight(textureHeight);
  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();
    pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
    const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();

    // Create an Ogre pixel box with our scol bitmap data for easy streching.
    const Ogre::PixelBox scolPixelBox(iLastWidth, iLastHeight, 1, bLastAlphaState ?  Ogre::PF_R8G8B8A8 :  Ogre::PF_R8G8B8, pixelsData);

    // Streching scolBitmap data to Ogre texture size. Nb that the scale function takes an optional filter parameter if we wants other filtering than bilinear 
    Ogre::Image::scale(scolPixelBox, pixelBox);
    
    // No mipmap generation with widget.
    pixelBuffer->unlock();
  }

  forceRenderingUpdate = true;
}

}

---