source: OGRE/trunk/ogrenew/PlugIns/OctreeSceneManager/src/OgreOctreeSceneQuery.cpp @ 657

Revision 657, 11.5 KB checked in by mattausch, 19 years ago (diff)

added ogre dependencies and patched ogre sources

Line 
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6 
7Copyright  2000-2005 The OGRE Team
8Also see acknowledgements in Readme.html
9 
10This program is free software; you can redistribute it and/or modify it under
11the terms of the GNU Lesser General Public License as published by the Free Software
12Foundation; either version 2 of the License, or (at your option) any later
13version.
14 
15This program is distributed in the hope that it will be useful, but WITHOUT
16ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 
19You should have received a copy of the GNU Lesser General Public License along with
20this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22http://www.gnu.org/copyleft/lesser.txt.
23-----------------------------------------------------------------------------
24*/
25/***************************************************************************
26OgreOctreeSceneQuery.cpp  -  description
27-------------------
28begin                : Tues July 20, 2004
29copyright            : (C) 2004by Jon Anderson
30email                : janders@users.sf.net
31 
32 
33 
34***************************************************************************/
35
36#include <OgreOctreeSceneQuery.h>
37#include <OgreOctreeSceneManager.h>
38#include <OgreEntity.h>
39
40namespace Ogre
41{
42
43//---------------------------------------------------------------------
44OctreeIntersectionSceneQuery::OctreeIntersectionSceneQuery(SceneManager* creator)
45        : DefaultIntersectionSceneQuery(creator)
46{
47
48}
49//---------------------------------------------------------------------
50OctreeIntersectionSceneQuery::~OctreeIntersectionSceneQuery()
51{}
52//---------------------------------------------------------------------
53void OctreeIntersectionSceneQuery::execute(IntersectionSceneQueryListener* listener)
54{
55    typedef std::pair<MovableObject *, MovableObject *> MovablePair;
56    typedef std::set
57        < std::pair<MovableObject *, MovableObject *> > MovableSet;
58
59    MovableSet set;
60
61    SceneManager::EntityIterator it = mParentSceneMgr->getEntityIterator();
62    while( it.hasMoreElements() )
63    {
64
65        Entity * e = it.getNext();
66
67        std::list < SceneNode * > list;
68        //find the nodes that intersect the AAB
69        static_cast<OctreeSceneManager*>( mParentSceneMgr ) -> findNodesIn( e->getWorldBoundingBox(), list, 0 );
70        //grab all moveables from the node that intersect...
71        std::list < SceneNode * >::iterator it = list.begin();
72        while( it != list.end() )
73        {
74            SceneNode::ObjectIterator oit = (*it) -> getAttachedObjectIterator();
75            while( oit.hasMoreElements() )
76            {
77                MovableObject * m = oit.getNext();
78
79                if( m != e &&
80                        set.find( MovablePair(e,m)) == set.end() &&
81                        set.find( MovablePair(m,e)) == set.end() &&
82                        (m->getQueryFlags() & mQueryMask) &&
83                                                m->isInScene() &&
84                                                e->getWorldBoundingBox().intersects( m->getWorldBoundingBox() ) )
85                {
86                    listener -> queryResult( e, m );
87                                        // deal with attached objects, since they are not directly attached to nodes
88                                        if (m->getMovableType() == "Entity")
89                                        {
90                                                Entity* e2 = static_cast<Entity*>(m);
91                                                Entity::ChildObjectListIterator childIt = e2->getAttachedObjectIterator();
92                                                while(childIt.hasMoreElements())
93                                                {
94                                                        MovableObject* c = childIt.getNext();
95                                                        if (c->getQueryFlags() & mQueryMask &&
96                                                                e->getWorldBoundingBox().intersects( c->getWorldBoundingBox() ))
97                                                        {
98                                                                listener->queryResult(e, c);
99                                                        }
100                                                }
101                                        }
102                }
103                set.insert( MovablePair(e,m) );
104
105            }
106            ++it;
107        }
108
109    }
110}
111/** Creates a custom Octree AAB query */
112OctreeAxisAlignedBoxSceneQuery::OctreeAxisAlignedBoxSceneQuery(SceneManager* creator)
113        : DefaultAxisAlignedBoxSceneQuery(creator)
114{
115}
116/** Deletes the custom Octree query */
117OctreeAxisAlignedBoxSceneQuery::~OctreeAxisAlignedBoxSceneQuery()
118{}
119
120/** Finds any entities that intersect the AAB for the query. */
121void OctreeAxisAlignedBoxSceneQuery::execute(SceneQueryListener* listener)
122{
123    std::list < SceneNode * > list;
124    //find the nodes that intersect the AAB
125    static_cast<OctreeSceneManager*>( mParentSceneMgr ) -> findNodesIn( mAABB, list, 0 );
126
127    //grab all moveables from the node that intersect...
128    std::list < SceneNode * >::iterator it = list.begin();
129    while( it != list.end() )
130    {
131        SceneNode::ObjectIterator oit = (*it) -> getAttachedObjectIterator();
132        while( oit.hasMoreElements() )
133        {
134            MovableObject * m = oit.getNext();
135            if( (m->getQueryFlags() & mQueryMask) &&
136                                m->isInScene() &&
137                                mAABB.intersects( m->getWorldBoundingBox() ) )
138            {
139                listener -> queryResult( m );
140                                // deal with attached objects, since they are not directly attached to nodes
141                                if (m->getMovableType() == "Entity")
142                                {
143                                        Entity* e = static_cast<Entity*>(m);
144                                        Entity::ChildObjectListIterator childIt = e->getAttachedObjectIterator();
145                                        while(childIt.hasMoreElements())
146                                        {
147                                                MovableObject* c = childIt.getNext();
148                                                if (c->getQueryFlags() & mQueryMask)
149                                                {
150                                                        listener->queryResult(c);
151                                                }
152                                        }
153                                }
154            }
155
156        }
157
158        ++it;
159    }
160
161}
162//---------------------------------------------------------------------
163OctreeRaySceneQuery::
164OctreeRaySceneQuery(SceneManager* creator) : DefaultRaySceneQuery(creator)
165{
166}
167//---------------------------------------------------------------------
168OctreeRaySceneQuery::~OctreeRaySceneQuery()
169{}
170//---------------------------------------------------------------------
171void OctreeRaySceneQuery::execute(RaySceneQueryListener* listener)
172{
173    std::list < SceneNode * > list;
174    //find the nodes that intersect the AAB
175    static_cast<OctreeSceneManager*>( mParentSceneMgr ) -> findNodesIn( mRay, list, 0 );
176
177    //grab all moveables from the node that intersect...
178    std::list < SceneNode * >::iterator it = list.begin();
179    while( it != list.end() )
180    {
181        SceneNode::ObjectIterator oit = (*it) -> getAttachedObjectIterator();
182        while( oit.hasMoreElements() )
183        {
184            MovableObject * m = oit.getNext();
185            if( (m->getQueryFlags() & mQueryMask) && m->isInScene() )
186            {
187                std::pair<bool, Real> result = mRay.intersects(m->getWorldBoundingBox());
188
189                if( result.first )
190                {
191                    listener -> queryResult( m, result.second );
192                                        // deal with attached objects, since they are not directly attached to nodes
193                                        if (m->getMovableType() == "Entity")
194                                        {
195                                                Entity* e = static_cast<Entity*>(m);
196                                                Entity::ChildObjectListIterator childIt = e->getAttachedObjectIterator();
197                                                while(childIt.hasMoreElements())
198                                                {
199                                                        MovableObject* c = childIt.getNext();
200                                                        if (c->getQueryFlags() & mQueryMask)
201                                                        {
202                                                                result = mRay.intersects(c->getWorldBoundingBox());
203                                                                if (result.first)
204                                                                {
205                                                                        listener->queryResult(c, result.second);
206                                                                }
207                                                        }
208                                                }
209                                        }
210                }
211            }
212        }
213
214        ++it;
215    }
216
217}
218
219
220//---------------------------------------------------------------------
221OctreeSphereSceneQuery::
222OctreeSphereSceneQuery(SceneManager* creator) : DefaultSphereSceneQuery(creator)
223{
224}
225//---------------------------------------------------------------------
226OctreeSphereSceneQuery::~OctreeSphereSceneQuery()
227{}
228//---------------------------------------------------------------------
229void OctreeSphereSceneQuery::execute(SceneQueryListener* listener)
230{
231    std::list < SceneNode * > list;
232    //find the nodes that intersect the AAB
233    static_cast<OctreeSceneManager*>( mParentSceneMgr ) -> findNodesIn( mSphere, list, 0 );
234
235    //grab all moveables from the node that intersect...
236    std::list < SceneNode * >::iterator it = list.begin();
237    while( it != list.end() )
238    {
239        SceneNode::ObjectIterator oit = (*it) -> getAttachedObjectIterator();
240        while( oit.hasMoreElements() )
241        {
242            MovableObject * m = oit.getNext();
243            if( (m->getQueryFlags() & mQueryMask) &&
244                                m->isInScene() &&
245                                mSphere.intersects( m->getWorldBoundingBox() ) )
246            {
247                listener -> queryResult( m );
248                                // deal with attached objects, since they are not directly attached to nodes
249                                if (m->getMovableType() == "Entity")
250                                {
251                                        Entity* e = static_cast<Entity*>(m);
252                                        Entity::ChildObjectListIterator childIt = e->getAttachedObjectIterator();
253                                        while(childIt.hasMoreElements())
254                                        {
255                                                MovableObject* c = childIt.getNext();
256                                                if (c->getQueryFlags() & mQueryMask &&
257                                                        mSphere.intersects( c->getWorldBoundingBox()))
258                                                {
259                                                        listener->queryResult(c);
260                                                }
261                                        }
262                                }
263            }
264        }
265
266        ++it;
267    }
268}
269//---------------------------------------------------------------------
270OctreePlaneBoundedVolumeListSceneQuery::
271OctreePlaneBoundedVolumeListSceneQuery(SceneManager* creator)
272        : DefaultPlaneBoundedVolumeListSceneQuery(creator)
273{
274
275}
276//---------------------------------------------------------------------
277OctreePlaneBoundedVolumeListSceneQuery::~OctreePlaneBoundedVolumeListSceneQuery()
278{}
279//---------------------------------------------------------------------
280void OctreePlaneBoundedVolumeListSceneQuery::execute(SceneQueryListener* listener)
281{
282    std::set<SceneNode*> checkedSceneNodes;
283
284    PlaneBoundedVolumeList::iterator pi, piend;
285    piend = mVolumes.end();
286    for (pi = mVolumes.begin(); pi != piend; ++pi)
287    {
288        std::list < SceneNode * > list;
289        //find the nodes that intersect the AAB
290        static_cast<OctreeSceneManager*>( mParentSceneMgr ) -> findNodesIn( *pi, list, 0 );
291
292        //grab all moveables from the node that intersect...
293        std::list < SceneNode * >::iterator it, itend;
294        itend = list.end();
295        for (it = list.begin(); it != itend; ++it)
296        {
297            // avoid double-check same scene node
298            if (!checkedSceneNodes.insert(*it).second)
299                continue;
300            SceneNode::ObjectIterator oit = (*it) -> getAttachedObjectIterator();
301            while( oit.hasMoreElements() )
302            {
303                MovableObject * m = oit.getNext();
304                if( (m->getQueryFlags() & mQueryMask) &&
305                                        m->isInScene() &&
306                                        (*pi).intersects( m->getWorldBoundingBox() ) )
307                {
308                    listener -> queryResult( m );
309                                        // deal with attached objects, since they are not directly attached to nodes
310                                        if (m->getMovableType() == "Entity")
311                                        {
312                                                Entity* e = static_cast<Entity*>(m);
313                                                Entity::ChildObjectListIterator childIt = e->getAttachedObjectIterator();
314                                                while(childIt.hasMoreElements())
315                                                {
316                                                        MovableObject* c = childIt.getNext();
317                                                        if (c->getQueryFlags() & mQueryMask &&
318                                                                (*pi).intersects( c->getWorldBoundingBox()))
319                                                        {
320                                                                listener->queryResult(c);
321                                                        }
322                                                }
323                                        }
324                }
325            }
326        }
327    }//for
328}
329
330
331}
Note: See TracBrowser for help on using the repository browser.