SO3VirtualPointer.cpp

Go to the documentation of this file.

 
#include "SO3SceneGraph/SO3VirtualPointer.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Pass.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include "SO3Renderer/SO3Widget.h"
 
namespace SO3
{
  int VIRTUAL_POINTER_ID = 128;
 
  SVirtualPointer::SVirtualPointer() : SNode(0, "", SNode::VIRTUAL_POINTER_TYPE_ID)
  {
    // Forbiden (private)
  }
 
  SVirtualPointer::SVirtualPointer(SScene* parent, const std::string& name, const float maxlength) : SNode(parent, name, SNode::VIRTUAL_POINTER_TYPE_ID)
  {
    mState = false;
    mAutoUpdate = false;
    mRenderSize = 32;
    mCameraSelector = 0;
    mMaxlength = maxlength;
    mId = VIRTUAL_POINTER_ID++;
 
#if defined(ANDROID) || defined(APPLE_IOS) || defined(OSX) || defined(RPI)
    mSelectorMode = SWindow::SO3_SELECTOR_LIMITED;
#else
    mSelectorMode = SWindow::SO3_SELECTOR_FAST;
#endif
 
    // create the camera used to render to our cubemap
    mRayCam = currentScene->GetOgreScenePointer()->createCamera("camera_" + name);
    mRayCam->setFOVy(Ogre::Degree(5));
    mRayCam->setAspectRatio(1);
    mRayCam->setNearClipDistance(Ogre::Real(0.01));
    mRayCam->setFarClipDistance(Ogre::Real(mMaxlength));
    O3SceneNode->attachObject(mRayCam);
  }
 
  SVirtualPointer::~SVirtualPointer()
  {
    SetEnable(false);
 
    // Destroy the camera
    O3SceneNode->detachObject(mRayCam);
    currentScene->GetOgreScenePointer()->destroyCamera(mRayCam);
  }
 
  void SVirtualPointer::SetSelectorMode(SWindow::SelectorMode mode)
  {
    if (mSelectorMode != mode)
    {
#if defined(ANDROID) || defined(APPLE_IOS) || defined(OSX) || defined(RPI)
      mSelectorMode = (mode == SWindow::SO3_SELECTOR_FAST) ? SWindow::SO3_SELECTOR_LIMITED : mode;
#else
      mSelectorMode = mode;
#endif
 
#if !defined(OSX) && !defined(APPLE_IOS)
      bool reload = false;
 
      if (mCameraSelector)
      {
        SO3_SAFE_DELETE(mCameraSelector);
        mCameraSelector = new SSubEntityCameraSelectorBuffer(mRayCam, name, mRenderSize, mRenderSize, (mSelectorMode == SWindow::SO3_SELECTOR_FAST) ? true : false);
      }
#endif
    }
  }
 
  void SVirtualPointer::SetMaxLength(const float& length)
  {
    mMaxlength = length;
    mRayCam->setFarClipDistance(Ogre::Real(mMaxlength));
  }
 
  float SVirtualPointer::GetMaxLength()
  {
    return mMaxlength;
  }
 
  int SVirtualPointer::GetID()
  {
    return mId;
  }
 
  void SVirtualPointer::SetEnable(const bool& newState)
  {
    if ((newState == true) && (mState == false))
    {
      mCameraSelector = new SSubEntityCameraSelectorBuffer(mRayCam, name, mRenderSize, mRenderSize, (mSelectorMode == SWindow::SO3_SELECTOR_FAST) ? true : false);
      mState = true;
    }
    else if ((newState == false) && (mState == true))
    {
      SAFE_DELETE(mCameraSelector);
      mState = false;
    }
  }
 
  bool SVirtualPointer::GetEnable()
  {
    return mState;
  }
 
