source: OGRE/trunk/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctree.cpp @ 350

Revision 350, 7.0 KB checked in by mattausch, 19 years ago (diff)

ray merge started

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 (c) 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/***************************************************************************
26octree.cpp  -  description
27-------------------
28begin                : Mon Sep 30 2002
29copyright            : (C) 2002 by Jon Anderson
30email                : janders@users.sf.net
31
32Enhancements 2003 - 2004 (C) The OGRE Team
33
34***************************************************************************/
35
36#include <OgreOctree.h>
37#include <OgreOctreeNode.h>
38
39namespace Ogre
40{
41
42/** Returns true is the box will fit in a child.
43*/
44bool Octree::_isTwiceSize( AxisAlignedBox &box )
45{
46    const Vector3 * pts1 = mBox.getAllCorners();
47    const Vector3 * pts2 = box.getAllCorners();
48
49    return ( ( pts2[ 4 ].x -pts2[ 0 ].x ) <= ( pts1[ 4 ].x - pts1[ 0 ].x ) / 2 ) &&
50           ( ( pts2[ 4 ].y - pts2[ 0 ].y ) <= ( pts1[ 4 ].y - pts1[ 0 ].y ) / 2 ) &&
51           ( ( pts2[ 4 ].z - pts2[ 0 ].z ) <= ( pts1[ 4 ].z - pts1[ 0 ].z ) / 2 ) ;
52
53}
54
55/** It's assumed the the given box has already been proven to fit into
56* a child.  Since it's a loose octree, only the centers need to be
57* compared to find the appropriate node.
58*/
59void Octree::_getChildIndexes( AxisAlignedBox &box, int *x, int *y, int *z )
60{
61    Vector3 max = mBox.getMaximum();
62    Vector3 min = box.getMinimum();
63
64    Vector3 center = mBox.getMaximum().midPoint( mBox.getMinimum() );
65
66    Vector3 ncenter = box.getMaximum().midPoint( box.getMinimum() );
67
68    if ( ncenter.x > center.x )
69        * x = 1;
70    else
71        *x = 0;
72
73    if ( ncenter.y > center.y )
74        * y = 1;
75    else
76        *y = 0;
77
78    if ( ncenter.z > center.z )
79        * z = 1;
80    else
81        *z = 0;
82
83}
84
85Octree::Octree( Octree * parent )
86    : mWireBoundingBox(0),
87      mHalfSize( 0, 0, 0 )
88#ifdef GTP_VISIBILITY_MODIFIED_OGRE
89        , mLastVisited(0), mVisible(false), mLastRendered(-1)
90#endif //GTP_VISIBILITY_MODIFIED_OGRE
91{
92    //initialize all children to null.
93    for ( int i = 0; i < 2; i++ )
94    {
95        for ( int j = 0; j < 2; j++ )
96        {
97            for ( int k = 0; k < 2; k++ )
98            {
99                mChildren[ i ][ j ][ k ] = 0;
100            }
101        }
102    }
103
104    mParent = parent;
105#ifdef GTP_VISIBILITY_MODIFIED_OGRE
106        // update bounds because we want tight octree
107        _updateBounds();
108       
109#endif //GTP_VISIBILITY_MODIFIED_OGRE
110    mNumNodes = 0;
111}
112
113Octree::~Octree()
114{
115    //initialize all children to null.
116    for ( int i = 0; i < 2; i++ )
117    {
118        for ( int j = 0; j < 2; j++ )
119        {
120            for ( int k = 0; k < 2; k++ )
121            {
122                if ( mChildren[ i ][ j ][ k ] != 0 )
123                    delete mChildren[ i ][ j ][ k ];
124            }
125        }
126    }
127
128    if(mWireBoundingBox)
129        delete mWireBoundingBox;
130
131    mParent = 0;
132
133}
134
135void Octree::_addNode( OctreeNode * n )
136{
137    mNodes.push_back( n );
138    n -> setOctant( this );
139
140    //update total counts.
141    _ref();
142
143#ifdef GTP_VISIBILITY_MODIFIED_OGRE
144        _updateBounds();
145#endif
146
147}
148
149void Octree::_removeNode( OctreeNode * n )
150{
151    mNodes.erase( std::find( mNodes.begin(), mNodes.end(), n ) );
152    n -> setOctant( 0 );
153
154    //update total counts.
155    _unref();
156
157#ifdef GTP_VISIBILITY_MODIFIED_OGRE
158        _updateBounds();
159#endif
160}
161
162void Octree::_getCullBounds( AxisAlignedBox *b )
163{
164    const Vector3 * corners = mBox.getAllCorners();
165    b -> setExtents( corners[ 0 ] - mHalfSize, corners[ 4 ] + mHalfSize );
166}
167
168WireBoundingBox* Octree::getWireBoundingBox()
169{
170        // Create a WireBoundingBox if needed
171    if(mWireBoundingBox == 0)
172        mWireBoundingBox = new WireBoundingBox();
173#ifdef GTP_VISIBILITY_MODIFIED_OGRE
174        mWireBoundingBox->setupBoundingBox(mWorldAABB);
175#else
176        mWireBoundingBox->setupBoundingBox(mBox);
177#endif 
178
179    return mWireBoundingBox;
180}
181
182#ifdef GTP_VISIBILITY_MODIFIED_OGRE
183//-----------------------------------------------------------------------       
184int Octree::lastVisited()
185{
186        return mLastVisited;
187}
188//-----------------------------------------------------------------------
189void Octree::setLastVisited(int frameid)
190{
191        mLastVisited = frameid;
192}
193//-----------------------------------------------------------------------       
194int Octree::lastRendered()
195{
196        return mLastRendered;
197}
198//-----------------------------------------------------------------------
199void Octree::setLastRendered(int frameid)
200{
201        mLastRendered = frameid;
202}
203//-----------------------------------------------------------------------       
204void Octree::setOctreeVisible(bool visible)
205{
206        mVisible = visible;
207}
208//-----------------------------------------------------------------------       
209bool Octree::isOctreeVisible()
210{
211        return mVisible;
212}
213//-----------------------------------------------------------------------       
214Octree *Octree::getParent()
215{
216        return mParent;
217}
218//-----------------------------------------------------------------------       
219AxisAlignedBox Octree::_getWorldAABB(void) const
220{
221        return mWorldAABB;
222}
223//-----------------------------------------------------------------------
224void Octree::_updateBounds()
225{
226        // Reset bounds first
227    mWorldAABB.setNull();
228 
229    // Update bounds from own attached objects
230        NodeList::iterator it, it_end;
231        it_end = mNodes.end();
232
233    for (it = mNodes.begin(); it != it_end; ++it)
234    {
235        // Merge world bounds of each object
236                mWorldAABB.merge((*it)->_getWorldAABB());
237    }
238
239    // Merge with children
240        for (int i = 0; i < 2; ++i)
241    {
242        for (int j = 0; j < 2; ++j)
243        {
244            for (int k = 0; k < 2; ++k)
245            {
246                if (mChildren[i][j][k])
247                                {
248                                        mWorldAABB.merge(mChildren[i][j][k]->_getWorldAABB());
249                                }
250            }
251        }
252        }
253        // HACK: clamp to bounds
254        AxisAlignedBox box;
255        _getCullBounds(&box);
256        mWorldAABB = mWorldAABB.intersection(box);
257       
258        // recursively update parent bounds
259        if (mParent)
260        {
261                mParent->_updateBounds();
262        }
263 }
264
265#endif //GTP_VISIBILITY_MODIFIED_OGRE
266}
Note: See TracBrowser for help on using the repository browser.