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) 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 "SO3Utils/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;
  indexSubEntity = -1;
 
  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(0.0f, 0.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;
  indexSubEntity = copiedRaycast.indexSubEntity;
  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
}
 
void SRaycast::GetMeshInformation(const Ogre::MeshPtr mesh,
  size_t &vertex_count,
  Ogre::Vector3* &vertices,
  size_t &index_count,
  unsigned long* &indices,
  const Ogre::Vector3 &position,
  const Ogre::Quaternion &orient,
  const Ogre::Vector3 &scale)
{
  bool added_shared = false;
  size_t current_offset = 0;
  size_t shared_offset = 0;
  size_t next_offset = 0;
  size_t index_offset = 0;
 
  vertex_count = index_count = 0;
 
  // Calculate how many vertices and indices we're going to need
  for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
  {
    Ogre::SubMesh* submesh = mesh->getSubMesh(i);
    // We only need to add the shared vertices once
    if (submesh->useSharedVertices)
    {
      if (!added_shared)
      {
        vertex_count += mesh->sharedVertexData->vertexCount;
        added_shared = true;
      }
    }
    else
    {
      vertex_count += submesh->vertexData->vertexCount;
    }
    // Add the indices
    index_count += submesh->indexData->indexCount;
  }
 
  // Allocate space for the vertices and indices
  vertices = new Ogre::Vector3[vertex_count];
  indices = new unsigned long[index_count];
 
  added_shared = false;
 
  // Run through the submeshes again, adding the data into the arrays
  for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
  {
    Ogre::SubMesh* submesh = mesh->getSubMesh(i);
 
    Ogre::VertexData* vertex_data = submesh->useSharedVertices ? mesh->sharedVertexData : submesh->vertexData;
 
    if ((!submesh->useSharedVertices) || (submesh->useSharedVertices && !added_shared))
    {
      if (submesh->useSharedVertices)
      {
        added_shared = true;
        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));
 
      // There is _no_ baseVertexPointerToElement() which takes an Ogre::Real or a double
      //  as second argument. So make it float, to avoid trouble when Ogre::Real will
      //  be comiled/typedefed as double:
      //Ogre::Real* pReal;
      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;
    }
 
    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);    
    size_t offset = (submesh->useSharedVertices) ? shared_offset : current_offset;
 
    if (use32bitindexes)
    {
      Ogre::uint32* pLong = static_cast<Ogre::uint32*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      for (size_t k = 0; k < numTris * 3; ++k)
      {
        indices[index_offset++] = pLong[k] + static_cast<unsigned long>(offset);
      }
    }
    else
    {
      Ogre::uint16* pShort = static_cast<Ogre::uint16*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      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;
  }
}
 
SRaycastResult SRaycast::Cast(SCamera* camera, const float& relativePosX, const float& relativePosY, Ogre::SubEntity* subEntity, bool getUvCoordonate)
{
  SRaycastResult results = Cast(camera->GetOgreCameraPointer(), relativePosX, relativePosY, subEntity, getUvCoordonate);
  results.viewport = camera->getCurrentViewPort();
 
  return results;
}
 