  void SVirtualPointer::Update()
  {
    if (!mState)
      return;
 
    SRaycastResult nRaycastValue;
 
    float xR = 0.5f;
    float yR = 0.5f;
    unsigned int pixelsX = mRenderSize / 2;
    unsigned int pixelsY = mRenderSize / 2;
 
    //subentity raycast
    if (mCameraSelector)
    {
      // First, use our selection buffer to find which sub-entity was hit
      Ogre::SubEntity* subEntity = 0;
      Ogre::Vector3 pos(0.0f, 0.0f, 0.0f);
      float rayLenght = 0.0f;
 
      subEntity = mCameraSelector->GetSelectedSubEntity(pixelsX, pixelsY);
 
      if (subEntity && mCameraSelector->UseDepthBuffer())
      {
        float zdepth = mCameraSelector->GetSelectedZdepth(pixelsX, pixelsY);
 
        if (mRayCam)
        {
          // x & y are in range [-1; 1];
          Ogre::Real nx = (2.0f * xR) - 1.0f;
          Ogre::Real ny = 1.0f - (2.0f * yR);
          Ogre::Vector3 nearPoint(nx, ny, -1.0f);
          Ogre::Vector3 midPoint(nx, ny, 0.0f);
 
          //get ray world position and direction
          Ogre::Matrix4 invViewMat = (mRayCam->getProjectionMatrix() * mRayCam->getViewMatrix(true)).inverse();
          Ogre::Vector3 rayOrigin = invViewMat * nearPoint;
          Ogre::Vector3 rayDest = invViewMat * midPoint;
          Ogre::Vector3 rayDirection = rayDest - rayOrigin;
          rayDirection.normalise();
 
          float farclip = mRayCam->getFarClipDistance();
          float nearclip = mRayCam->getNearClipDistance();
 
          // correct perspective
          if (mRayCam->getProjectionType() == Ogre::PT_PERSPECTIVE)
          {
            // non linear depth
            Ogre::Vector4 viewpos = mRayCam->getProjectionMatrixWithRSDepth().inverse() * Ogre::Vector4(nx, ny, zdepth, 1.0f);
            zdepth = viewpos.z / viewpos.w;
 
            //restore view distance from linear depth
            //zdepth *= farclip - nearclip;
 
            if (SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL3_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_METAL_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_VULKAN_RENDERER)
              zdepth += nearclip;
            else
              zdepth -= nearclip;
 
            // get new distance for ray direction
            // A B C triangle : tan(fov / 2) gives AB : AC is depth : then use pythagore to get hypotenuse BC
            double ylenght = Ogre::Math::Tan(mRayCam->getFOVy().valueRadians() * 0.5f);
            double xlenght = ylenght * mRayCam->getAspectRatio();
            double opx = zdepth * abs(xlenght * nx);
            double opy = zdepth * abs(ylenght * ny);
            rayLenght = Ogre::Math::Sqrt((zdepth * zdepth) + (opx * opx) + (opy * opy));
          }
          else
          {
            zdepth *= (farclip - nearclip);
 
            if (SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL3_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_METAL_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_VULKAN_RENDERER)
              zdepth *= 0.5f;
 
            rayLenght = zdepth;
          }
 
          pos = rayOrigin + (rayDirection * rayLenght);
        }
      }
      //MMechostr(MSKDEBUG, ">>>>>> RayCast : %i:%i\n", pixelsX, pixelsY);
 
      if (subEntity != 0)
      {
        //MMechostr(MSKDEBUG, ">>>>>> RayCast : Entity found > %s\n", subEntity->getParent()->getName().c_str());
 
        int subid = -1;
        for (unsigned int i = 0; i < subEntity->getParent()->getNumSubEntities() && (subid == -1); i++)
        {
          if (subEntity->getParent()->getSubEntity(i) == subEntity)
            subid = i;
        }
 
        //Only on widgets when the depth is available
        if (mCameraSelector != 0)
        {
          if (mCameraSelector->UseDepthBuffer())
          {
            Ogre::Any bindedCustomEntity = subEntity->getUserObjectBindings().getUserAny("SEntity");
            SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
            SScene* scene = entity->GetParentScene();
            SMaterial* mat = scene->GetMaterial(entity->GetGroupName(), subEntity->getMaterial()->getName());
 
            nRaycastValue.entity = entity;
            nRaycastValue.entityName = entity->GetName();
            nRaycastValue.scene = entity->GetParentScene();
            nRaycastValue.sceneName = scene->GetName();
            nRaycastValue.material = mat;
 
            // Should we force uv coordonate retrieving too?
            if (mat && (mat->GetAssociatedWidget() != 0))
              nRaycastValue = SRaycast::Cast(mRayCam, xR, yR, subEntity, true);
 
            nRaycastValue.point = pos;
            nRaycastValue.closestDistance = rayLenght;
          }
          else if (mSelectorMode == SWindow::SO3_SELECTOR_LIMITED) // position only on widgets
          {
            Ogre::Any bindedCustomEntity = subEntity->getUserObjectBindings().getUserAny("SEntity");
            SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
            SScene* scene = entity->GetParentScene();
            SMaterial* mat = scene->GetMaterial(entity->GetGroupName(), subEntity->getMaterial()->getName());
 
            // Should we force uv coordonate retrieving too?
            if (mat && (mat->GetAssociatedWidget() != 0))
            {
              nRaycastValue.entity = entity;
              nRaycastValue.entityName = entity->GetName();
              nRaycastValue.scene = entity->GetParentScene();
              nRaycastValue.sceneName = scene->GetName();
              nRaycastValue.material = mat;
              nRaycastValue = SRaycast::Cast(mRayCam, xR, yR, subEntity, true);
            }
            else
            {
              float xR = 0.5f;
              float yR = 0.5f;
              Ogre::Ray ray = mRayCam->getCameraToViewportRay(fabs(xR), fabs(yR));
              ray.setOrigin(GetGlobalPosition());
              GetParentScene()->GetSimpleRayCast(ray, entity, nRaycastValue);
              nRaycastValue.material = mat;
            }
          }
          else
          {
            nRaycastValue = SRaycast::Cast(mRayCam, xR, yR, subEntity);
          }
        }
 
        nRaycastValue.indexSubEntity = subid;
      }
    }
    else
    {
      //simple raycast
      if (mRayCam != 0)
      {
        float xR = 0.5f;
        float yR = 0.5f;
        Ogre::Ray ray = mRayCam->getCameraToViewportRay(fabs(xR), fabs(yR));
        ray.setOrigin(GetGlobalPosition());
 
        GetParentScene()->GetSimpleRayCast(ray, nRaycastValue);
      }
    }
 
    mRaycastValue = nRaycastValue;
  }
  
