Ogre射线精确查询

女爷i 2022-10-01 03:48 188阅读 0赞

bool PickEntity(Ogre::RaySceneQuery\* mRaySceneQuery, Ogre::Ray &ray, Ogre::Entity \*\*result, Ogre::uint32 mask ,Ogre::Vector3 &hitpoint, bool excludeInVisible,const Ogre::String& excludeobject, Ogre::Real max\_distance)  
\{  
mRaySceneQuery->setRay(ray);  
mRaySceneQuery->setQueryMask(mask);  
mRaySceneQuery->setQueryTypeMask(Ogre::SceneManager::ENTITY\_TYPE\_MASK);  
mRaySceneQuery->setSortByDistance(true);  
  
if (mRaySceneQuery->execute().size() <= 0) return (false);  
  
// at this point we have raycast to a series of different objects bounding boxes.  
// we need to test these different objects to see which is the first polygon hit.  
// there are some minor optimizations (distance based) that mean we wont have to  
// check all of the objects most of the time, but the worst case scenario is that  
// we need to test every triangle of every object.  
Ogre::Real closest\_distance = max\_distance;  
Ogre::Vector3 closest\_result;  
Ogre::RaySceneQueryResult &query\_result = mRaySceneQuery->getLastResults();  
for (size\_t qr\_idx = 0; qr\_idx < query\_result.size(); qr\_idx++)  
\{  
// stop checking if we have found a raycast hit that is closer  
// than all remaining entities  
if ((closest\_distance >= 0.0f) && (closest\_distance < query\_result\[qr\_idx\].distance))  
\{  
break;  
\}  
  
// only check this result if its a hit against an entity  
if ((query\_result\[qr\_idx\].movable != NULL) && (query\_result\[qr\_idx\].movable->getMovableType().compare("Entity") == 0))  
\{  
// get the entity to check  
Ogre::Entity \*pentity = static\_cast<Ogre::Entity\*>(query\_result\[qr\_idx\].movable);  
  
if(excludeInVisible)  
if (!pentity->getVisible())  
continue;  
if(pentity->getName() == excludeobject)  
continue;  
  
// mesh data to retrieve  
size\_t vertex\_count;  
size\_t index\_count;  
Ogre::Vector3 \*vertices;  
unsigned long \*indices;  
  
// get the mesh information  
GetMeshInformationEx(pentity->getMesh(), vertex\_count, vertices, index\_count, indices,  
pentity->getParentNode()->\_getDerivedPosition(),  
pentity->getParentNode()->\_getDerivedOrientation(),  
pentity->getParentNode()->\_getDerivedScale());  
   
//maybe there is a bug in GetMeshInformationEx(),when mesh is a line or a circle, the vertex\_count is not multiple of 3  
//            if (index\_count%3 != 0)  
//            \{  
//                index\_count-=index\_count%3;  
//            \}  
  
// 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, true);  
  
// if it was a hit check if its the closest  
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;  
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)  
\{  
closest\_result = ray.getPoint(closest\_distance);  
(\*result) = pentity;  
\}  
\}  
\}  
  
// return the result  
if (closest\_distance != max\_distance)  
\{  
hitpoint = closest\_result;  
return true;  
\}  
else  
\{  
// raycast failed  
return false;  
\}  
\}  
  
void GetMeshInformationEx(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);  
  
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;  
\}  
\}  
  
使用时用如下代码即可（可能需要根据实际情况有所改动）：  
Entity\* rayResult=NULL;  
Vector3 hitPoint;  
CEGUI::Point mousePos= CEGUI::MouseCursor::getSingleton().getPosition();  
Ray mouseRay = mCamera->getCameraToViewportRay(mousePos.d\_x/float(e.state.width),mousePos.d\_y/float(e.state.height));  
RaySceneQuery\* rayQuery=mSceneMgr->createRayQuery(Ray());  
if (PickEntity(rayQuery,mouseRay,&rayResult,QF\_moveable\_object,hitPoint,true))  
rayResult->getParentSceneNode(); //find a entity  
以上源码参考Ogitor，为了配合自己的程序，稍有改动。  
为了方便大家，所以贴出来，建议大家直接看Ogitor源码。  
  
//暂时放着，代码没有测试过！  
  
  
  
  
gre碰撞检测，精确到物体网格三角面  
    我们课程的期末项目是做一个蚊子吸血的三维游戏。由于蚊子的体积很小，并且蚊子需要在三维场景中穿梭飞行。因此常规的模型包围盒检测便显得有些不足。例如，场景中有一个台灯，从模型的包围盒看，台灯是一个长方体，如果按照这样来做碰撞检测，那么蚊子便无法从台灯的长长的弧形躯干形成的拱桥洞中飞过去，尽管看起来蚊子确实没有撞到台灯。这在现实中是让人无法接受的。  
    我曾经尝试了几种方法，一种是用从蚊子出发的指向各个方向的几条射线来检测碰撞，另一种是用一个球体包围蚊子，然后检测球体中的物体个数来检测碰撞。但最终都失败了，其本质的原因还是因为，这些碰撞只能检测到和模型包围盒的交点。  
    看来，必须要寻找更好的解决方案。  
    很幸运，我找到一个第三方的开源库，叫做  Minimal Ogre Collision  。可以在http://www.ogre3d.org/wiki/index.php/Minimal\_Ogre\_Collision上找到它。  
    我决定把其中最核心的一段代码挑出来，详细解读。  
