Tools/osgBench/Nodes.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000,2001 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <boost/python/errors.hpp>
  44 #include <Python.h>
  45 #include <Nodes.h>
  46 #include <OpenSG/OSGSimpleGeometry.h>
  47 #include <OpenSG/OSGSceneFileHandler.h>
  48
  49 // Basic Node
  50
  51 NodeBase::NodeBase()
  52 {
  53     _node = OSG::Node::create();
  54 }
  55
  56 NodeBase::NodeBase(const NodeBase &copy) : _node(copy._node)
  57 {
  58 }
  59
  60 NodeBase::NodeBase(OSG::NodePtr node) : _node(node)
  61 {
  62 }
  63
  64 NodeBase::NodeBase(OSG::NodeCorePtr core)
  65 {
  66     _node = OSG::Node::create();
  67
  68     // beginEditCP(_node);
  69     _node->setCore(core);
  70     // endEditCP(_node);
  71 }
  72
  73 NodeBase::~NodeBase()
  74 {
  75 }
  76
  77 const char *NodeBase::getType(void)
  78 {
  79     if(_node->getCore() == OSG::NullFC)
  80         return "<uncored>";
  81
  82     return _node->getCore()->getType().getCName();
  83 }
  84
  85 void NodeBase::dump(void)
  86 {
  87     _node->dump();
  88 }
  89
  90 void NodeBase::save(const char * name)
  91 {
  92     OSG::SceneFileHandler::the()->write(_node, name);
  93 }
  94
  95 NodeBase NodeBase::clone(void)
  96 {
  97     return NodeBase(OSG::deepCloneTree(_node));
  98 }
  99
 100
 101 NodeIterator NodeBase::iter(const char * name)
 102 {
 103     return NodeIterator(*this, name);
 104 }
 105
 106 TypedNodeIterator<Geometry> NodeBase::geometries(void)
 107 {
 108     return TypedNodeIterator<Geometry>(*this);
 109 }
 110
 111 TypedNodeIterator<Transform> NodeBase::transforms(void)
 112 {
 113     return TypedNodeIterator<Transform>(*this);
 114 }
 115
 116 // Group Node
 117
 118 Group::Group() : NodeBase()
 119 {
 120     _group = OSG::Group::create();
 121
 122     // OSG::beginEditCP(_node);
 123     _node->setCore(_group);
 124     // OSG::endEditCP(_node);
 125 }
 126
 127 Group::Group(const Group &group) : NodeBase(group)
 128 {
 129     _group = group._group;
 130 }
 131
 132 Group::Group(OSG::NodePtr node) : NodeBase(node)
 133 {
 134     _group = OSG::cast_dynamic<OSG::GroupPtr>(node->getCore());
 135
 136     // OSG::beginEditCP(_node);
 137     _node->setCore(_group);
 138     // OSG::endEditCP(_node);
 139 }
 140
 141 Group::Group(OSG::GroupPtr group) : NodeBase()
 142 {
 143     // OSG::beginEditCP(_node);
 144     _node->setCore(_group);
 145     // OSG::endEditCP(_node);
 146 }
 147
 148 Group::~Group()
 149 {
 150 }
 151
 152
 153 void Group::addChild(NodeBase &child)
 154 {
 155     // OSG::beginEditCP(_node);
 156     _node->addChild(child.getNode());
 157     // OSG::endEditCP(_node);
 158 }
 159
 160
 161 void Group::subChild(NodeBase &child)
 162 {
 163     // OSG::beginEditCP(_node);
 164     _node->subChild(child.getNode());
 165     // OSG::endEditCP(_node);
 166 }
 167
 168 // Transform Node
 169
 170 Transform::Transform()
 171 {
 172     _transform = OSG::Transform::create();
 173
 174     // OSG::beginEditCP(_node);
 175     _node->setCore(_transform);
 176     // OSG::endEditCP(_node);
 177 }
 178
 179 Transform::Transform(const Transform &trans) : Group(trans)
 180 {
 181     _transform = trans._transform;
 182 }
 183
 184 Transform::Transform(OSG::NodePtr node) : Group(node)
 185 {
 186     _transform = OSG::cast_dynamic<OSG::TransformPtr>(node->getCore());
 187
 188     // OSG::beginEditCP(_node);
 189     _node->setCore(_transform);
 190     // OSG::endEditCP(_node);
 191 }
 192
 193 Transform::Transform(OSG::TransformPtr transform) : Group()
 194 {
 195     // OSG::beginEditCP(_node);
 196     _node->setCore(_transform);
 197     // OSG::endEditCP(_node);
 198 }
 199
 200 Transform::~Transform()
 201 {
 202 }
 203
 204
 205 void Transform::setTranslation(OSG::Real32 x, OSG::Real32 y, OSG::Real32 z)
 206 {
 207     OSG::Matrix m;
 208
 209     m.setTransform(OSG::Vec3f(x,y,z));
 210
 211     // OSG::beginEditCP(_transform);
 212     _transform->setMatrix(m);
 213     // OSG::endEditCP(_transform);
 214 }
 215
 216
 217 // Geometry Node
 218
 219 Geometry::Geometry()
 220 {
 221     _geometry = OSG::Geometry::create();
 222
 223     // OSG::beginEditCP(_node);
 224     _node->setCore(_geometry);
 225     // OSG::endEditCP(_node);
 226 }
 227
 228 Geometry::Geometry(const Geometry &geo) : NodeBase(geo)
 229 {
 230     _geometry = geo._geometry;
 231 }
 232
 233 Geometry::Geometry(OSG::NodePtr node) : NodeBase(node)
 234 {
 235     _geometry = OSG::cast_dynamic<OSG::GeometryPtr>(node->getCore());
 236
 237     // OSG::beginEditCP(_node);
 238     _node->setCore(_geometry);
 239     // OSG::endEditCP(_node);
 240 }
 241
 242 Geometry::Geometry(OSG::GeometryPtr geometry) : NodeBase()
 243 {
 244     // OSG::beginEditCP(_node);
 245     _node->setCore(_geometry);
 246     // OSG::endEditCP(_node);
 247 }
 248
 249 Geometry::~Geometry()
 250 {
 251 }
 252
 253
 254 void Geometry::translate(OSG::Real32 x, OSG::Real32 y, OSG::Real32 z)
 255 {
 256     OSG::Vec3f d(x,y,z);
 257     OSG::Pnt3f p;
 258     OSG::GeoPositionsPtr pos = _geometry->getPositions();
 259
 260     // OSG::beginEditCP(_geometry, OSG::Geometry::PositionsFieldMask);
 261
 262     for(OSG::UInt32 i = 0; i < pos->size(); ++i)
 263     {
 264         pos->getValue(p, i);
 265         p += d;
 266         pos->setValue(p,i);
 267     }
 268
 269     // OSG::endEditCP(_geometry, OSG::Geometry::PositionsFieldMask);
 270 }
 271
 272 void Geometry::scale(OSG::Real32 x, OSG::Real32 y, OSG::Real32 z)
 273 {
 274     OSG::Pnt3f p;
 275     OSG::GeoPositionsPtr pos = _geometry->getPositions();
 276
 277     // OSG::beginEditCP(_geometry, OSG::Geometry::PositionsFieldMask);
 278
 279     for(OSG::UInt32 i = 0; i < pos->size(); ++i)
 280     {
 281         pos->getValue(p, i);
 282         p[0] *= x;
 283         p[1] *= y;
 284         p[2] *= z;
 285         pos->setValue(p,i);
 286     }
 287
 288     // OSG::endEditCP(_geometry, OSG::Geometry::PositionsFieldMask);
 289 }
 290
 291
 292 void Geometry::setDlistCache(bool cache)
 293 {
 294     _geometry->setDlistCache(cache);
 295 }
 296
 297
 298 // Node Iterator
 299
 300 NodeIterator::NodeIterator(void)
 301 {
 302 }
 303
 304 NodeIterator::NodeIterator(NodeBase &start, const char *name)
 305 {
 306     _stack.push_back(start.getNode());
 307
 308     _type = OSG::FieldContainerFactory::the()->findType(name);
 309
 310 }
 311
 312 NodeIterator::NodeIterator(const NodeIterator &copy) :
 313     _type(copy._type), _stack(copy._stack)
 314 {
 315 }
 316
 317 NodeIterator::~NodeIterator()
 318 {
 319 }
 320
 321 NodeIterator NodeIterator::__iter__(void)
 322 {
 323     return *this;
 324 }
 325
 326 NodeBase NodeIterator::next(void)
 327 {
 328     while(!_stack.empty())
 329     {
 330         OSG::NodePtr act = _stack.back();
 331
 332         _stack.pop_back();
 333
 334         for(OSG::UInt32 i = 0; i < act->getNChildren(); ++i)
 335             _stack.push_back(act->getChild(i));
 336
 337         if(act->getCore()->getType().isDerivedFrom(*_type))
 338         {
 339             return NodeBase(act);
 340         }
 341     }
 342
 343     PyErr_SetString(PyExc_StopIteration, "Out of Nodes");
 344     boost::python::throw_error_already_set();
 345 }
 346
 347
 348 template <class type>
 349 TypedNodeIterator<type>::TypedNodeIterator(void) : NodeIterator()
 350 {
 351     _type = OSG::FieldContainerFactory::the()->findType(type::getCoreName());
 352 }
 353
 354 template <class type>
 355 TypedNodeIterator<type>::TypedNodeIterator(NodeBase &start) :
 356     NodeIterator(start, type::getCoreName())
 357 {
 358 }
 359
 360 template <class type>
 361 TypedNodeIterator<type>::TypedNodeIterator(const TypedNodeIterator<type> &copy)
 362 : NodeIterator(copy)
 363 {
 364 }
 365
 366 template <class type>
 367 TypedNodeIterator<type>::~TypedNodeIterator()
 368 {
 369 }
 370
 371 template <class type>
 372 TypedNodeIterator<type> TypedNodeIterator<type>::__iter__(void)
 373 {
 374     return *this;
 375 }
 376
 377 template <class type>
 378 type TypedNodeIterator<type>::next(void)
 379 {
 380     return type(NodeIterator::next().getNode());
 381 }
 382
 383
 384 template class TypedNodeIterator<Geometry>;
 385 template class TypedNodeIterator<Transform>;
 386
 387 // Functions
 388
 389
 390 Geometry makeBox(OSG::Real32 x, OSG::Real32 y, OSG::Real32 z,
 391                  OSG::UInt16 hor, OSG::UInt16 vert, OSG::UInt16 depth)
 392 {
 393     Geometry g(OSG::makeBox(x,y,z,hor,vert,depth));
 394
 395     return g;
 396 }
 397
 398 Geometry makeTorus(OSG::Real32 inner, OSG::Real32 outer,
 399                    OSG::UInt16 sides, OSG::UInt16 rings)
 400 {
 401     Geometry g(OSG::makeTorus(inner,outer,sides,rings));
 402
 403     return g;
 404 }
 405
 406 Geometry makeSphere(OSG::UInt16 latres, OSG::UInt16 longres,
 407                     OSG::Real32 radius)
 408 {
 409     Geometry g(OSG::makeLatLongSphere(latres,longres,radius));
 410
 411     return g;
 412 }
 413
 414
 415 Geometry makePlane(OSG::Real32 x, OSG::Real32 y,
 416                    OSG::UInt16 hor, OSG::UInt16 vert)
 417 {
 418     Geometry g(OSG::makePlane(x, y, hor, vert));
 419
 420     return g;
 421 }
 422
 423 NodeBase makeShared(NodeBase &node)
 424 {
 425     return NodeBase(node.getNode()->getCore());
 426 }
 427
 428 void addRef(NodeBase &node)
 429 {
 430     OSG::addRef(node.getNode());
 431 }
 432
 433 void subRef(NodeBase &node)
 434 {
 435     OSG::subRef(node.getNode());
 436 }
 437
 438 NodeBase loadScene(char *filename)
 439 {
 440     OSG::NodePtr node = OSG::SceneFileHandler::the()->read(filename);
 441
 442     return NodeBase(node);
 443 }