SO3Widget.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 "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3Widget.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include "SO3Material/SO3Material.h"
#include "SO3Renderer/SO3ViewPort.h"
#include <OgreBitwise.h>
#include <boost/algorithm/string.hpp>
 
namespace SO3
{
 
  unsigned int prevPOW2(unsigned int x)
  {
    if (x == 0)
    {
      return 0;
    }
    // x--; Uncomment this, if you want a strictly less than 'x' result.
    x |= (x >> 1);
    x |= (x >> 2);
    x |= (x >> 4);
    x |= (x >> 8);
    x |= (x >> 16);
    return x - (x >> 1);
  }
 
  SWidget::SWidget() : SData(""), isOverlayed(false), is2DRect(false)
  {
    // Forbiden, private constructor
  }
 
  SWidget::SWidget(SScene* targetScene, const std::string& widgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport, const unsigned int& widgetZOrder, const std::string& widgetType) : SData(widgetName), isOverlayed(true), is2DRect(false)
  {
    StandardConstructor(targetScene, xPos, yPos, widgetWidth, widgetHeight, widgetZOrder, targetViewport, widgetType);
    if (widgetType != "BitmapWidget")
      CreateTexture();
 
    CreateMaterial();
    CreateOverlay();
  }
 
  SWidget::SWidget(SScene* targetScene, const std::string& widgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport, const std::string& widgetType) : SData(widgetName), isOverlayed(false), is2DRect(true)
  {
    StandardConstructor(targetScene, xPos, yPos, widgetWidth, widgetHeight, 0, targetViewport, widgetType);
 
    if (widgetType != "BitmapWidget")
      CreateTexture();
 
    CreateMaterial();
    Create2D();
  }
 
  SWidget::SWidget(SScene* targetScene, const std::string& widgetName, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SMaterial* targetMaterial, const unsigned short& targetTechnique, const unsigned short& targetPass, const unsigned short& targetTextureUnit, const std::string& widgetType) : SData(widgetName), isOverlayed(false), is2DRect(false)
  {
    StandardConstructor(targetScene, 0, 0, widgetWidth, widgetHeight, 0, 0, widgetType);
 
    // Let the material know that a widget will modify it's internal data.
    // Warning, an exception can be fired here.
    originalMaterial = targetMaterial;
    //if (targetMaterial->GetAssociatedWidget() == 0)
    targetMaterial->SetAssociatedWidget(this);
 
    ogreTargetMaterial = targetMaterial->getOgreMaterialPointer();
 
    //update generated materials
    SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
   
    ogreTargetMaterialPass = ogreTargetMaterial->getTechnique(targetTechnique)->getPass(targetPass);
    ogreTargetTextureUnit = ogreTargetMaterialPass->getTextureUnitState(targetTextureUnit);
 
    matData.oSceneBlendingS = ogreTargetMaterialPass->getSourceBlendFactor();
    matData.oSceneBlendingD = ogreTargetMaterialPass->getDestBlendFactor();
    matData.oDepthWrite = ogreTargetMaterialPass->getDepthWriteEnabled();
    
    ogreOriginalTextureUnit = OGRE_NEW Ogre::TextureUnitState(*ogreTargetTextureUnit);
    renderingTextureUnit = OGRE_NEW Ogre::TextureUnitState(*ogreTargetTextureUnit);
 
    // Create texture AFTER storing original material and texture informations
    if (widgetType != "BitmapWidget")
    {
      CreateTexture();
    }
  }
 
  void SWidget::StandardConstructor(SScene* targetScene, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, const unsigned int& widgetZOrder, SViewPort* targetViewport, const std::string& widgetType)
  {
    // Default Init
    type = widgetType;
    leftPos = xPos;
    topPos = yPos;
    width = widgetWidth;
    height = widgetHeight;
    leftOffset = 0.0f;
    topOffset = 0.0f;
    scene = targetScene;
    viewport = targetViewport;
    currentViewport = (viewport) ? viewport->GetOgreViewPortPointer() : 0;
    renderingTexture.reset();
    renderingTextureUnit = 0;
    ogreOriginalTextureUnit = 0;
    mTextureWidth = 0;
    mTextureHeight = 0;
    textureRatio = 1.0f;
    baseResourceName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Widgets/" + widgetType;
    compensateNPOT = false;
    ogreTargetTextureUnit = 0;
    ogreTargetMaterialPass = 0;
    topOnFocus = false;
    isPriorized = false;
    originalMaterial = 0;
    mouseIsOver = 0;
    opacity = 1.0f;
    isTransparent = false;
    mouseEnable = true;
    keyboardEnable = true;
    forceRenderingUpdate = false;
    transparentIgnorePixels = isOverlayed;
    transparentTresholdColor = (transparentIgnorePixels) ? 0.04f : 0.0f;
    updateOnFocusOnly = false;
    mStereoMode = StereoMode::MONO;
    mVisible = true;
 
    // 2D rect stuff
    ogre2dRect = 0;
    ogre2dNode = 0;
    widthScale = 1.0f;
    heightScale = 1.0f;
 
    // Overlay stuff
    zOrder = widgetZOrder;
    ogreOverlay = 0;
    ogreOverlayPanel = 0;
    ogreOverlayMaterial.reset();
  }
 
