SO3EmbeddedWebNavigatorRenderHandler.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) 2011 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 "SO3Web/SO3EmbeddedWebNavigatorRenderHandler.h"
#include "SO3Web/SO3EmbeddedWebNavigatorClient.h"
#include "SO3Web/SO3EmbeddedWebNavigator.h"
#include "SO3Web/SO3EmbeddedWebNavigatorManager.h"
#if SO3_WEB_NAVIGATOR_BUILD == 1
 
namespace SO3
{
  namespace EmbeddedWebNavigator
  {
 
    WebNavigatorRenderHandler::WebNavigatorRenderHandler(CefRefPtr<WebNavigatorClient>& parentWebNavigatorClientInstance, const ScolWindowHandle& scolMainWindow, bool offscreen) : WebNavigatorHandler(parentWebNavigatorClientInstance, scolMainWindow),
      isOffscreen(offscreen)
    {
      offscreenBuffer = 0;
      offscreenBufferMemorySize = 0;
      offscreenBuffer_width = 512;
      offscreenBuffer_height = 512;
      offscreenPopupBuffer = 0;
      offscreenPopupRect.Set(0, 0, 0, 0);
      bufferContentChanged = false;
    }
 
    WebNavigatorRenderHandler::WebNavigatorRenderHandler() : WebNavigatorHandler(CefRefPtr<WebNavigatorClient>(), 0),
      isOffscreen(false)
    {
      // Forbidden ctor
    }
 
    WebNavigatorRenderHandler::~WebNavigatorRenderHandler()
    {
      if (offscreenBuffer)
      {
        free(offscreenBuffer);
        offscreenBuffer = 0;
        offscreenBufferMemorySize = 0;
      }
      if (offscreenPopupBuffer)
      {
        free(offscreenPopupBuffer);
        offscreenPopupBuffer = 0;
        offscreenPopupRect.Set(0, 0, 0, 0);
      }
    }
 
    unsigned char* WebNavigatorRenderHandler::GetOffscreenBuffer()
    {
      bufferContentChanged = false;
      if (isOffscreen)
        return offscreenBuffer;
      else
        return 0;
    }
 
    unsigned char* WebNavigatorRenderHandler::GetOffscreenPopupBuffer()
    {
      bufferContentChanged = false;
      if (isOffscreen)
        return offscreenPopupBuffer;
      else
        return 0;
    }
 
    bool WebNavigatorRenderHandler::GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect)
    {
      assert(CefCurrentlyOn(TID_UI));
      if (isOffscreen && parentWebNavigator)
      {
        std::pair<int, int> size = parentWebNavigator->GetSize();
        rect.x = rect.y = 0;
        rect.width = size.first;
        rect.height = size.second;
        return true;
      }
      return false;
    }
 
    void WebNavigatorRenderHandler::OnPopupShow(CefRefPtr<CefBrowser> browser, bool show)
    {
      // Check cef current thread
      assert(CefCurrentlyOn(TID_UI));
 
      if (isOffscreen && (parentWebNavigatorClient.get() != 0))
      {
        //conditional lock
        std::unique_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
 
        if (!show)
        {
          // Clear the popup buffer.
          offscreenPopupRect.Set(0, 0, 0, 0);
          if (offscreenPopupBuffer != 0)
          {
            // Release memory
            free(offscreenPopupBuffer);
            offscreenPopupBuffer = 0;
 
            // User texture will need refresh
            bufferContentChanged = true;
          }
        }
      }
    }
 
    void WebNavigatorRenderHandler::OnPopupSize(CefRefPtr<CefBrowser> browser, const CefRect& rect)
    {
      // Check cef current thread
      assert(CefCurrentlyOn(TID_UI));
 
      if (isOffscreen && (parentWebNavigatorClient.get() != 0))
      {
        //conditional lock
        std::unique_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
 
        if (rect.width > 0)
        {
          // It will always be inside the view due to HandleGetRect().
          assert(((rect.x + rect.width) < static_cast<int>(offscreenBuffer_width)) && ((rect.y + rect.height) < static_cast<int>(offscreenBuffer_height)));
 
          // Check the new size
          if ((offscreenPopupRect.width * offscreenPopupRect.height) != (rect.width * rect.height))
          {
            // Delete existing buffer
            if (offscreenPopupBuffer != 0)
              free(offscreenPopupBuffer);
 
            // Create a new buffer
            size_t neededMemory = rect.width * rect.height * 4;
            offscreenPopupBuffer = (unsigned char*)malloc(neededMemory);
            memset(offscreenPopupBuffer, 0xF, neededMemory);
          }
 
          // Update the popup rectange.
          offscreenPopupRect = rect;
        }
      }
    }
 