  void SVirtualPointer::Click(const MouseButtonId& btn)
  {
    CheckRayCastValidity();
 
    if (mRaycastValue.material == 0)
      return;
 
    SWidget* widget = mRaycastValue.material->GetAssociatedWidget();
    if (widget != 0)
      SWidgetManager::getSingleton().InjectMouseDown(widget, mRaycastValue, btn, mId);
  }
 
  void SVirtualPointer::UnClick(const MouseButtonId& btn)
  {
    SWidgetManager::getSingleton().InjectMouseUp(mRaycastValue, btn, mId);
  }
  
  void SVirtualPointer::MoveCursor(const MouseButtonId& btn)
  {
    SWidget* widget = 0;
    CheckRayCastValidity();
 
    if (mRaycastValue.material != 0)
      widget = mRaycastValue.material->GetAssociatedWidget();
 
    SWidgetManager::getSingleton().InjectMouseMove(widget, mRaycastValue, btn, mId);
  }
 
  void SVirtualPointer::Wheel(const int delta)
  {
    SWidget* widget = 0;
    CheckRayCastValidity();
 
    if (mRaycastValue.material != 0)
      widget = mRaycastValue.material->GetAssociatedWidget();
 
    SWidgetManager::getSingleton().InjectMouseWheel(widget, mRaycastValue, delta, mId);
  }
 
  bool SVirtualPointer::HasWidgetUnder()
  {
    return (mState && mRaycastValue.material && (mRaycastValue.material->GetAssociatedWidget() != 0) && (mRaycastValue.material->GetAssociatedWidget()->GetMouseEnable())) ? true : false;
  }
 
  float SVirtualPointer::GetLength()
  {
    if (!mState)
      return 0.0f;
 
    return mRaycastValue.closestDistance;
  }
 
  Ogre::Vector3 SVirtualPointer::GetTargetPosition()
  {
    if (!mState)
      return Ogre::Vector3::ZERO;
 
    return mRaycastValue.point;
  }
 
  SEntity* SVirtualPointer::GetSelectedObject()
  {
    if (!mState)
      return 0;
 
    CheckRayCastValidity();
    return mRaycastValue.entity;
  }
 
  SMaterial* SVirtualPointer::GetSelectedMaterial()
  {
    if (!mState)
      return 0;
 
    CheckRayCastValidity();
    return mRaycastValue.material;
  }
 
  int SVirtualPointer::GetSelectedSubEntity()
  {
    if (!mState)
      return 0;
 
    return mRaycastValue.indexSubEntity;
  }
 
  const SRaycastResult& SVirtualPointer::GetRaycastResult()
  {
    return mRaycastValue;
  }
 
  void SVirtualPointer::CheckRayCastValidity()
  {
    try
    {
      if (mRaycastValue.sceneName != "")
      {
        Ogre::SceneManager* sceneManager = Ogre::Root::getSingleton().getSceneManager(mRaycastValue.sceneName);
        Ogre::Entity* entity = sceneManager->getEntity(mRaycastValue.entityName);
        // If no error occurs, then no need to invalidate lastRaycast
      }
      else
      {
        // Invalidate lastRaycast.
        mRaycastValue = SRaycastResult();
      }
    }
    catch (Ogre::Exception&)
    {
      // Invalidate lastRaycast.
      mRaycastValue = SRaycastResult();
    }
  }
}