1. void Sprite3DWithOBBPerfromanceTest::onTouchesBegan(const std::vector<Touch*>& touches, Event* event)  
2. {  
3.     for (auto touch: touches)  
4.     {  
5.         auto location = touch->getLocationInView(); 
6.   
7.         if(_obb.size() > 0) 
8.         {  
9.             _intersetList.clear();  
10.             Ray ray;  
11.             
12.             calculateRayByLocationInView(&ray,location);  
13.               
14.             for(int i = 0; i < _obb.size(); i++)  
15.             {  
16.                 if(ray.intersects(_obb[i])) 
17.                 {  
18.                     _intersetList.insert(i);   
19.                     return;  
20.                 }  
21.             }  
22.         }  
23.     }  
24. }  

2. void Sprite3DWithOBBPerfromanceTest::unproject(const Mat4& viewProjection, const Size* viewport, Vec3* src, Vec3* dst)  
3. {  
4.     assert(dst);  
5.       
6.     assert(viewport->width != 0.0f && viewport->height != 0.0f);  
7.       
8.     
9.     Vec4 screen(src->x / viewport->width, ((viewport->height - src->y)) / viewport->height, src->z, 1.0f);  
10.       
11.     screen.x = screen.x * 2.0f - 1.0f;  
12.     screen.y = screen.y * 2.0f - 1.0f;  
13.     screen.z = screen.z * 2.0f - 1.0f;  
14.       
15.     
16.     viewProjection.getInversed().transformVector(screen, &screen);  
17.       
18.     
19.     if (screen.w != 0.0f)  
20.     {  
21.         screen.x /= screen.w;  
22.         screen.y /= screen.w;  
23.         screen.z /= screen.w;  
24.     }  
25.     
26.     dst->set(screen.x, screen.y, screen.z);  
27. }  
29. void Sprite3DWithOBBPerfromanceTest::calculateRayByLocationInView(Ray* ray, const Vec2& location)  
30. {  
31.     auto dir = Director::getInstance();  
32.     auto view = dir->getWinSize(); 
33.     Mat4 mat = dir->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);  
34.     
35.     mat = dir->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);  
36.   
37.     Vec3 src = Vec3(location.x, location.y, -1);  
38.     Vec3 nearPoint; 
39.     unproject(mat, &view, &src, &nearPoint);
40.       
41.     src = Vec3(location.x, location.y, 1);  
42.     Vec3 farPoint; 
43.     unproject(mat, &view, &src, &farPoint);
44.       
45.     Vec3 direction; 
46.     Vec3::subtract(farPoint, nearPoint, &direction); 
47.     direction.normalize(); 
48.   
49.     ray->_origin = nearPoint;  
50.     ray->_direction = direction; 
51. }  

1. bool Ray::intersects(const AABB& aabb) const  
2. {  
3.     Vec3 ptOnPlane; 
4.     Vec3 min = aabb._min; 
5.     Vec3 max = aabb._max; 
6.       
7.     const Vec3& origin = _origin; 
8.     const Vec3& dir = _direction; 
9.       
10.     float t;  
11.       
12.     
13.       
14.     
15.     if (dir.x != 0.f) 
16.     {  
17.         
20.         if (dir.x > 0)
21.             t = (min.x - origin.x) / dir.x;  
22.         else  
23.             t = (max.x - origin.x) / dir.x;  
24.           
25.         if (t > 0.f) 
26.         {  
27.             ptOnPlane = origin + t * dir; 
28.             
29.             if (min.y < ptOnPlane.y && ptOnPlane.y < max.y && min.z < ptOnPlane.z && ptOnPlane.z < max.z)  
30.             {  
31.                 return true; 
32.             }  
33.         }  
34.     }  
35.       
36.     
37.     if (dir.y != 0.f)  
38.     {  
39.         if (dir.y > 0)  
40.             t = (min.y - origin.y) / dir.y;  
41.         else  
42.             t = (max.y - origin.y) / dir.y;  
43.           
44.         if (t > 0.f)  
45.         {  
46.             ptOnPlane = origin + t * dir;  
47.   
48.             if (min.z < ptOnPlane.z && ptOnPlane.z < max.z && min.x < ptOnPlane.x && ptOnPlane.x < max.x)  
49.             {  
50.                 return true;  
51.             }  
52.         }  
53.     }  
54.       
55.     
56.     if (dir.z != 0.f)  
57.     {  
58.         if (dir.z > 0)  
59.             t = (min.z - origin.z) / dir.z;  
60.         else  
61.             t = (max.z - origin.z) / dir.z;  
62.           
63.         if (t > 0.f)  
64.         {  
65.             ptOnPlane = origin + t * dir;  
66.               
67.             if (min.x < ptOnPlane.x && ptOnPlane.x < max.x && min.y < ptOnPlane.y && ptOnPlane.y < max.y)  
68.             {  
69.                 return true;  
70.             }  
71.         }  
72.     }  
73.       
74.     return false;  
75. }  

原文：http://blog.csdn.net/u012945598/article/details/39927911