    void WebNavigatorRenderHandler::OnPaint(CefRefPtr<CefBrowser> browser, CefRenderHandler::PaintElementType type, const CefRenderHandler::RectList& dirtyRects, const void* buffer, int width, int height)
    {
      if (isOffscreen && (parentWebNavigatorClient.get() != 0))
      {
        //conditional lock
        std::unique_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
        if (!dirtyRects.empty())
        {
          assert(CefCurrentlyOn(TID_UI));
 
          if (type == PET_VIEW)
          {
            // Paint the view.
            SetRGB(browser, width, height, buffer, dirtyRects);
            bufferContentChanged = true;
          }
 
          if (type == PET_POPUP)
          {
            // Store the popup in our dedicated buffer.
            if (offscreenPopupBuffer != 0)
              memcpy(offscreenPopupBuffer, (unsigned char*)buffer, offscreenPopupRect.width * offscreenPopupRect.height * 4);
          }
        }
      }
    }
 
    void WebNavigatorRenderHandler::OnCursorChange(CefRefPtr<CefBrowser> browser, CefCursorHandle cursor, CursorType type, const CefCursorInfo& custom_cursor_info)
    {
      if (isOffscreen && parentWebNavigator)
      {
        assert(CefCurrentlyOn(TID_UI));
 
        // Send event
        std::unique_lock< std::shared_mutex > lock(WebNavigatorManager::GetSingletonPtr()->webMessageQueueCriticalSection);
        WebNavigatorManager::GetSingletonPtr()->mainThreadWebMessageQueue.post(std::bind(&WebNavigatorManager::InvokeCursorChange, WebNavigatorManager::GetSingletonPtr(), parentWebNavigator->GetUniqueId(), cursor));
      }
    }
 
    void WebNavigatorRenderHandler::SetRGB(CefRefPtr<CefBrowser> browser, int width, int height, const void* src, const RectList& dirtyRects)
    {
      SetBufferSize(width, height);
      ConvertToRGBA((unsigned char*)src, offscreenBuffer, dirtyRects, width, height);
    }
 
    unsigned int WebNavigatorRenderHandler::GetOffscreenBufferWidth()
    {
      return offscreenBuffer_width;
    }
 
    unsigned int WebNavigatorRenderHandler::GetOffscreenBufferHeight()
    {
      return offscreenBuffer_height;
    }
 
    bool WebNavigatorRenderHandler::GetOffscreenBufferContentChanged()
    {
      return bufferContentChanged;
    }
 
    CefRect WebNavigatorRenderHandler::GetOffscreenPopupBufferRect()
    {
      return offscreenPopupRect;
    }
 
    void WebNavigatorRenderHandler::SetBufferSize(int width, int height)
    {
      size_t dst_size = width * height * 4 * sizeof(unsigned char);
 
      // Allocate a new buffer if necesary.
      offscreenBuffer_width = width;
      offscreenBuffer_height = height;
 
      if (dst_size != offscreenBufferMemorySize)
      {
        if (offscreenBuffer)
          free(offscreenBuffer);
 
        offscreenBufferMemorySize = dst_size;
        offscreenBuffer = (unsigned char*)malloc(offscreenBufferMemorySize);
        memset(offscreenBuffer, 0xF, offscreenBufferMemorySize);
      }
    }
 
