OSG::BoxVolume Class Reference

00037                          : 
00038      Inherited(             ),
00039     _min      (0.f, 0.f, 0.f), 
00040     _max      (0.f, 0.f, 0.f)
00041 {
00042 }

00047                                                       :
00048      Inherited(                ), 
00049     _min      (xmin, ymin, zmin), 
00050     _max      (xmax, ymax, zmax)
00051 { 
00052     setEmpty(false);
00053 }

00057                                                        :
00058      Inherited(   ), 
00059     _min      (min), 
00060     _max      (max)
00061 { 
00062     setEmpty(false); 
00063 }

00067                                          :
00068      Inherited(obj     ), 
00069     _min      (obj._min), 
00070     _max      (obj._max) 
00071 {
00072 }

00077 {
00078 }

00083 {
00084     return _min;
00085 }

00090 {
00091     return _max;
00092 }

00067 {
00068     if(isEmpty() == true)
00069     {
00070         center.setValues(0.0f, 0.0f, 0.0f);
00071     }
00072     else
00073     {
00074         center = _min + (_max - _min) * .5f;
00075     }
00076 }

00081 {
00082     return (isEmpty() == true) ? 0.0f : (_max[0] - _min[0]) *
00083                                         (_max[1] - _min[1]) *
00084                                         (_max[2] - _min[2]);
00085 }

00089 {
00090     min = _min;
00091     max = _max;
00092 }

00102 {
00103     _min.getSeparateValues(xmin, ymin, zmin);
00104     _max.getSeparateValues(xmax, ymax, zmax);
00105 }

00112 {
00113     originX = _min[0];
00114     originY = _min[1];
00115     originZ = _min[2];
00116 }

00123 {
00124     sizeX = _max[0] - _min[0];
00125     sizeY = _max[1] - _min[1];
00126     sizeZ = _max[2] - _min[2];
00127 }

00132 {
00133     vec.setValues(_max[0] - _min[0], _max[1] - _min[1], _max[2] - _min[2]);
00134 }

00139 {
00140     _min.setValues(-w / 2.0f, -h / 2.0f, -d / 2.0f);
00141     _max.setValues( w / 2.0f,  h / 2.0f,  d / 2.0f);
00142 
00143     Volume::setValid   (true );
00144     Volume::setEmpty   (false);
00145     Volume::setInfinite(false);
00146 }

00156 {
00157     _min.setValues(xmin, ymin, zmin);
00158     _max.setValues(xmax, ymax, zmax);
00159 
00160     Volume::setValid   (true );
00161     Volume::setEmpty   (false);
00162     Volume::setInfinite(false);
00163 }

00168 {
00169     _min = min; 
00170     _max = max;
00171 
00172     Volume::setValid   (true );
00173     Volume::setEmpty   (false);
00174     Volume::setInfinite(false);
00175 }

00098 {
00099     _min.setValues(center.x() - size.x() / 2.0f,
00100                    center.y() - size.y() / 2.0f,
00101                    center.z() - size.z() / 2.0f);
00102     _max.setValues(center.x() + size.x() / 2.0f,
00103                    center.y() + size.y() / 2.0f,
00104                    center.z() + size.z() / 2.0f);
00105 
00106     Volume::setValid   (true);
00107     Volume::setEmpty   (size.isZero());
00108     Volume::setInfinite(false);
00109 }

00117 {
00118     if(isUntouchable() == true)
00119         return;
00120 
00121     if(isEmpty() == true)
00122     {
00123         _min[0] = _max[0] = pt[0];
00124         _min[1] = _max[1] = pt[1];
00125         _min[2] = _max[2] = pt[2];
00126 
00127         setEmpty(false);
00128 
00129         return;
00130     }
00131 
00132     if(pt[0] < _min[0])
00133     {
00134         _min[0] = pt[0];
00135     }
00136     else
00137     {
00138         if(pt[0] > _max[0])
00139             _max[0] = pt[0];
00140     }
00141 
00142     if(pt[1] < _min[1])
00143     {
00144         _min[1] = pt[1];
00145     }
00146     else
00147     {
00148         if(pt[1] > _max[1])
00149             _max[1] = pt[1];
00150     }
00151 
00152     if(pt[2] < _min[2])
00153     {
00154         _min[2] = pt[2];
00155     }
00156     else
00157     {
00158         if(pt[2] > _max[2])
00159             _max[2] = pt[2];
00160     }
00161 }

00165 {
00166     OSG::extend(*this,volume);
00167 }

00180 {
00181     OSG::extend(*this, volume);
00182 }

00174 {
00175     return 
00176         (!isEmpty()      &&
00177         (_min[0] < pt[0] && _max[0] > pt[0]) &&
00178         (_min[1] < pt[1] && _max[1] > pt[1]) &&
00179         (_min[2] < pt[2] && _max[2] > pt[2]));
00180 }

00185 {
00186     Real enter;
00187     Real exit;
00188 
00189     return line.intersect(*this, enter, exit);
00190 }

00199 {
00200     return line.intersect(*this, min, max);
00201 }

00205 {
00206     return OSG::intersect(*this, volume);
00207 }

00211 {
00212     return OSG::intersect(*this, volume);
00213 }

00217 {
00218     if(((osgAbs(point[0] - _min[0]) < Eps           ||
00219          osgAbs(point[0] - _max[0]) < Eps             ) &&
00220         (point[1] >= _min[1] && point[1] <= _max[1] &&
00221          point[2] >= _min[2] && point[2] <= _max[2]   )   ) ||
00222 
00223        ((osgAbs(point[1] - _min[1]) < Eps           ||
00224          osgAbs(point[1] - _max[1]) < Eps             ) &&
00225         (point[0] >= _min[0] && point[0] <= _max[1] &&
00226          point[2] >= _min[2] && point[2] <= _max[2]   )   ) ||
00227 
00228        ((osgAbs(point[2] - _min[2]) < Eps           ||
00229          osgAbs(point[2] - _max[2]) < Eps             ) &&
00230         (point[1] >= _min[1] && point[1] <= _max[1] &&
00231          point[0] >= _min[0] && point[0] <= _max[0]   )   )   )
00232     {
00233         return true;
00234     }
00235     else
00236     {
00237         return false;
00238     }
00239 }

