SO3Engine/SO3Utils/SO3RayCast.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 "SO3RayCast.h"
#include "../SO3Material/SO3Material.h"
#include "../SO3SceneGraph/SO3Scene.h"
#include "../SO3SceneGraph/SO3Camera.h"

namespace SO3
{

SRaycastResult::SRaycastResult()
{
  scene      = 0;
  sceneName  = "";
  viewport   = 0;
  entity     = 0;
  entityName = "";
  material   = 0;

  closestDistance = -1.0f;
  point      = Ogre::Vector3::ZERO;
  indexFace  = 0;
  v1         = Ogre::Vector3::ZERO;
  v2         = Ogre::Vector3::ZERO;
  v3         = Ogre::Vector3::ZERO;
  pReal1     = Ogre::Vector2::ZERO;
  pReal2     = Ogre::Vector2::ZERO;
  pReal3     = Ogre::Vector2::ZERO;
  uvResult   = Ogre::Vector2(-1.0f, -1.0f);
}

SRaycastResult::SRaycastResult(const SRaycastResult& copiedRaycast)
{
  scene      = copiedRaycast.scene;
  sceneName  = copiedRaycast.sceneName;
  viewport   = copiedRaycast.viewport;
  entity     = copiedRaycast.entity;
  entityName = copiedRaycast.entityName;
  material   = copiedRaycast.material;

  closestDistance = copiedRaycast.closestDistance;
  point      = copiedRaycast.point;
  indexFace  = copiedRaycast.indexFace;
  v1         = copiedRaycast.v1;
  v2         = copiedRaycast.v2;
  v3         = copiedRaycast.v3;
  pReal1     = copiedRaycast.pReal1;
  pReal2     = copiedRaycast.pReal2;
  pReal3     = copiedRaycast.pReal3;
  uvResult   = copiedRaycast.uvResult;
}

SRaycast::SRaycast()
{
  // Private constructor
}

SRaycastResult SRaycast::Cast(SCamera* camera, float relativePosX, float relativePosY, Ogre::SubEntity* subEntity, bool getUvCoordonate)
{
  // Our return struct.
  SRaycastResult results;
  
  // If our ogre is anterior to v1.7
  #if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
    Ogre::Any bindedCustomEntity = subEntity->getUserAny();
  #else
    Ogre::Any bindedCustomEntity = subEntity->getUserObjectBindings().getUserAny("SEntity");
  #endif

  assert(!bindedCustomEntity.isEmpty());
  results.entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
  results.entityName = results.entity->GetName();
  results.scene = results.entity->GetParentScene();
  results.sceneName = results.scene->GetName();
  results.viewport = camera->getCurrentViewPort();
  results.material = results.scene->GetMaterial(results.entity->GetGroupName(), subEntity->getMaterial()->getName());

  // Should we force uv coordonate retrieving too?
  if(!getUvCoordonate && results.material)
    if(results.material->GetAssociatedWidget() != 0)
      getUvCoordonate = true;

  // Cast from camera
  Ogre::Ray ray = camera->GetOgreCameraPointer()->getCameraToViewportRay(abs(relativePosX), abs(relativePosY));

  // Then, pseudo ray cast to the polygon level.
  float closest_distance = -1.0f;
  size_t vertex_count;
  size_t index_count;
  Ogre::Vector3* vertices;
  unsigned long* indices;
  Ogre::SubMesh* submesh = subEntity->getSubMesh();
        GetSubEntityInformation(subEntity, vertex_count, vertices, index_count, indices);

  Ogre::RenderOperation tmpRenderOperation;
        submesh->_getRenderOperation(tmpRenderOperation);
  if(tmpRenderOperation.operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST) 
  {
    int closestVerticeIndex = 0;
    for (int j = 0; j < static_cast<int>(index_count); j += 3) 
    {
      std::pair<bool, Ogre::Real> hit = Ogre::Math::intersects(ray, vertices[indices[j]], vertices[indices[j+1]], vertices[indices[j+2]], true, false); 
      if(hit.first)
      {
        if((closest_distance < 0.0f) || (hit.second < closest_distance))
              {
                      // this is the closest so far, save it off
                      closest_distance = hit.second;
          closestVerticeIndex = j;

                      results.indexFace = j/3;
                      results.v1 = vertices[indices[j]];
                      results.v2 = vertices[indices[j+1]];
                      results.v3 = vertices[indices[j+2]];
                      results.point = ray.getPoint(hit.second);
              }
      }
    }
    results.closestDistance = closest_distance;

    if (getUvCoordonate)
    {
      Ogre::VertexData* vertex_data = submesh->useSharedVertices ? submesh->parent->sharedVertexData : submesh->vertexData;
      const Ogre::VertexElement* vertex_element1 = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
      if(vertex_data->vertexDeclaration->getElementCount()>2)
      {
        /*Ogre::HardwareVertexBufferSharedPtr vbuf1 = vertex_data->vertexBufferBinding->getBuffer(vertex_element1->getSource());
        unsigned char* vertex1 = 0;
        unsigned char* vertex2 = 0;
        unsigned char* vertex3 = 0;
        Ogre::Real* tempReal;
        vertex1 = vertex2 = vertex3 = static_cast<unsigned char*>(vbuf1->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
        vertex1 += indices[closestVerticeIndex]   * vbuf1->getVertexSize();
        vertex2 += indices[closestVerticeIndex+1] * vbuf1->getVertexSize();
        vertex2 += indices[closestVerticeIndex+2] * vbuf1->getVertexSize();
        vertex_element1->baseVertexPointerToElement(vertex1, &tempReal);
        results.pReal1 = Ogre::Vector2(tempReal);
        vertex_element1->baseVertexPointerToElement(vertex2, &tempReal);
        results.pReal2 = Ogre::Vector2(tempReal);
        vertex_element1->baseVertexPointerToElement(vertex3, &tempReal);
        results.pReal3 = Ogre::Vector2(tempReal);
        vbuf1->unlock();*/

        float* pReal1;
        float* pReal2;
        float* pReal3;

        Ogre::HardwareVertexBufferSharedPtr vbuf1 = vertex_data->vertexBufferBinding->getBuffer(vertex_element1->getSource());
              unsigned char* vertex1 = static_cast<unsigned char*>(vbuf1->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
              vertex1 += indices[closestVerticeIndex]*vbuf1->getVertexSize();
              vertex_element1->baseVertexPointerToElement(vertex1, &pReal1);
              vbuf1->unlock();

              const Ogre::VertexElement* vertex_element2 = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
              Ogre::HardwareVertexBufferSharedPtr vbuf2 = vertex_data->vertexBufferBinding->getBuffer(vertex_element2->getSource());
              unsigned char* vertex2 = static_cast<unsigned char*>(vbuf2->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
              vertex2 += indices[closestVerticeIndex+1]*vbuf2->getVertexSize();
              vertex_element2->baseVertexPointerToElement(vertex2, &pReal2);
              vbuf2->unlock();

              const Ogre::VertexElement* vertex_element3 = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
              Ogre::HardwareVertexBufferSharedPtr vbuf3 = vertex_data->vertexBufferBinding->getBuffer(vertex_element3->getSource());
              unsigned char* vertex3 = static_cast<unsigned char*>(vbuf3->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
              vertex3 += indices[closestVerticeIndex+2]*vbuf3->getVertexSize();
              vertex_element3->baseVertexPointerToElement(vertex3, &pReal3);
              vbuf3->unlock();

              results.pReal1.x = pReal1[0];
              results.pReal1.y = pReal1[1];
              results.pReal2.x = pReal2[0];
              results.pReal2.y = pReal2[1];
              results.pReal3.x = pReal3[0];
              results.pReal3.y = pReal3[1];

        Ogre::Vector3 B = GetBarycentricCoordinates(results.v1, results.v2, results.v3, results.point);
        Ogre::Vector2 T = results.pReal1*B.x + results.pReal2*B.y + results.pReal3*B.z;

        results.uvResult.x = abs(T.x) - abs((int)T.x);
        results.uvResult.y = abs(T.y) - abs((int)T.y);

        if(T.x<0)
          results.uvResult.x = 1 - results.uvResult.x;
        if(T.y<0) 
          results.uvResult.y = 1 - results.uvResult.y;
      }
    }
  }
  delete[] vertices;
  delete[] indices;

  return results;
}

void SRaycast::GetSubEntityInformation(Ogre::SubEntity* subEntity, size_t &vertex_count, Ogre::Vector3* &vertices, size_t &index_count, unsigned long* &indices)
{
  size_t current_offset = 0;
        size_t shared_offset = 0;
        size_t next_offset = 0;
        size_t index_offset = 0;

  Ogre::SubMesh* submesh = subEntity->getSubMesh();
  Ogre::Entity* parentEntity = subEntity->getParent();
  bool useSoftwareBlendingVertices = parentEntity->hasSkeleton();
        bool useSoftwareMorphingVertices = parentEntity->hasVertexAnimation();

  Ogre::SceneNode* attachedNode = parentEntity->getParentSceneNode();
  assert(attachedNode != 0);
  Ogre::Vector3 position  = attachedNode->_getDerivedPosition();
  Ogre::Quaternion orient = attachedNode->_getDerivedOrientation();
  Ogre::Vector3 scale     = attachedNode->_getDerivedScale();

  // Count vertexes
  if(submesh->useSharedVertices)
    vertex_count = submesh->parent->sharedVertexData->vertexCount;
        else
                vertex_count = submesh->vertexData->vertexCount;

  // Count indices
        index_count = submesh->indexData->indexCount;

  // Create buffers with the calculated sizes.
        vertices = new Ogre::Vector3[vertex_count];
  indices = new unsigned long[index_count];

  // Retrieve vertex data
  Ogre::VertexData* vertex_data;
        if(useSoftwareBlendingVertices && parentEntity->_isAnimated())
                vertex_data = submesh->useSharedVertices ? parentEntity->_getSkelAnimVertexData() : subEntity->_getSkelAnimVertexData();
        else if(!useSoftwareBlendingVertices && useSoftwareMorphingVertices && parentEntity->_isAnimated() && parentEntity->getMesh()->getPoseCount()==0)
                vertex_data = submesh->useSharedVertices ? parentEntity->_getSoftwareVertexAnimVertexData() : subEntity->_getSoftwareVertexAnimVertexData();
        else
    vertex_data = submesh->useSharedVertices ? submesh->parent->sharedVertexData : submesh->vertexData;

  // Copy vertice informations
  if((!submesh->useSharedVertices)||(submesh->useSharedVertices))
        {
                if(submesh->useSharedVertices)
                        shared_offset = current_offset;

    const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
                Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
                unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));

                float* pReal;
                for(size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
                {
                        posElem->baseVertexPointerToElement(vertex, &pReal);
                        Ogre::Vector3 pt(pReal[0], pReal[1], pReal[2]);
                        vertices[current_offset + j] = (orient * (pt * scale)) + position;
                }

                vbuf->unlock();
                next_offset += vertex_data->vertexCount;
        }

  // Copy indexes informations
  Ogre::IndexData* index_data = submesh->indexData;
        size_t numTris = index_data->indexCount / 3;
        Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
        bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
        unsigned long*  pLong = static_cast<unsigned long*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
        unsigned short* pShort = reinterpret_cast<unsigned short*>(pLong);
        size_t offset = (submesh->useSharedVertices)? shared_offset : current_offset;

        if(use32bitindexes)
                for (size_t k = 0; k < numTris*3; ++k)
                        indices[index_offset++] = pLong[k] + static_cast<unsigned long>(offset);
        else
                for (size_t k = 0; k < numTris*3; ++k)
                        indices[index_offset++] = static_cast<unsigned long>(pShort[k]) + static_cast<unsigned long>(offset);

        ibuf->unlock();
        current_offset = next_offset;
}

Ogre::Vector3 SRaycast::GetBarycentricCoordinates(const Ogre::Vector3& P1, const Ogre::Vector3& P2, const Ogre::Vector3& P3, const Ogre::Vector3& P)
{
  Ogre::Vector3 coordinates(0.0);
        Ogre::Real denom = (-P1.x * P3.y - P2.x * P1.y + P2.x * P3.y + P1.y * P3.x + P2.y * P1.x - P2.y * P3.x);
        if(fabs(denom) >= 1e-6) 
        {
                coordinates.x = (P2.x * P3.y - P2.y * P3.x - P.x * P3.y + P3.x * P.y - P2.x * P.y + P2.y * P.x) / denom;
                coordinates.y = -(-P1.x * P.y + P1.x * P3.y + P1.y * P.x - P.x * P3.y + P3.x * P.y - P1.y * P3.x) / denom;
        }
        else
        {
                denom = (-P1.x * P3.z - P2.x * P1.z + P2.x * P3.z + P1.z * P3.x + P2.z * P1.x - P2.z * P3.x);
                if(fabs(denom) >= 1e-6) 
                {
                        coordinates.x = (P2.x * P3.z - P2.z * P3.x - P.x * P3.z + P3.x * P.z - P2.x * P.z + P2.z * P.x) / denom;
                        coordinates.y = -(-P1.x * P.z + P1.x * P3.z + P1.z * P.x - P.x * P3.z + P3.x * P.z - P1.z * P3.x) / denom;
                }
                else
                {
                        denom = (-P1.y * P3.z - P2.y * P1.z + P2.y * P3.z + P1.z * P3.y + P2.z * P1.y - P2.z * P3.y);
                        if(fabs(denom) >= 1e-6) 
                        {
                                coordinates.x = (P2.y * P3.z - P2.z * P3.y - P.y * P3.z + P3.y * P.z - P2.y * P.z + P2.z * P.y) / denom;
                                coordinates.y = -(-P1.y * P.z + P1.y * P3.z + P1.z * P.y - P.y * P3.z + P3.y * P.z - P1.z * P3.y) / denom;
                        }
                }
        }
        coordinates.z = 1 - coordinates.x - coordinates.y;
        return coordinates;
}

}

---