    void WebNavigatorRenderHandler::ConvertToRGBA(const unsigned char* src, unsigned char* dst, const RectList& dirtyRects, int renderSizeWidth, int renderSizeHeight)
    {
      // Update all dirty regions
      RectList::const_iterator iDirtyRects = dirtyRects.begin();
      while (iDirtyRects != dirtyRects.end())
      {
        // Position the buffer pointer to the start of the dirty region
        size_t initialOffset = ((((*iDirtyRects).y * renderSizeWidth) + (*iDirtyRects).x)) * 4;
        size_t offset = initialOffset;
 
        // Update one dirty region
        for (int i = 0; i < (*iDirtyRects).height; i++)
        {
          memcpy(dst + offset, src + offset, (*iDirtyRects).width * 4);
          offset += (renderSizeWidth * 4);
        }
 
        // Next dirty region
        iDirtyRects++;
      }
    }
 
    void WebNavigatorRenderHandler::_Cleanup()
    {
      WebNavigatorHandler::_Cleanup();
    }
 
    bool WebNavigatorRenderHandler::BlitOffscreenBitmap(unsigned char* dest, int destWidth, int destHeight, int destBytesPerPixel, int destBitsPerLine)
    {
      bool result = false;
      std::shared_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
 
      if ((offscreenBuffer_width == destWidth) && (offscreenBuffer_height == destHeight))
      {
        // Vars used for blitting
        unsigned long srcByte = 0;
        unsigned long destByte = 0;
 
        // Get and blit main view buffer
        unsigned char* buffer = GetOffscreenBuffer();
        if (buffer != 0)
        {
          for (long y = 0; y < destHeight; y++)
          {
            for (long x = 0; x < destWidth; x++)
            {
              srcByte = (x + (destWidth * y)) * 4;
              destByte = (x * destBytesPerPixel) + (y * destBitsPerLine);
 
              dest[destByte] = buffer[srcByte];
              dest[destByte + 1] = buffer[srcByte + 1];
              dest[destByte + 2] = buffer[srcByte + 2];
            }
          }
        }
 
        // Get and blit secondary buffer ('popup' buffer).
        buffer = GetOffscreenPopupBuffer();
        CefRect offscreenPopupBufferRect = GetOffscreenPopupBufferRect();
        if (buffer != 0)
        {
          for (long y = 0; y < offscreenPopupBufferRect.height; y++)
          {
            for (long x = 0; x < offscreenPopupBufferRect.width; x++)
            {
              srcByte = (x + (y * offscreenPopupBufferRect.width)) * 4;
              destByte = ((x + offscreenPopupBufferRect.x) * destBytesPerPixel) + ((offscreenPopupBufferRect.y + y) * destBitsPerLine);
 
              dest[destByte] = buffer[srcByte];
              dest[destByte + 1] = buffer[srcByte + 1];
              dest[destByte + 2] = buffer[srcByte + 2];
            }
          }
        }
 
        // All done
        result = true;
      }
      return result;
    }
 
    bool WebNavigatorRenderHandler::BlitOffscreenAlphaBitmap(unsigned char* destColor, unsigned char* destAlpha, int destWidth, int destHeight, int destColorBytesPerPixel, int destColorBitsPerLine)
    {
      bool result = false;
      std::shared_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
 
      if ((offscreenBuffer_width == destWidth) && (offscreenBuffer_height == destHeight))
      {
        // Vars used for blitting
        unsigned long srcByte = 0;
        unsigned long destByte = 0;
        unsigned long alphaLineOffset = 0;
 
        // Get and blit main view buffer
        unsigned char* buffer = GetOffscreenBuffer();
        if (buffer != 0)
        {
          for (long y = 0; y < destHeight; y++)
          {
            alphaLineOffset = y * destWidth;
            for (long x = 0; x < destWidth; x++)
            {
              srcByte = (x + (y * destWidth)) * 4;
              destByte = (x * destColorBytesPerPixel) + (y * destColorBitsPerLine);
 
              destColor[destByte] = buffer[srcByte];
              destColor[destByte + 1] = buffer[srcByte + 1];
              destColor[destByte + 2] = buffer[srcByte + 2];
              destAlpha[x + alphaLineOffset] = buffer[srcByte + 3];
            }
          }
        }
 
        // Get and blit secondary buffer ('popup' buffer).
        buffer = GetOffscreenPopupBuffer();
        CefRect offscreenPopupBufferRect = GetOffscreenPopupBufferRect();
        if (buffer != 0)
        {
          for (long y = 0; y < offscreenPopupBufferRect.height; y++)
          {
            alphaLineOffset = (y * offscreenPopupBufferRect.width);
            for (long x = 0; x < offscreenPopupBufferRect.width; x++)
            {
              srcByte = (x + (y * offscreenPopupBufferRect.width)) * 4;
              destByte = ((x + offscreenPopupBufferRect.x) * destColorBytesPerPixel) + ((offscreenPopupBufferRect.y + y) * destColorBitsPerLine);
 
              destColor[destByte] = buffer[srcByte];
              destColor[destByte + 1] = buffer[srcByte + 1];
              destColor[destByte + 2] = buffer[srcByte + 2];
              destAlpha[x + alphaLineOffset] = buffer[srcByte + 3];
            }
          }
        }
 
        // All done
        result = true;
      }
      return result;
    }
 
