Ogre中精确到三角面的碰撞检测（使用射线查询）

最新推荐文章于 2021-08-21 12:56:48 发布
最新推荐文章于 2021-08-21 12:56:48 发布
阅读量610 收藏
点赞数 1


2014
04-04

Ogre中精确到三角面的碰撞检测（使用射线查询）

 Jianchihu  编程之美  围观1238次  留下评论  编辑日期：2015-11-13  字体：大 中 小

Ogre中的射线查询一般只能侦测到边界盒（AABB）,就像你在下面图片看到的，使用下面的代码就能避免这些。

Ogre中精确到三角面的碰撞检测（使用射线查询） - 第1张 | Jianchihu

初始化射线查询：

1
2
3
4
5
6
7
8
// create the ray scene query object
     m_pray_scene_query = m_pscene_manager -> createRayQuery ( Ogre :: Ray ( ) , Ogre :: SceneManager :: WORLD_GEOMETRY_TYPE_MASK ) ;
     if ( NULL == m_pray_scene_query )
     {
         LOG_ERROR << "Failed to create Ogre::RaySceneQuery instance" << ENDLOG ;
       return ( false ) ;
     }
     m_pray_scene_query -> setSortByDistance ( true ) ;

射线投射：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// raycast from a point in to the scene.
// returns success or failure.
// on success the point is returned in the result.
bool OgreVisionEngine :: RaycastFromPoint ( const Vector3 & point ,
                                         const Vector3 & normal ,
                                         Vector3 & result )
{
     // create the ray to test
     Ogre :: Ray ray ( Ogre :: Vector3 ( point . x , point . y , point . z ) ,
                   Ogre :: Vector3 ( normal . x , normal . y , normal . z ) ) ;
     // check we are initialised
     if ( m_pray_scene_query != NULL )
     {
         // create a query object
         m_pray_scene_query -> setRay ( ray ) ;
         // execute the query, returns a vector of hits
         if ( m_pray_scene_query -> execute ( ) . size ( ) <= 0 )
         {
             // raycast did not hit an objects bounding box
             return ( false ) ;
         }
     }
     else
     {
         LOG_ERROR << "Cannot raycast without RaySceneQuery instance" << ENDLOG ;
         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 = - 1.0f ;
     Ogre :: Vector3 closest_result ;
     Ogre :: RaySceneQueryResult & query_result = m_pray_scene_query -> 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 ) ;           
             // mesh data to retrieve        
             size_t vertex_count ;
             size_t index_count ;
             Ogre :: Vector3 * vertices ;
             unsigned long * indices ;
             // get the mesh information
         OgreVE :: GetMeshInformation ( pentity -> getMesh ( ) , vertex_count , vertices , index_count , indices ,             
                               pentity -> getParentNode ( ) -> getWorldPosition ( ) ,
                               pentity -> getParentNode ( ) -> getWorldOrientation ( ) ,
                               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 ( ( 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 ) ;               
             }
         }       
     }
     // return the result
     if ( closest_distance >= 0.0f )
     {
         // raycast success
         result = closest_result ;
         return ( true ) ;
     }
     else
     {
         // raycast failed
         return ( false ) ;
     }
}

得到网格信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
// Get the mesh information for the given mesh.
// Code found in Wiki: www.ogre3d.org/wiki/index.php/RetrieveVertexData
void OgreVE :: 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 ;
         if ( ibuf . isNull ( ) ) continue ; // need to check if index buffer is valid (which will be not if the mesh doesn't have triangles like a pointcloud)
         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 ;
         size_t index_start = index_data -> indexStart ;
         size_t last_index = numTris* 3 + index_start ;
         if ( use32bitindexes )
             for ( size _t k = index_start ; k < last_index ; ++ k )
             {
                 indices [ index_offset ++ ] = pLong [ k ] + static_cast < unsigned long > ( offset ) ;
             }
         else
             for ( size _t k = index_start ; k < last_index ; ++ k )
             {
                 indices [ index_offset ++ ] = static_cast < unsigned long > ( pShort [ k ] ) +
                     static_cast < unsigned long > ( offset ) ;
             }
         ibuf -> unlock ( ) ;
         current_offset = next_offset ;
     }
}