  SWidget::~SWidget()
  {
    // For overlayed widget only
    if (isOverlayed)
    {
      DestroyOverlay();
      DestroyMaterial();
    }
    else if (is2DRect)
    {
      Destroy2D();
      DestroyMaterial();
    }
    else
    {
      // Reset the original texture name if the widget was created on an existing material
      if (ogreOriginalTextureUnit)
      {
        //update generated materials
        SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
 
        if (mVisible)
        {
          Ogre::LayerBlendModeEx bmode = ogreOriginalTextureUnit->getAlphaBlendMode();
          ogreTargetTextureUnit->setAlphaOperation(bmode.operation, bmode.source1, bmode.source2, bmode.alphaArg1, bmode.alphaArg2, bmode.factor);
          ogreTargetTextureUnit->setTextureFiltering(ogreOriginalTextureUnit->getTextureFiltering(Ogre::FT_MIN), ogreOriginalTextureUnit->getTextureFiltering(Ogre::FT_MAG), ogreOriginalTextureUnit->getTextureFiltering(Ogre::FT_MIP));
          
          ogreTargetTextureUnit->removeAllEffects();
          Ogre::TextureUnitState::EffectMap effects = ogreOriginalTextureUnit->getEffects();
          Ogre::TextureUnitState::EffectMap::const_iterator it;
          for (it = effects.begin(); it != effects.end(); it++)
          {
            Ogre::TextureUnitState::TextureEffect effect = it->second;
            ogreTargetTextureUnit->addEffect(effect);
          }
          ogreTargetMaterialPass->setSceneBlending(matData.oSceneBlendingS, matData.oSceneBlendingD);
          ogreTargetMaterialPass->setDepthWriteEnabled(matData.oDepthWrite);
 
          try
          {
            if (!ogreOriginalTextureUnit->_getTexturePtr())
              ogreTargetTextureUnit->setBlank();
            else
              ogreTargetTextureUnit->setTexture(ogreOriginalTextureUnit->_getTexturePtr());
          }
          catch (Ogre::Exception &)
          {
            ogreTargetTextureUnit->setTextureName("blackpix.jpg");
          }
 
          //Reset materials
          SMaterial::CleanUpGeneratedTechniques(ogreTargetMaterial.get());          
        }
 
        OGRE_DELETE(ogreOriginalTextureUnit);
        OGRE_DELETE(renderingTextureUnit);
      }
    }
 
    // Free rendering texture
    DestroyTexture();
 
    if (isOverlayed)
      SWidgetManager::getSingleton().UpdateWidgetsZOrder(); // Recalculate zOrder of all widgets without this one.
    else if (!is2DRect)
      originalMaterial->SetAssociatedWidget(0);             // Remove reference to this widget of the material
  }
 
  void SWidget::SetCurrentViewport(Ogre::Viewport* vp)
  {
    currentViewport = (!vp && viewport) ? viewport->GetOgreViewPortPointer() : vp;
  }
 
  SScene* SWidget::GetParentScene()
  {
    return scene;
  }
 
  std::string SWidget::GetType()
  {
    return type;
  }
 
  bool SWidget::IsCompensateNPOT() const
  {
    return compensateNPOT;
  }
 
  unsigned short SWidget::GetWidth()
  {
    return width;
  }
 
  unsigned short SWidget::GetHeight()
  {
    return height;
  }
 
  SPoint<unsigned short> SWidget::GetSize()
  {
    return SPoint<unsigned short>(width, height);
  }
 
  void SWidget::SetSize(const unsigned short& newWidth, const unsigned short& newHeight)
  {
    SetSize(SPoint<unsigned short>(newWidth, newHeight));
  }
 
  void SWidget::SetSize(const SPoint<unsigned short>& newSize)
  {
    if ((width == newSize.x) && (height == newSize.y))
      return;
 
    width = newSize.x;
    height = newSize.y;
    SetSizeImpl(width, height);
 
    if (ogreOverlay != 0)
    {
      ogreOverlayPanel->setDimensions(width, height);
 
      xCoef.y = width;
      yCoef.y = height;
    }
 
    if (ogre2dRect != 0)
    {
      if (currentViewport->getActualWidth() > 5 || currentViewport->getActualHeight() > 5)
      {
        Ogre::Real wcoef = 2.0f / currentViewport->getActualWidth();
        Ogre::Real hcoef = 2.0f / currentViewport->getActualHeight();
        Ogre::Real w = wcoef * width;
        Ogre::Real h = hcoef * height;
        Ogre::Real l = (wcoef * leftPos) - 1.0f;
        Ogre::Real t = 1.0f - (hcoef * topPos);
        Ogre::Real r = ((wcoef * leftPos) + w) - 1.0f;
        Ogre::Real b = 1.0f - ((hcoef * topPos) + h);
        xCoef.x = l;
        xCoef.y = r;
        yCoef.x = t;
        yCoef.y = b;
      }
 
      Ogre::Real l = (xCoef.x * widthScale) + leftOffset;
      Ogre::Real r = (xCoef.y * widthScale) + leftOffset;
      Ogre::Real t = (yCoef.x * heightScale) + topOffset;
      Ogre::Real b = (yCoef.y * heightScale) + topOffset;
      ogre2dRect->setCorners(l, t, r, b, false);
      
      Ogre::AxisAlignedBox aabInf;
      aabInf.setInfinite();
      ogre2dRect->setBoundingBox(aabInf);
    };
  }
 
  SPoint<int> SWidget::GetPosition()
  {
    if ((ogreOverlay != 0) || (ogre2dRect != 0))
    {
      return SPoint<int>(leftPos, topPos);
    }
    else
      return SPoint<int>(0, 0);
  }
 
  void SWidget::SetPosition(const int& xPos, const int& yPos)
  {
    SetPosition(SPoint<int>(xPos, yPos));
  }
 