//ray，求交射线；result,与模型面片的交点；target，相交物体；closest\_distance，距离最近交点的距离；queryMask，碰撞检测掩码  
bool CollisionTools::raycast(const Ogre::Ray &ray, Ogre::Vector3 &result,Ogre::MovableObject\* &target,float &closest\_distance, const Ogre::uint32 queryMask)  
\{  
 target = NULL;  
    // 测试射线是否有效  
    if (mRaySceneQuery != NULL)  
    \{  
        // 创建一个射线查询  
  mRaySceneQuery->setRay(ray);  
  mRaySceneQuery->setSortByDistance(true);//查询结果按距离排序  
  mRaySceneQuery->setQueryMask(queryMask);//设置掩码  
        // 执行查询  
        if (mRaySceneQuery->execute().size() <= 0)  
        \{  
            return (false);  
        \}  
    \}  
    else  
    \{  
        //LOG\_ERROR << "Cannot raycast without RaySceneQuery instance" << ENDLOG;  
        return (false);  
    \}  
    // 注意哦，到这里我们已经得到一系列按照包围盒检测到的模型了.  
    // 我们要找到第一个相交的物体.  
    // 这就意味着我们不必去检测后面的物体了，这样大大节省了时间  
    // 但是很遗憾，我们不得不遍历每一个物体的三角面，听起来是多么痛苦，必须得忍  
    //  
    //初始化最小距离为-1  
 closest\_distance = -1.0f;  
    Ogre::Vector3 closest\_result;  
    Ogre::RaySceneQueryResult &query\_result = mRaySceneQuery->getLastResults();//取回刚才查询的结果，因为之前并没有保存  
    for (size\_t qr\_idx = 0; qr\_idx < query\_result.size(); qr\_idx++)  
    \{  
        // 如果下一个碰撞物体比这个还远，当然要无视啦          
        if ((closest\_distance >= 0.0f) &&  
            (closest\_distance < query\_result\[qr\_idx\].distance))  
        \{  
            break;  
        \}  
        // 我们只关心碰撞的东西是个物体  
        if ((query\_result\[qr\_idx\].movable != NULL)  &&  
            (query\_result\[qr\_idx\].movable->getMovableType().compare("Entity") == 0))  
        \{  
            // 取得被碰撞的物体  
            Ogre::MovableObject \*pentity = static\_cast<Ogre::MovableObject\*>(query\_result\[qr\_idx\].movable);  
            // 顶点是顶点，索引是索引，不着急，往下看  
            size\_t vertex\_count;  
            size\_t index\_count;  
            Ogre::Vector3 \*vertices;  
            Ogre::uint32 \*indices;  
            // 下面的函数得到模型的详细信息  
   GetMeshInformation(((Ogre::Entity\*)pentity)->getMesh(), vertex\_count, vertices, index\_count, indices,  
                              pentity->getParentNode()->\_getDerivedPosition(),  
                              pentity->getParentNode()->\_getDerivedOrientation(),  
                              pentity->getParentNode()->\_getDerivedScale());  
            // 再次注意了，下面求每一个三角面的交点，同样记录最近点  
            bool new\_closest\_found = false;  
            for (size\_t i = 0; i < index\_count; i += 3)  
            \{  
                // 下面的函数求一条射线与三角面的交点，返回一个pair，《是否相交，距离交点距离》  
                std::pair<bool, Ogre::Real> hit = Ogre::Math::intersects(ray, vertices\[indices\[i\]\],  
                    vertices\[indices\[i+1\]\], vertices\[indices\[i+2\]\], true, false);//知道索引干嘛用的了吧，索引乃顶点之索引也  
                // 如果碰撞，检查是否是当前最小距离  
                if (hit.first)  
                \{  
                    if ((closest\_distance < 0.0f) ||  
                        (hit.second < closest\_distance))  
                    \{  
                        // 如果是则更新  
                        closest\_distance = hit.second;  
                        new\_closest\_found = true;  
                    \}  
                \}  
            \}  
   // 释放刚才申请的内存，这种东西当然是在写申请的时候就要成对编写的了，正如同时写下\{\}  
            delete\[\] vertices;  
            delete\[\] indices;  
            //如果找到新的点，不要忘了更新相应信息  
            if (new\_closest\_found)  
            \{  
                target = pentity;  
                closest\_result = ray.getPoint(closest\_distance);//最近点的计算，简单的线性方程  
            \}  
        \}  
    \}  
    // 返回结果  
    if (closest\_distance >= 0.0f)  
    \{  
        // 成功了  
        result = closest\_result;  
        return (true);  
    \}  
    else  
    \{  
        //失败了  
        return (false);  
    \}  
\}