SRaycastResult SRaycast::Cast(Ogre::Camera* camera, const float& relativePosX, const float& relativePosY, Ogre::SubEntity* subEntity, bool getUvCoordonate)
{
  // Our return struct.
  SRaycastResult results;
  
  if (!subEntity)
    return results;
 
  Ogre::Any bindedCustomEntity = subEntity->getUserObjectBindings().getUserAny("SEntity");
 
  assert(bindedCustomEntity.has_value());
  results.entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
  results.entityName = results.entity->GetName();
  results.scene = results.entity->GetParentScene();
  results.sceneName = results.scene->GetName();
  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->getCameraToViewportRay(fabs(relativePosX), fabs(relativePosY));
 
  // Then, pseudo ray cast to the polygon level.
  float closest_distance = -1.0f;
  Ogre::SubMesh* submesh = subEntity->getSubMesh();
 
  Ogre::RenderOperation tmpRenderOperation;
        submesh->_getRenderOperation(tmpRenderOperation);
  if (tmpRenderOperation.operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST)
  {
    // Count vertexes
    size_t vertex_count = 0;
    if (submesh->useSharedVertices)
      vertex_count = submesh->parent->sharedVertexData->vertexCount;
    else
      vertex_count = submesh->vertexData->vertexCount;
 
    // Count indices
    size_t index_count = submesh->indexData->indexCount;
    unsigned long* indices = new unsigned long[index_count];
 
    // 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);
 
    size_t index_offset = 0;
    if (use32bitindexes)
    {
      Ogre::uint32* pLong = static_cast<Ogre::uint32*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      for (size_t k = 0; k < numTris * 3; ++k)
        indices[index_offset++] = pLong[k];
    }
    else
    {
      Ogre::uint16* pShort = static_cast<Ogre::uint16*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      for (size_t k = 0; k < numTris * 3; ++k)
        indices[index_offset++] = static_cast<unsigned long>(pShort[k]);
    }
    ibuf->unlock();
 
    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();
 
    int closestVerticeIndex = 0;
 
    // 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()->getPoseList().size() == 0))
      vertex_data = submesh->useSharedVertices ? parentEntity->_getSoftwareVertexAnimVertexData() : subEntity->_getSoftwareVertexAnimVertexData();
    else
      vertex_data = submesh->useSharedVertices ? submesh->parent->sharedVertexData : submesh->vertexData;
 
    const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
    Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
    if (!vbuf->isLocked())
    {
      unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      
      for (int j = 0; j < static_cast<int>(index_count); j += 3)
      {
        float* pReal1;
        float* pReal2;
        float* pReal3;
        posElem->baseVertexPointerToElement(vertex + indices[j] * vbuf->getVertexSize(), &pReal1);
        posElem->baseVertexPointerToElement(vertex + indices[j + 1] * vbuf->getVertexSize(), &pReal2);
        posElem->baseVertexPointerToElement(vertex + indices[j + 2] * vbuf->getVertexSize(), &pReal3);
 
        Ogre::Vector3 pt1(pReal1[0], pReal1[1], pReal1[2]);
        Ogre::Vector3 pt2(pReal2[0], pReal2[1], pReal2[2]);
        Ogre::Vector3 pt3(pReal3[0], pReal3[1], pReal3[2]);
        pt1 = (orient * (pt1 * scale)) + position;
        pt2 = (orient * (pt2 * scale)) + position;
        pt3 = (orient * (pt3 * scale)) + position;
 
        std::pair<bool, Ogre::Real> hit = Ogre::Math::intersects(ray, pt1, pt2, pt3, 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 = pt1;
            results.v2 = pt2;
            results.v3 = pt3;
            results.point = ray.getPoint(hit.second);
          }
        }
      }
      vbuf->unlock();
      results.closestDistance = closest_distance;
 
      // Get hit point uv coordinates, see the end of this page for an explanation: http://www.blackpawn.com/texts/pointinpoly/default.html
      if (getUvCoordonate)
      {
        Ogre::VertexData* vertex_data = submesh->useSharedVertices ? submesh->parent->sharedVertexData : submesh->vertexData;
        const Ogre::VertexElement* vertex_element = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
        if (vertex_data->vertexDeclaration->getElementCount() > 2)
        {
          float* pReal1;
          float* pReal2;
          float* pReal3;
 
          Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(vertex_element->getSource());
          unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
 
          vertex_element->baseVertexPointerToElement(vertex + indices[closestVerticeIndex] * vbuf->getVertexSize(), &pReal1);
          vertex_element->baseVertexPointerToElement(vertex + indices[closestVerticeIndex + 1] * vbuf->getVertexSize(), &pReal2);
          vertex_element->baseVertexPointerToElement(vertex + indices[closestVerticeIndex + 2] * vbuf->getVertexSize(), &pReal3);
 
          vbuf->unlock();
 
          // Get face points uvs
          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];
 
          // Compute vectors 
          Ogre::Vector3 v0 = results.v3 - results.v1;
          Ogre::Vector3 v1 = results.v2 - results.v1;
          Ogre::Vector3 v2 = results.point - results.v1;
 
          // Compute dot products
          float dot00 = v0.dotProduct(v0);
          float dot01 = v0.dotProduct(v1);
          float dot02 = v0.dotProduct(v2);
          float dot11 = v1.dotProduct(v1);
          float dot12 = v1.dotProduct(v2);
 
          // Compute barycentric coordinates
          float invDenom = 1.0f / (dot00 * dot11 - dot01 * dot01);
          float u = (dot11 * dot02 - dot01 * dot12) * invDenom;
          float v = (dot00 * dot12 - dot01 * dot02) * invDenom;
 
          // Compute uv range
          Ogre::Vector2 t2 = results.pReal2 - results.pReal1;
          Ogre::Vector2 t1 = results.pReal3 - results.pReal1;
 
          // Finally, store uv coordinates of our point
          results.uvResult = results.pReal1 + t1*u + t2*v;
        }
      }
 
      delete[] indices;
    }
  }
 
  return results;
}
 