00245 {
00246     Real xmin;
00247     Real ymin;
00248     Real zmin;
00249     Real xmax;
00250     Real ymax;
00251     Real zmax;
00252     Real a;
00253     Real b;
00254 
00255     if(isEmpty() == true)
00256         return;
00257 
00258     xmin = xmax = m[3][0];
00259     ymin = ymax = m[3][1];
00260     zmin = zmax = m[3][2];
00261 
00262     //
00263     // calculate xmin and xmax of new tranformed BBox
00264     //
00265 
00266     a = _max[0] * m[0][0];
00267     b = _min[0] * m[0][0];
00268 
00269     if(a >= b)
00270     {
00271         xmax += a;
00272         xmin += b;
00273     }
00274     else
00275     {
00276         xmax += b;
00277         xmin += a;
00278     }
00279 
00280     a = _max[1] * m[1][0];
00281     b = _min[1] * m[1][0];
00282 
00283     if(a >= b) 
00284     {
00285         xmax += a;
00286         xmin += b;
00287     }
00288     else
00289     {
00290         xmax += b;
00291         xmin += a;
00292     }
00293     
00294     a = _max[2] * m[2][0];
00295     b = _min[2] * m[2][0];
00296 
00297     if(a >= b)
00298     {
00299         xmax += a;
00300         xmin += b;
00301     }
00302     else
00303     {
00304         xmax += b;
00305         xmin += a;
00306     }
00307 
00308     //
00309     // calculate ymin and ymax of new tranformed BBox
00310     //
00311 
00312     a = _max[0] * m[0][1];
00313     b = _min[0] * m[0][1];
00314 
00315     if(a >= b)
00316     {
00317         ymax += a;
00318         ymin += b;
00319     }
00320     else
00321     {
00322         ymax += b;
00323         ymin += a;
00324     }
00325 
00326     a = _max[1] * m[1][1];
00327     b = _min[1] * m[1][1];
00328 
00329     if(a >= b)
00330     {
00331         ymax += a;
00332         ymin += b;
00333     }
00334     else
00335     {
00336         ymax += b;
00337         ymin += a;
00338     }
00339 
00340     a = _max[2] * m[2][1];
00341     b = _min[2] * m[2][1];
00342 
00343     if(a >= b)
00344     {
00345         ymax += a;
00346         ymin += b;
00347     }
00348     else
00349     {
00350         ymax += b;
00351         ymin += a;
00352     }
00353 
00354     //
00355     // calculate zmin and zmax of new tranformed BBox
00356     //
00357 
00358     a = _max[0] * m[0][2];
00359     b = _min[0] * m[0][2];
00360 
00361     if(a >= b) 
00362     {
00363         zmax += a;
00364         zmin += b;
00365     }
00366     else
00367     {
00368         zmax += b;
00369         zmin += a;
00370     }
00371 
00372     a = _max[1] * m[1][2];
00373     b = _min[1] * m[1][2];
00374 
00375     if(a >= b)
00376     {
00377         zmax += a;
00378         zmin += b;
00379     }
00380     else
00381     {
00382         zmax += b;
00383         zmin += a;
00384     }
00385 
00386     a = _max[2] * m[2][2];
00387     b = _min[2] * m[2][2];
00388 
00389     if(a >= b)
00390     {
00391         zmax += a;
00392         zmin += b;
00393     }
00394     else
00395     {
00396         zmax += b;
00397         zmin += a;
00398     }
00399 
00400     _min.setValues(xmin, ymin, zmin);
00401     _max.setValues(xmax, ymax, zmax);
00402 }

00407 {
00408     if(&b1 == this)
00409         return *this;
00410 
00411     _min   = b1._min;
00412     _max   = b1._max;
00413     _state = b1._state;
00414 
00415     return *this;
00416 }

00422 {
00423     PLOG << "Box(" << _min << "|" << _max << ")";
00424 }

00074 {
00075     if(!isStatic())
00076     {
00077         if(value == true)
00078             _state |=  OSGVALID;
00079         else
00080             _state &= ~OSGVALID;
00081     }
00082 }

00088 {
00089     return (_state & OSGVALID) ? true : false;
00090 }

00096 {
00097     if(value == true)
00098     {
00099         _state |=  OSGEMPTY;
00100         _state |=  OSGVALID;
00101         _state &= ~OSGINFINITE;
00102     }
00103     else
00104     {
00105         _state &= ~OSGEMPTY;
00106     }
00107 }

00113 {
00114     return (_state & OSGEMPTY) ? true : false;
00115 }

00055 {
00056     if(value == true)
00057         _state |= OSGSTATIC;
00058     else
00059         _state &= ~OSGSTATIC;
00060 }

00066 {
00067     return (_state & OSGSTATIC) ? true : false;
00068 }

00121 {
00122     if(value == true)
00123     {
00124         _state |=  OSGINFINITE;
00125         _state |=  OSGVALID;
00126         _state &= ~OSGEMPTY;
00127     }
00128     else
00129     {
00130         _state &= ~OSGINFINITE;
00131     }
00132 }

00138 {
00139     return (_state & OSGINFINITE) ? true : false;
00140 }

00149 {
00150     return (_state & (OSGINFINITE | OSGVALID |