  void SWidget::SetLeftOffset(const float left)
  {
    leftOffset = left;
    SetPosition(SPoint<int>(leftPos, topPos));
  }
 
  void SWidget::SetTopOffset(const float top)
  {
    topOffset = top;
    SetPosition(SPoint<int>(leftPos, topPos));
  }
 
  SPoint<int> SWidget::GetRealPixelPosition()
  {
    SPoint<int> rpos;
    if (ogreOverlay != 0 || ogre2dRect != 0)
    {
      rpos.x = leftPos + (static_cast<int>((float)(currentViewport->getActualWidth() <= 1) ? 1.0f : currentViewport->getActualWidth() * widthScale * leftOffset)) + ((width - static_cast<int>((float)width * widthScale)) / 2);
      rpos.y = topPos + (static_cast<int>((float)(currentViewport->getActualHeight() <= 1) ? 1.0f : currentViewport->getActualHeight() * heightScale * topOffset)) + ((height - static_cast<int>((float)height * heightScale)) / 2);
    }
    else
    {
      rpos = GetPosition();
    }
 
    return rpos;
  }
 
  SPoint<unsigned short> SWidget::GetRealPixelSize()
  {
    SPoint<unsigned short> rsize;
    if (ogreOverlay != 0 || ogre2dRect != 0)
    {
      rsize.x = static_cast<unsigned short>((float)width * widthScale);
      rsize.y = static_cast<unsigned short>((float)height * heightScale);
    }
    else
    {
      rsize = GetSize();
    }
 
    return rsize;
  }
 
  void SWidget::SetPosition(const SPoint<int>& newPosition)
  {
    if (ogreOverlay != 0)
    {
      leftPos = newPosition.x;
      topPos = newPosition.y;
      ogreOverlay->setScale(1.0f, 1.0f);
      ogreOverlayPanel->_setLeft(0.0f);
      ogreOverlayPanel->_setTop(0.0f);
      ogreOverlayPanel->setPosition(static_cast<Ogre::Real> (leftPos), static_cast<Ogre::Real> (topPos));
 
      if ((leftOffset != 0.0) || (topOffset != 0.0))
      {
        //update the real position
        if (!SRoot::getSingletonPtr()->isDeviceLost())
          ogreOverlayPanel->_update();
 
        if (leftOffset != 0.0)
        {
          Ogre::Real cleft = ogreOverlayPanel->_getLeft();
          ogreOverlayPanel->_setLeft(cleft + leftOffset);
        }
 
        if (topOffset != 0.0)
        {
          Ogre::Real ctop = ogreOverlayPanel->_getTop();
          ogreOverlayPanel->_setTop(ctop + topOffset);
        }
      }
 
      xCoef = Ogre::Vector2(ogreOverlayPanel->getLeft(), ogreOverlayPanel->getWidth());
      yCoef = Ogre::Vector2(ogreOverlayPanel->getTop(), ogreOverlayPanel->getHeight());
 
      //reapply scale
      ogreOverlay->setScale(widthScale, heightScale);
    }
 
    if (ogre2dRect != 0)
    {
      leftPos = newPosition.x;
      topPos = newPosition.y;
 
      if (currentViewport->getActualWidth() > 5 || currentViewport->getActualHeight() > 5)
      {
        Ogre::Real wcoef = 2.0f / currentViewport->getActualWidth();
        Ogre::Real hcoef = 2.0f / currentViewport->getActualHeight();
        Ogre::Real w = wcoef * width;
        Ogre::Real h = hcoef * height;
        Ogre::Real l = (wcoef * leftPos) - 1.0f;
        Ogre::Real t = 1.0f - (hcoef * topPos);
        Ogre::Real r = ((wcoef * leftPos) + w) - 1.0f;
        Ogre::Real b = 1.0f - ((hcoef * topPos) + h);
        xCoef.x = l;
        xCoef.y = r;
        yCoef.x = t;
        yCoef.y = b;
      }
 
      Ogre::Real l = (xCoef.x * widthScale) + leftOffset;
      Ogre::Real r = (xCoef.y * widthScale) + leftOffset;
      Ogre::Real t = (yCoef.x * heightScale) + topOffset;
      Ogre::Real b = (yCoef.y * heightScale) + topOffset;
      ogre2dRect->setCorners(l, t, r, b, false);
 
      Ogre::AxisAlignedBox aabInf;
      aabInf.setInfinite();
      ogre2dRect->setBoundingBox(aabInf);
    }
  }
 
  float SWidget::GetTextureRatio()
  {
    return textureRatio;
  }
 
  void SWidget::SetTextureRatio(const float& newRatio)
  {
    if (textureRatio != newRatio)
    {
      textureRatio = newRatio;
 
      if (type != "BitmapWidget")
        CreateTexture();
    }
  }
 
  void SWidget::Move(const SPoint<int>& relativeMove)
  {
    // Move the widget
    SetPosition(SPoint<int>(leftPos + relativeMove.x, topPos + relativeMove.y));
  }
 
  void SWidget::SetScale(const float width, const float height)
  {
    widthScale = width;
    heightScale = height;
 
    // Scale the widget
    if (ogreOverlay != 0)
      ogreOverlay->setScale(widthScale, heightScale);
    else if (ogre2dRect != 0)
    {
      SetPosition(SPoint<int>(leftPos, topPos));
    }
  }
 
  SPoint<float> SWidget::GetScale()
  {
    return SPoint<float>(widthScale, heightScale);
  }
 