SRaycastResult SRaycast::Cast(SScene* sm, Ogre::Vector3 pos, Ogre::Vector3 dir, Ogre::Real maxdist, bool getUvCoordonate)
{
  // Our return struct.
  SRaycastResult results;
  Ogre::RaySceneQuery* rq = sm->GetRayquery();
  Ogre::Ray ray = Ogre::Ray(pos, dir);
  rq->setRay(ray);
 
  if (rq->execute().size() <= 0)
  {
    // raycast did not hit an objects bounding box
    return results;
  }
 
  Ogre::Real closestDist = -1.0f;
  Ogre::Vector3 closestResult;
  Ogre::RaySceneQueryResult queryResult = rq->getLastResults();
  bool toofar = false;
  for (size_t qr_idx = 0; qr_idx < queryResult.size(); qr_idx++)
  {
    // stop checking if we have found a raycast hit that is closer
    // than all remaining entities
    if (((closestDist >= 0.0f) && (closestDist < queryResult[qr_idx].distance)) || closestDist >= maxdist)
    {
      if (closestDist >= maxdist)
        toofar = true;
      break;
    }
 
    // only check this result if its a hit against an entity
    if ((queryResult[qr_idx].movable != NULL) && (queryResult[qr_idx].movable->getMovableType().compare("Entity") == 0))
    {
      // get the entity to check
      Ogre::Entity *pentity = static_cast<Ogre::Entity*>(queryResult[qr_idx].movable);
 
      // mesh data to retrieve         
      size_t vertex_count;
      size_t index_count;
      Ogre::Vector3 *vertices;
      unsigned long *indices;
 
      // get the mesh information
      GetMeshInformation(pentity->getMesh(), vertex_count, vertices, index_count, indices,
        pentity->getParentNode()->_getDerivedPosition(),
        pentity->getParentNode()->_getDerivedOrientation(),
        pentity->getParentNode()->_getDerivedScale());
 
      // test for hitting individual triangles on the mesh
      bool new_closest_found = false;
      for (int i = 0; i < static_cast<int>(index_count); i += 3)
      {
        // check for a hit against this triangle
        std::pair<bool, Ogre::Real> hit = Ogre::Math::intersects(ray, vertices[indices[i]],
          vertices[indices[i + 1]], vertices[indices[i + 2]], true, false);
 
        // if it was a hit check if its the closest
        if (hit.first)
        {
          if ((closestDist < 0.0f) || (hit.second < closestDist))
          {
            // this is the closest so far, save it off
            closestDist = hit.second;
            new_closest_found = true;
 
          }
        }
      }
 
      // free the verticies and indicies memory
      delete[] vertices;
      delete[] indices;
 
      // if we found a new closest raycast for this object, update the
      // closest_result before moving on to the next object.
      if (new_closest_found)
      {
        closestResult = ray.getPoint(closestDist);
      }
    }
  }
 
  // return the result
  if ((closestDist >= 0.0f) && !toofar)
  {
    // raycast success
    results.point = closestResult;
    results.closestDistance = closestDist;
  }
 
  /*
  // 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 = sm;
  results.sceneName = sm->GetName();
  results.viewport = NULL;
  results.material = sm->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;
 
 
  // 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;
 
    // Get hit point uv coordinates, see the end of this page for an explanation: http://www.blackpawn.com/texts/pointinpoly/default.html
    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)
      {
        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();
 
        // Get face points uvs
        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];
 
        // Compute vectors 
        Ogre::Vector3 v0 = results.v3 - results.v1;
        Ogre::Vector3 v1 = results.v2 - results.v1;
        Ogre::Vector3 v2 = results.point - results.v1;
 
        // Compute dot products
        float dot00 = v0.dotProduct(v0);
        float dot01 = v0.dotProduct(v1);
        float dot02 = v0.dotProduct(v2);
        float dot11 = v1.dotProduct(v1);
        float dot12 = v1.dotProduct(v2);
 
        // Compute barycentric coordinates
        float invDenom = 1.0f / (dot00 * dot11 - dot01 * dot01);
        float u = (dot11 * dot02 - dot01 * dot12) * invDenom;
        float v = (dot00 * dot12 - dot01 * dot02) * invDenom;
 
        // Compute uv range
        Ogre::Vector2 t2 = results.pReal2 - results.pReal1;
        Ogre::Vector2 t1 = results.pReal3 - results.pReal1;
 
        // Finally, store uv coordinates of our point
        results.uvResult = results.pReal1 + t1*u + t2*v;
      }
    }
  }
  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 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()->getPoseList().size() == 0))
                vertex_data = submesh->useSharedVertices ? parentEntity->_getSoftwareVertexAnimVertexData() : subEntity->_getSoftwareVertexAnimVertexData();
        else
    vertex_data = submesh->useSharedVertices ? submesh->parent->sharedVertexData : submesh->vertexData;
 
  const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
        Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
  if(!vbuf->isLocked())
  {
    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[j] = (orient * (pt * scale)) + position;
          }
          vbuf->unlock();
 
    // 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);
          Ogre::uint32*  pLong = static_cast<Ogre::uint32*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
    if (use32bitindexes)
    {
      Ogre::uint32* pLong = static_cast<Ogre::uint32*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      for (size_t k = 0; k < numTris * 3; ++k)
        indices[index_offset++] = pLong[k];
    }
    else
    {
      Ogre::uint16* pShort = static_cast<Ogre::uint16*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
      for (size_t k = 0; k < numTris * 3; ++k)
        indices[index_offset++] = static_cast<unsigned long>(pShort[k]);
    }
          ibuf->unlock();
  }
}
 
}