如果要考虑对处于运动状态物体做碰撞检测，可使用如下的得到网格信息代码（如果运动物体使用硬件蒙皮下面代码会出问题）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
void GetMeshInformation ( const Entity * entity ,
                                 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 ;
   Ogre :: MeshPtr mesh = entity -> getMesh ( ) ;
   bool useSoftwareBlendingVertices = entity -> hasSkeleton ( ) ;
   if ( useSoftwareBlendingVertices )
   {
       entity -> _updateAnimation ( ) ;
   }
     // 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 ) ;
       //----------------------------------------------------------------
       // GET VERTEXDATA
       //----------------------------------------------------------------
         //Ogre::VertexData* vertex_data = submesh->useSharedVertices ? mesh->sharedVertexData : submesh->vertexData;
       Ogre :: VertexData* vertex_data ;
       //When there is animation:
       if ( useSoftwareBlendingVertices )
         vertex_data = submesh -> useSharedVertices ? entity -> _getSkelAnimVertexData ( ) : entity -> getSubEntity ( i ) -> _getSkelAnimVertexData ( ) ;
       else
         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 ;
         size_t index_start = index_data -> indexStart ;
         size_t last_index = numTris* 3 + index_start ;
         if ( use32bitindexes )
             for ( size _t k = index_start ; k < last_index ; ++ k )
             {
                 indices [ index_offset ++ ] = pLong [ k ] + static_cast < unsigned long > ( offset ) ;
             }
         else
             for ( size _t k = index_start ; k < last_index ; ++ k )
             {
                 indices [ index_offset ++ ] = static_cast < unsigned long > ( pShort [ k ] ) +
                     static_cast < unsigned long > ( offset ) ;
             }
         ibuf -> unlock ( ) ;
         current_offset = next_offset ;
     }
}

总的原理是进行射线查询，然后获取模型mesh顶点与索引信息，将每三个顶点构成一个三角面，将定义好的射线与这些三角面进行相交，得到距离最近的交点，射线发射点与该交点距离即为最近距离，最后返回该最近距离。

具体代码使用大家可以参考MOC这个轻量级的碰撞检测库，官网上有示例，可以很容易的掌握。

 
yangchuangbao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OGRE射线碰撞检测精确到三角面
08-16
OGRE射线碰撞检测精确到三角面 里面有说明加源码 重要函数都写出来了、数学好的应该看懂
在ogre中进行精细射线检测
limiteee的专栏
01-24 2514
 ogre有一个RaySceneQuery的类，在默认场景管理器下，这个类返回一组RaySceneQueryResultEntry，他们都是通过包围盒进行的检测，由于包围盒过于简陋，我们可以再进行更精细的基于面的射线碰撞检测。主要注意的就是mesh的构造方式，是否用了index，index是16位还是32位，其他的没什么了，射线到三角的检测函数取自dx例子，ogre自己也提供了，不过我感觉