  void SWidget::SetZOrder(const unsigned short& newWidgetOrder)
  {
    zOrder = newWidgetOrder;
 
    // Update other widgets if needed.
    if (isOverlayed)
      SWidgetManager::getSingleton().UpdateWidgetsZOrder();
  }
 
  unsigned short SWidget::GetZOrder()
  {
    return zOrder;
  }
 
  void SWidget::CreateTexture(bool alpha)
  {
    // Erase existing texture (texture reset in case of re-creation).
    DestroyTexture();
 
    const Ogre::RenderSystemCapabilities* caps = SRoot::getSingleton().GetOgreRenderSystem()->getCapabilities();
    
    if (caps && (!caps->hasCapability(Ogre::RSC_NON_POWER_OF_2_TEXTURES)))
      compensateNPOT = true;
 
    if (type != "BitmapWidget")
    {
      if (compensateNPOT)
      {
        mTextureWidth = Ogre::Bitwise::firstPO2From(static_cast <unsigned short>(width * textureRatio)) / 2;
        mTextureHeight = Ogre::Bitwise::firstPO2From(static_cast <unsigned short>(height * textureRatio)) / 2;
      }
      else
      {
        mTextureWidth = static_cast <unsigned short>(width * textureRatio);
        mTextureHeight = static_cast <unsigned short>(height * textureRatio);
      }
    }
    else
    {
      if (compensateNPOT)
      {
        mTextureWidth = Ogre::Bitwise::firstPO2From(static_cast <unsigned short>(mTextureWidth * textureRatio));
        mTextureHeight = Ogre::Bitwise::firstPO2From(static_cast <unsigned short>(mTextureHeight * textureRatio));
 
#if defined(ANDROID) || defined(APPLE_IOS) || defined(RPI)
        if (mTextureWidth > 512 || mTextureHeight > 512)
        {
          mTextureWidth = mTextureWidth / 2;
          mTextureHeight = mTextureHeight / 2;
        }
#endif
      }
      else
      {
        mTextureWidth = static_cast <unsigned short>(mTextureWidth * textureRatio);
        mTextureHeight = static_cast <unsigned short>(mTextureHeight * textureRatio);
      }
    }
 
    // Check if size is not null
    mTextureWidth = std::max<unsigned short>(mTextureWidth, 1);
    mTextureHeight = std::max<unsigned short>(mTextureHeight, 1);
 
    // no too high texture size
    /*if (compensateNPOT)
    {
    mTextureWidth = std::min<unsigned short>(mTextureWidth, 768);
    mTextureHeight = std::min<unsigned short>(mTextureHeight, 768);
    }*/
 
    MMechostr(MSKDEBUG, ">>>> Widget texture creation : %ix%i", mTextureWidth, mTextureHeight);
    // Create the texture
    try
    {
      Ogre::PixelFormat format = Ogre::PF_A8R8G8B8;
      SRoot::getSingleton().GetRttPixelFormat(format, alpha);
 
/*#if defined(APPLE_IOS)
      Ogre::PixelFormat format = ((alpha == false) && Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_BYTE_RGB, Ogre::TU_DYNAMIC)) ? Ogre::PF_BYTE_RGB : Ogre::PF_BYTE_RGBA;
#else
      Ogre::PixelFormat format = ((alpha == false) && Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_BYTE_BGR, Ogre::TU_DYNAMIC)) ? Ogre::PF_BYTE_BGR : Ogre::PF_BYTE_BGRA;
#endif*/
      std::string grpName = (ogreTargetTextureUnit != 0) ? ogreTargetTextureUnit->getParent()->getResourceGroup() : SO3_INTERNAL_RESOURCE_GROUP;
      renderingTexture = Ogre::TextureManager::getSingleton().createManual(baseResourceName + "/Texture/" + name, grpName, Ogre::TEX_TYPE_2D, mTextureWidth, mTextureHeight, 0, format, Ogre::TU_DYNAMIC, this);
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
      renderingTexture.reset();
    }
 
    if (renderingTexture)
    {
      // Initialise pixel buffer
      Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
      pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
      const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
      unsigned int textureDepth = Ogre::PixelUtil::getNumElemBytes(pixelBox.format);
      unsigned int texturePitch = (pixelBox.rowPitch*textureDepth);
      memset(pixelBox.data, 0, mTextureHeight*texturePitch);
      pixelBuffer->unlock();
 
      // Apply on existing material
      if (ogreTargetTextureUnit != 0)
      {
        //apply on backup for hide
        renderingTextureUnit->setTextureName(baseResourceName + "/Texture/" + name);
        renderingTextureUnit->setTexture(renderingTexture);
        renderingTextureUnit->removeAllEffects();
        
#ifndef APPLE_IOS
        renderingTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
#else
        renderingTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
        renderingTextureUnit->setTextureFiltering(Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
#endif
        
        if (mVisible)
        {
          ogreTargetTextureUnit->removeAllEffects();
#ifndef APPLE_IOS
          ogreTargetTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
#else
          ogreTargetTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
          ogreTargetTextureUnit->setTextureFiltering(Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
#endif
          if (!renderingTexture)
            ogreTargetTextureUnit->setBlank();
          else
            ogreTargetTextureUnit->setTexture(renderingTexture);
 
          //update generated materials
          SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
        }
 
        //remove generated techniques to let them update
        Ogre::Material* mat = ogreTargetTextureUnit->getParent()->getParent()->getParent();
        std::vector<Ogre::Technique*> techs = mat->getTechniques();
        for (unsigned int i = 0; i < techs.size(); i++)
        {
          if (techs[i]->getSchemeName().find("/Ssao/") != Ogre::String::npos)
            mat->removeTechnique(i);
        }
      }
      else
      {
        if (ogreOverlayMaterial)
        {
          if (!renderingTexture)
            ogreOverlayMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setBlank();
          else
            ogreOverlayMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTexture(renderingTexture);
        }
      }
    }
  }
 
  void SWidget::DestroyTexture()
  {
    // Destroy internal rendering texture
    if (renderingTexture)
    {
      renderingTexture->unload();
      //renderingTexture->setManuallyLoaded(false);
      // Tell the texture manager that we want to unload the texture, and set the shared pointer to null ask for texture total destruction.
      Ogre::TextureManager::getSingleton().remove(renderingTexture->getHandle());
      renderingTexture.reset();
    }
  }
 
  void SWidget::CreateOverlay()
  {
    assert(ogreOverlayMaterial);
 
    // Erase existing panels and overlays (reset in case of re-creation).
    DestroyOverlay();
 
    // Create overlay.
    ogreOverlayPanel = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", baseResourceName + "/Overlays/Panels/" + name));
    ogreOverlayPanel->setMetricsMode(Ogre::GMM_PIXELS);
    ogreOverlayPanel->setMaterialName(ogreOverlayMaterial->getName());
    ogreOverlayPanel->setDimensions(width, height);
 
    ogreOverlay = Ogre::OverlayManager::getSingleton().create(baseResourceName + "/Overlays/" + name);
    ogreOverlay->add2D(ogreOverlayPanel);
 
    SetPosition(SPoint<int>(leftPos, topPos));
    ogreOverlay->show();
  }
 
  void SWidget::DestroyOverlay()
  {
    if (ogreOverlayPanel != 0)
    {
      Ogre::OverlayManager::getSingleton().destroyOverlayElement(ogreOverlayPanel);
      ogreOverlayPanel = 0;
    }
 
    if (ogreOverlay != 0)
    {
      Ogre::OverlayManager::getSingleton().destroy(ogreOverlay);
      ogreOverlay = 0;
    }
  }
 
  void SWidget::Create2D()
  {
    assert(ogreOverlayMaterial);
 
    // Erase existing 2D rect (reset in case of re-creation).
    Destroy2D();
 
    // Create overlay.
    ogre2dRect = new Ogre::Rectangle2D(true);
    SetPosition(SPoint<int>(leftPos, topPos));
    ogre2dRect->setMaterial(ogreOverlayMaterial);
    ogre2dRect->setCastShadows(false);
 
    // Render the background before everything else
    ogre2dRect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
 
    // Use infinite AAB to always stay visible
    Ogre::AxisAlignedBox aabInf;
    aabInf.setInfinite();
    ogre2dRect->setBoundingBox(aabInf);
    ogre2dRect->setVisibilityFlags(1 << 11);
 
    // Attach background to the scene
    ogre2dNode = scene->GetOgreScenePointer()->getRootSceneNode()->createChildSceneNode(baseResourceName + "/Background/" + name);
    ogre2dNode->attachObject(ogre2dRect);
    
    ogre2dRect->setRenderingDistance(0.0f);
    ogre2dRect->setRenderingMinPixelSize(0.0f);
  }
 
  void SWidget::Destroy2D()
  {
    if (ogre2dRect != 0)
    {
      ogre2dRect->detachFromParent();
      scene->GetOgreScenePointer()->getRootSceneNode()->removeChild(ogre2dNode);
      scene->GetOgreScenePointer()->destroySceneNode(ogre2dNode);
      delete(ogre2dRect);
      ogre2dRect = 0;
      ogre2dNode = 0;
    }
  }
 
  void SWidget::CreateMaterial()
  {
    assert((isOverlayed == true) || (is2DRect == true));
 
    // Erase existing material (reset in case of re-creation).
    DestroyMaterial();
 
    // Create the material that will be use by the overlay panel
    ogreOverlayMaterial = Ogre::MaterialManager::getSingleton().create(baseResourceName + "/Overlays/Panels/Materials/" + name, SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* matPass = ogreOverlayMaterial->getTechnique(0)->getPass(0);
    renderingTextureUnit = matPass->createTextureUnitState();
 
#ifndef APPLE_IOS
    renderingTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
    renderingTextureUnit->setTextureFiltering(Ogre::TFO_BILINEAR);
#else
    renderingTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    renderingTextureUnit->setTextureFiltering(Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
#endif
 
    //set shaders
    try
    {
      matPass->setVertexProgram("SO3/VS/OVERLAY", true);
      matPass->setFragmentProgram("SO3/FP/OVERLAY", true);
    }
    catch (Ogre::Exception &e)
    {
      MMechostr(MSKDEBUG, "Warning : Overlay programm not found : %s", e.what());
    }
 
    try
    {
      if (!renderingTexture)
        renderingTextureUnit->setTextureName("blackpix.jpg");
      else
        renderingTextureUnit->setTexture(renderingTexture);
 
      renderingTextureUnit->setNumMipmaps(0);
    }
    catch (Ogre::Exception&)
    {
    }
 
    if (is2DRect)
    {
      matPass->setDepthCheckEnabled(false);
      matPass->setDepthWriteEnabled(false);
      matPass->setLightingEnabled(false);
      ogreOverlayMaterial->setReceiveShadows(false);
    }
 
    ApplyMaterialParameters(matPass, renderingTextureUnit);
  }
 
  void SWidget::DestroyMaterial()
  {
    if (ogreOverlayMaterial)
    {
      SMaterial::CleanUpGeneratedTechniques(ogreOverlayMaterial.get());
      SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
 
      // Tell the material manager that we want to unload the material, and set the shared pointer to null ask for material total destruction.
      ogreOverlayMaterial->unload();
      Ogre::MaterialManager::getSingletonPtr()->remove(ogreOverlayMaterial->getHandle());
      ogreOverlayMaterial.reset();
      renderingTextureUnit = 0;
    }
  }
 
  void SWidget::ApplyMaterialParameters(Ogre::Pass* materialPassToModify, Ogre::TextureUnitState* materialTextureUnitToModify)
  {
    assert((materialPassToModify != 0) && (materialTextureUnitToModify != 0));
    //keep last param for material hide / show and use ogreTargetTextureUnit to check;
    if (isOverlayed || is2DRect || ((isTransparent || (opacity != 1.0f)) && (materialPassToModify->getTextureUnitStateIndex(materialTextureUnitToModify) == 0)))
    {
      if (mVisible || isOverlayed || is2DRect)
      {
        materialPassToModify->setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE_MINUS_SOURCE_ALPHA);
        materialPassToModify->setDepthWriteEnabled(false);
      }
    }
    else
    {
      if (isOverlayed || is2DRect || mVisible)
        materialPassToModify->setSceneBlending((isTransparent || (opacity != 1.0f)) ? Ogre::SBT_TRANSPARENT_ALPHA : Ogre::SBT_REPLACE);
 
      if (!isTransparent && (opacity == 1.0f) && (!is2DRect))
        if (materialPassToModify->getTextureUnitStateIndex(materialTextureUnitToModify) == 0)
        {
          if (mVisible || isOverlayed)
            materialPassToModify->setDepthWriteEnabled(true);
        }
    }
    
    if (isOverlayed || is2DRect || mVisible)
    {
#ifndef APPLE_IOS
      materialTextureUnitToModify->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
      materialTextureUnitToModify->setTextureFiltering(Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
#else
      materialTextureUnitToModify->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
      materialTextureUnitToModify->setTextureFiltering(Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
#endif
    }    
 
    if (isOverlayed || is2DRect)
    {
      try
      {
        if (materialPassToModify->hasFragmentProgram())
        {
          Ogre::GpuProgramParametersSharedPtr fparams = materialPassToModify->getFragmentProgramParameters();
          fparams->setNamedConstant("opacity", opacity);
        }
      }
      catch (Ogre::Exception &)
      {
        //error
      }
    }
    else // custom material
    {
      if (mVisible)
      {
        materialTextureUnitToModify->setAlphaOperation(Ogre::LBX_MODULATE, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
      }
    }
  }
 
  void SWidget::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();*/
    forceRenderingUpdate = true;
  }
 
  void SWidget::_SetOgreOverlayZOrder(const unsigned short& overlayZOrder)
  {
    assert(ogreOverlay != 0);
    ogreOverlay->setZOrder(overlayZOrder);
  }
 
  void SWidget::SetTopOnFocus(const bool& enableWidgetTopOnFocus)
  {
    topOnFocus = enableWidgetTopOnFocus;
  }
 
  bool SWidget::GetTopOnFocus()
  {
    return topOnFocus;
  }
 
  void SWidget::SetForeground(const bool& enableWidgetForeground)
  {
    isPriorized = enableWidgetForeground;
    SWidgetManager::getSingleton().UpdateWidgetsZOrder();
  }
 
  bool SWidget::GetForeground()
  {
    return isPriorized;
  }
 
  void SWidget::TakeFocus()
  {
    SWidgetManager::getSingleton().UpdateFocusedWidget(this);
  }
 
  void SWidget::ReleaseFocus()
  {
    if (this == SWidgetManager::getSingleton().GetFocusedWidget())
      SWidgetManager::getSingleton().UpdateFocusedWidget(0);
  }
 
  bool SWidget::HasFocus()
  {
    if (SWidgetManager::getSingleton().GetFocusedWidget() == this)
      return true;
    else
      return false;
  }
 
  bool SWidget::GetMouseOver()
  {
    return mouseIsOver;
  }
 
  bool SWidget::GetInputOver(int id)
  {
    bool found = false;
    for (unsigned int i = 0; i < inputIndexes.size() && !found; i++)
      found = (inputIndexes[i] == id) ? true : false;
 
    return found;
  }
 
  void SWidget::SetInputOver(int id, bool state)
  {
    if (state)
    {
      if (!GetInputOver(id))
        inputIndexes.push_back(id);
    }
    else
    {
      bool found = false;
      for (unsigned int i = 0; i < inputIndexes.size() && !found; i++)
      {
        found = (inputIndexes[i] == id) ? true : false;
        if (found)
          inputIndexes.erase(inputIndexes.begin() + i);
      }
    }
    mouseIsOver = (inputIndexes.size() > 0) ? true : false;
  }
 
  void SWidget::SetOpacity(const float& widgetOpacity)
  {
    // Bound opacity values between 0 and 1.
    if (widgetOpacity > 1.0f)
      opacity = 1.0f;
    else if (widgetOpacity < 0)
      opacity = 0.0f;
    else
      opacity = widgetOpacity;
 
    if ((isOverlayed) || (is2DRect))
    {
      ApplyMaterialParameters(ogreOverlayMaterial->getTechnique(0)->getPass(0), renderingTextureUnit);
    }
    else
    {
      ApplyMaterialParameters(ogreTargetMaterialPass, ogreTargetTextureUnit);
      //update generated materials
      SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
    }
  }
 
  float SWidget::GetOpacity()
  {
    return opacity;
  }
 
  void SWidget::Show(const bool& fade, const unsigned short& fadeDurationMS)
  {
    if (mVisible)
      return;
 
    mVisible = true;
 
    if (isOverlayed)
    {
      ogreOverlay->show();
    }
    else if (is2DRect)
    {
      ogre2dRect->setVisible(true);
    }
    else
    {
      // Reset the original texture name if the widget was created on an existing material
      if (ogreOriginalTextureUnit)
      {
        if (ogreTargetTextureUnit != 0)
        {
          Ogre::LayerBlendModeEx bmode = renderingTextureUnit->getAlphaBlendMode();
          ogreTargetTextureUnit->setAlphaOperation(bmode.operation, bmode.source1, bmode.source2, bmode.alphaArg1, bmode.alphaArg2, bmode.factor);
          ogreTargetTextureUnit->setTextureFiltering(renderingTextureUnit->getTextureFiltering(Ogre::FT_MIN), renderingTextureUnit->getTextureFiltering(Ogre::FT_MAG), renderingTextureUnit->getTextureFiltering(Ogre::FT_MIP));
 
          ogreTargetTextureUnit->removeAllEffects();
          Ogre::TextureUnitState::EffectMap effects = renderingTextureUnit->getEffects();
          Ogre::TextureUnitState::EffectMap::const_iterator it;
          for (it = effects.begin(); it != effects.end(); it++)
          {
            Ogre::TextureUnitState::TextureEffect effect = it->second;
            ogreTargetTextureUnit->addEffect(effect);
          }
 
          if (!renderingTextureUnit->_getTexturePtr())
            ogreTargetTextureUnit->setBlank();
          else
            ogreTargetTextureUnit->setTexture(renderingTextureUnit->_getTexturePtr());
 
          ApplyMaterialParameters(ogreTargetMaterialPass, ogreTargetTextureUnit);
        }
 
        //update generated materials
        SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
      }
    }
 
    // Unfocus this widget if it's the last focused.
    if (this == SWidgetManager::getSingleton().GetFocusedWidget())
      SWidgetManager::getSingleton().UpdateFocusedWidget(0);
  }
 
  void SWidget::Hide(const bool& fade, const unsigned short& fadeDurationMS)
  {
    if (!mVisible)
      return;
 
    if (isOverlayed)
    {
      ogreOverlay->hide();
    }
    else if (is2DRect)
    {
      ogre2dRect->setVisible(false);
    }
    else
    {
      if (ogreOriginalTextureUnit)
      {
        Ogre::LayerBlendModeEx bmode = ogreOriginalTextureUnit->getAlphaBlendMode();
        ogreTargetTextureUnit->setAlphaOperation(bmode.operation, bmode.source1, bmode.source2, bmode.alphaArg1, bmode.alphaArg2, bmode.factor);
        ogreTargetTextureUnit->setTextureFiltering(ogreOriginalTextureUnit->getTextureFiltering(Ogre::FT_MIN), ogreOriginalTextureUnit->getTextureFiltering(Ogre::FT_MAG), ogreOriginalTextureUnit->getTextureFiltering(Ogre::FT_MIP));
 
        ogreTargetTextureUnit->removeAllEffects();
        Ogre::TextureUnitState::EffectMap effects = ogreOriginalTextureUnit->getEffects();
        Ogre::TextureUnitState::EffectMap::const_iterator it;
        for (it = effects.begin(); it != effects.end(); it++)
        {
          Ogre::TextureUnitState::TextureEffect effect = it->second;
          ogreTargetTextureUnit->addEffect(effect);
        }
 
        ogreTargetMaterialPass->setSceneBlending(matData.oSceneBlendingS, matData.oSceneBlendingD);
        ogreTargetMaterialPass->setDepthWriteEnabled(matData.oDepthWrite);
 
        try
        {
          if (!ogreOriginalTextureUnit->_getTexturePtr())
            ogreTargetTextureUnit->setBlank();
          else
            ogreTargetTextureUnit->setTexture(ogreOriginalTextureUnit->_getTexturePtr());
        }
        catch(Ogre::Exception &)
        {
          ogreTargetTextureUnit->setTextureName("blackpix.jpg");
        }        
 
        //update generated materials
        SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
      }
    }
    mVisible = false;
  }
 
  bool SWidget::GetVisible()
  {
    return mVisible;
  }
 
  void SWidget::SetTransparency(const bool& enableTransparency)
  {
    if (enableTransparency != isTransparent)
    {
      isTransparent = enableTransparency;
      SetTransparencyImpl(isTransparent);
 
      if ((isOverlayed) || (is2DRect))
      {
        ApplyMaterialParameters(ogreOverlayMaterial->getTechnique(0)->getPass(0), renderingTextureUnit);
      }
      else
      {
        ApplyMaterialParameters(ogreTargetMaterialPass, ogreTargetTextureUnit);
        //update generated materials
        SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreTargetMaterial.get());
      }
    }
  }
 
  bool SWidget::GetTransparency()
  {
    return isTransparent;
  }
 
  void SWidget::SetKeyboardEnable(const bool& enableKeyboardOnWidget)
  {
    keyboardEnable = enableKeyboardOnWidget;
    SetKeyboardEnableImpl(enableKeyboardOnWidget);
  }
 
  bool SWidget::GetKeyboardEnable()
  {
    return keyboardEnable;
  }
 
  void SWidget::SetMouseEnable(const bool& enableMouseOnWidget)
  {
    mouseEnable = enableMouseOnWidget;
    SetMouseEnableImpl(enableMouseOnWidget);
  }
 
  bool SWidget::GetMouseEnable()
  {
    return mouseEnable;
  }
 
  std::string SWidget::CheckUrl(const std::string& url)
  {
    std::string httpPrefix = "http://";
    std::string httpsPrefix = "https://";
    std::string ftpPrefix = "ftp://";
    std::string filePrefix = "file://";
 
    std::string urlString = url;
    boost::to_lower(urlString);
 
    // Add "http://" if needed. 
    if ((urlString.substr(0, httpPrefix.length()) != httpPrefix)
      && (urlString.substr(0, httpsPrefix.length()) != httpsPrefix)
      && (urlString.substr(0, ftpPrefix.length()) != ftpPrefix)
      && (urlString.substr(0, filePrefix.length()) != filePrefix))
    {
      urlString = httpPrefix + url;
    }
    else
    {
      urlString = url;
    }
 
    return urlString;
  }
 
  void SWidget::SetIgnoreTransparentPixels(const bool& widgetIgnoreTransparentPixels, const float& tresholdColor)
  {
    transparentIgnorePixels = widgetIgnoreTransparentPixels;
    transparentTresholdColor = tresholdColor;
  }
 
  bool SWidget::GetIgnoreTransparentPixels()
  {
    return transparentIgnorePixels;
  }
 
  float SWidget::GetIgnoreTransparentPixelsTreshold()
  {
    return transparentTresholdColor;
  }
 
  bool SWidget::GetUpdateOnFocusOnly()
  {
    return updateOnFocusOnly;
  }
 
  void SWidget::SetUpdateOnFocusOnly(const bool& activate)
  {
    updateOnFocusOnly = activate;
  }
 
  bool SWidget::GetIsOverlayed()
  {
    return isOverlayed;
  }
 
  bool SWidget::GetIs2DRect()
  {
    return is2DRect;
  }
 
  bool SWidget::GetIsStereo()
  {
    return mStereoMode != StereoMode::MONO;
  }
 
  void SWidget::SetStereo(StereoMode state)
  {
    if (mStereoMode == state)
      return;
 
    mStereoMode = state;
    if (mStereoMode != StereoMode::MONO)
    {
      SetStereoEye();
    }
    else
    {
      if (isOverlayed)
        ogreOverlayPanel->setUV(0.0f, 0.0f, 1.0f, 1.0f);
      else if (is2DRect)
        ogre2dRect->setDefaultUVs();
    }
  }
 
  void SWidget::SetStereoEye(bool isleft)
  {
    if (mStereoMode != StereoMode::MONO)
    {
      if (mStereoMode == StereoMode::SBS)
      {
        if (isOverlayed)
        {
          if (isleft)
            ogreOverlayPanel->setUV(0.0f, 0.0f, 0.5f, 1.0f);
          else
            ogreOverlayPanel->setUV(0.5f, 0.0f, 1.0f, 1.0f);
        }
        else if (is2DRect)
        {
          if (isleft)
            ogre2dRect->setUVs(Ogre::Vector2(0.0f, 0.0f), Ogre::Vector2(0.0f, 1.0f), Ogre::Vector2(0.5f, 0.0f), Ogre::Vector2(0.5f, 1.0f));
          else
            ogre2dRect->setUVs(Ogre::Vector2(0.5f, 0.0f), Ogre::Vector2(0.5f, 1.0f), Ogre::Vector2(1.0f, 0.0f), Ogre::Vector2(1.0f, 1.0f));
        }
      }      
      else if (mStereoMode == StereoMode::TB)
      {
        if (isOverlayed)
        {
          if (isleft)
            ogreOverlayPanel->setUV(0.0f, 0.0f, 1.0f, 0.5f);
          else
            ogreOverlayPanel->setUV(0.0f, 0.5f, 1.0f, 1.0f);
        }
        else if (is2DRect)
        {
          if (isleft)
            ogre2dRect->setUVs(Ogre::Vector2(0.0f, 0.0f), Ogre::Vector2(0.0f, 0.5f), Ogre::Vector2(1.0f, 0.0f), Ogre::Vector2(1.0f, 0.5f));
          else
            ogre2dRect->setUVs(Ogre::Vector2(0.0f, 0.5f), Ogre::Vector2(0.0f, 1.0f), Ogre::Vector2(1.0f, 0.5f), Ogre::Vector2(1.0f, 1.0f));
        }
      }
      else if (mStereoMode == StereoMode::BT)
      {
        if (isOverlayed)
        {
          if (isleft)
            ogreOverlayPanel->setUV(0.0f, 0.5f, 1.0f, 1.0f);
          else
            ogreOverlayPanel->setUV(0.0f, 0.0f, 1.0f, 0.5f);
        }
        else if (is2DRect)
        {
          if (isleft)
            ogre2dRect->setUVs(Ogre::Vector2(0.0f, 0.5f), Ogre::Vector2(0.0f, 1.0f), Ogre::Vector2(1.0f, 0.5f), Ogre::Vector2(1.0f, 1.0f));
          else
            ogre2dRect->setUVs(Ogre::Vector2(0.0f, 0.0f), Ogre::Vector2(0.0f, 0.5f), Ogre::Vector2(1.0f, 0.0f), Ogre::Vector2(1.0f, 0.5f));
        }
      }
    }
  }
 
  HCURSOR SWidget::GetCurrentMouseCursor()
  {
    return 0;
  }
 
}