    bool WebNavigatorRenderHandler::BlitOffscreenTexture(Ogre::TexturePtr& ogreTexture, bool forceUpdate)
    {
      bool returnValue = false;
      if (forceUpdate || bufferContentChanged)
      {
        // Lock render handler buffer
        std::shared_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
        try
        {
          // Lock the pixel buffer and get a pixel box
          Ogre::HardwarePixelBufferSharedPtr pixelBuffer = ogreTexture->getBuffer();
          pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
          const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
 
          // Get and blit main view buffer
          unsigned char* cefRenderBuffer = GetOffscreenBuffer();
          if (cefRenderBuffer != 0)
          {
            // Create an Ogre pixel box for easy streching.
            const Ogre::PixelBox scolPixelBox(offscreenBuffer_width, offscreenBuffer_height, 1, Ogre::PF_BYTE_BGRA, cefRenderBuffer);
 
            // Streching bitmap 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);
          }
 
          // Get and blit secondary buffer ('popup' buffer).
          cefRenderBuffer = GetOffscreenPopupBuffer();
          CefRect offscreenPopupBufferRect = GetOffscreenPopupBufferRect();
          if (cefRenderBuffer != 0)
          {
            float ratio = static_cast<float>(pixelBox.getWidth()) / static_cast<float>(offscreenBuffer_width);
            Ogre::PixelBox targetPixelBox = pixelBox.getSubVolume(Ogre::Box(static_cast<size_t>(offscreenPopupBufferRect.x * ratio),
              static_cast<size_t>(offscreenPopupBufferRect.y * ratio),
              static_cast<size_t>((offscreenPopupBufferRect.width + offscreenPopupBufferRect.x) * ratio),
              static_cast<size_t>((offscreenPopupBufferRect.height + offscreenPopupBufferRect.y) * ratio)));
 
            // Create an Ogre pixel box for easy streching.
            const Ogre::PixelBox scolPixelBox(offscreenPopupBufferRect.width, offscreenPopupBufferRect.height, 1, Ogre::PF_BYTE_BGRA, cefRenderBuffer);
 
            // Streching bitmap 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, targetPixelBox);
          }
 
          // Everything is ok
          pixelBuffer->unlock();
          returnValue = true;
        }
        catch (const Ogre::Exception&)
        {
          // Problem!
        }
      }
      return returnValue;
    }
 
    bool WebNavigatorRenderHandler::CheckPixelAlpha(int posX, int posY, float transparentTresholdColor)
    {
      bool returnValue = false;
 
      if (GetOffscreenBuffer() && (posX < static_cast<int>(offscreenBuffer_width)) && (posY < static_cast<int>(offscreenBuffer_height)))
      {
        std::shared_lock< std::shared_mutex > lock(offscreenBufferCriticalSection);
        unsigned char* buf = GetOffscreenBuffer();
        int color = buf[(((posX * 4) + (offscreenBuffer_width * 4) * posY) + 3) * sizeof(unsigned char)];
        if (color > transparentTresholdColor * 255)
          returnValue = true;
      }
      return returnValue;
    }
 
  }
}
 
#endif