Ogre中的碰撞检测
痞子龙3D编程
03-12 4321
基于射线查询的方式，实现摄像机和地形的碰撞检测，防止摄像机穿透地面,这也是ogre demo中Terrian例子中的方法。   首先定义 RaySceneQuery* raySceneQuery = 0; 在CreateScene时候，创建场景查询  frameRenderingQueued事件中，进行射线查询，设定摄像机位置   raySceneQuery = mSceneMgr-
OGRE碰撞检测之射线查询地形
yeazer0的专栏
12-08 2129
//场景射线类：场景射线查询，全局指针变量，RaySceneQuery* raySceneQuery = 0;//在侦听器"FrameListener"类（继承于ExampleFrameListener）中，  //在侦渲染"FreameRendering"中执行场景射线一些列动作。  //射线类 静态：用于更新射线。  static Ray updateRay;  //设置射线起点。  
Ogre中级教程（二）：射线场景查询及基础鼠标用法
神秘代码
03-27 2404
中级教程2：射线场景查询及基础鼠标用法 有关这篇教程，无论遇到任何问题，都可以到论坛发帖寻求帮助。       目录      [隐藏]        1 介绍         2 前期准备         3 开始         4 创建场景         5 帧监听器介绍         6 创建帧监听器         7 增加鼠标查看         8 地形碰撞检测        
ogre 碰撞检测
08-23
ogre 一个不错碰撞检测的例子
Ogre碰撞检测
06-03
Ogre碰撞检测技术，包括AABB，球查询等等
Ogre简单的AABB碰撞检测源码
11-07
提供给Ogre的初学者，简单的碰撞检测源代码，原理是轴对称（AABB）
ogre中文教程 ogre中文教程
12-26
ogre中文教程
三维空间中三角面片碰撞检测TTI
qq_40977737的博客
08-21 1445
三维空间中三角面片碰撞检测TTI 空间中三角面片碰撞检测，本质上是检测两个三角形面片
空间中三角形碰撞检测TTI——ESTTI.zip
08-21
用于检测空间中两个三角形面片是否发生碰撞
一个很好的碰撞检测例子（精确到球和面片）
08-31
opengl碰撞检测例子,球和三角面片的碰撞检测
三角形相交检测（碰撞）
04-22
描述了两个三角形相交的判断过程。vc++6.0界面设计。
ogre中鼠标选取
10-19
ogre中的鼠标选取实体mesh文件，形成选框
Ogre射线精确查询
苗伟业的专栏
07-15 2471
bool PickEntity(Ogre::RaySceneQuery* mRaySceneQuery, Ogre::Ray &ray, Ogre::Entity **result, Ogre::uint32 mask ,Ogre::Vector3 &hitpoint, bool
OGRE最简单的射线拾取详解
痞子龙3D编程
03-16 2874
<br />射线拾取原理是从摄像机发射一条经过鼠标位置的射线，计算射线和哪些三角形相交，然后计算这些三角形所属的场景对象（可以是Entity，Light，平面等等）<br />OGRE已经帮我们实现了基本的功能。<br />在这里实现的是最简单的鼠标射线拾取。<br />view plaincopy to clipboardprint?<br />bool GuiFrameListener::mousePressed( const OIS::MouseEvent &arg, OIS::MouseButton
碰撞检测
狼牙
12-11 989
AABB(轴对齐包围盒) 这个东西是碰撞检测的基础，和它类似的还有OBB(有向包围盒)，由于OBB创建复杂，所以Ogre采用了AABB。 最简单的碰撞检测： 通过Ogre::SceneNode::_getWorldAABB()可以取得这个叶子节点的AABB(Ogre::AxisAlignedBox)，Ogre::AxisAlignedBox封装了对AABB的支持，该类的成员函数Ogre::A
Ogre碰撞检测，精确到物体网格三角面
狼牙
06-05 1244
我们课程的期末项目是做一个蚊子吸血的三维游戏。由于蚊子的体积很小，并且蚊子需要在三维场景中穿梭飞行。因此常规的模型包围盒检测便显得有些不足。例如，场景中有一个台灯，从模型的包围盒看，台灯是一个长方体，如果按照这样来做碰撞检测，那么蚊子便无法从台灯的长长的弧形躯干形成的拱桥洞中飞过去，尽管看起来蚊子确实没有撞到台灯。这在现实中是让人无法接受的。    我曾经尝试了几种方法，一种是用从蚊子出发的指向
UPS、蓄电池、空开、电缆配置计算方法.pptx
最新发布
04-27
5G通信行业、网络优化、通信工程建设资料
怎么提取ogre中的watermesh信息
12-08
要提取Ogre中的WaterMesh信息，首先需要加载Ogre的WaterMesh组件，并确保已经在引擎中进行了正确的初始化。接下来，我们可以通过以下步骤来提取WaterMesh信息： 1. 获取场景管理器：首先需要获取Ogre的场景管理器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值