C++ SLNode::next方法代码示例

/*!
The SLRefGroup::shapeInit checks the validity of the referenced node. To avoid 
endless loops a refShape node is not allowed to refShape its ancestors. An 
ancestor of a refShape node is group node followed along the previous pointers 
with lower depth than the depth of the refShape node.
*/
void SLRefGroup::shapeInit(SLSceneView* sv)
{  
   // cummulate wm with referenced wm
   SLShape* ref = (SLShape*)_refGroup; 
   _wm *= ref->m();
   _wmI.setMatrix(_wm.inverse());
   _wmN.setMatrix(_wmI.mat3());
   _wmN.transpose();
   
   // check circular references
   SLNode* parent = this->parent();
   while (parent)
   {  if (parent==_refGroup)
         SL_EXIT_MSG("Reference node produces a never ending loop.");
      parent = parent->parent();
   }
   
   // set transparency flag
   _aabb.hasAlpha(((SLShape*)_refGroup)->aabb()->hasAlpha());
   
   // delete all child references
   if (_first) deleteAll();
      
   // loop through the referenced group and add a SLRefShape or SLRefGroup
   SLNode* current = ((SLGroup*)_refGroup)->first();
   while (current)
   {  if (typeid(*current)==typeid(SLGroup))
           addNode(new SLRefGroup((SLGroup*)current, name()+"_"+current->name()));
      else addNode(new SLRefShape((SLShape*)current, name()+"_"+current->name()));
      ((SLShape*)_last)->wm(_wm);
      ((SLShape*)_last)->depth(depth()+1);
      ((SLShape*)_last)->shapeInit(sv);
      current = current->next();
   }
}

/*!
SLGroup::shapeDraw loops over all child nodes and calls the their draw method.
Groups are only traversed for opaque objects. Transparent objects are rendere
extra afterwards.
*/
void SLGroup::shapeDraw(SLSceneView* sv)
{  SLNode* current = _first;
   
   while (current)
   {  current->draw(sv);   
      current = current->next();
   }
}

/*!
SLGroup::shapeCopy loops over all child nodes and calls their copy method.
A new group with all copied child node is returned.
*/
SLShape* SLGroup::shapeCopy()
{  SLGroup* copy = new SLGroup(name());
   SLNode* current = _first;
   
   while (current)
   {  copy->addNode(current->copy());
      current = current->next();
   }
   return copy;
}

/*!
SLRefGroup::shapeHit calls the shapeHit method of the referenced group.
*/
SLbool SLRefGroup::shapeHit(SLRay* ray)
{  
   // loop through child references an hit each
   SLNode* current = _first;
   SLbool wasHit = false;
   while (current)
   {  if (((SLShape*)current)->hit(ray) && !wasHit) wasHit = true;
      current = current->next();
   }
   return wasHit;
}

/*!
SLGroup::getNode finds a node by a name
*/
SLNode* SLGroup::getNode(SLstring name) 
{  SLNode* current = _first;
   
   while (current)
   {  if(current->name() == name) return current;
      if (typeid(*current)==typeid(SLGroup))
      {  SLNode* found = ((SLGroup*)current)->getNode(name);
         if (found) return found;
      }
      current = current->next();
   }
   return 0;
}

/*!
SLGroup::buildAABB() loops over all child nodes and merges their AABB
to the axis aligned bounding box of the group.
*/
SLAABBox& SLGroup::buildAABB()
{  SLNode* current = _first;
   
   // empty the groups AABB    
   _aabb.minWS(SLVec3f( FLT_MAX, FLT_MAX, FLT_MAX));
   _aabb.maxWS(SLVec3f(-FLT_MAX,-FLT_MAX,-FLT_MAX));

   while (current)
   {  _aabb.merge(current->buildAABB());
      current = current->next();
   }
   
   _aabb.fromWStoOS(_aabb.minWS(), _aabb.maxWS(), _wmI);
   return _aabb;
}

/*!
SLGroup::shapeInit loops over all child nodes and calls their init method with
an incremented depth. While looping it must be checked that all child nodes
have a depth equal the groups depth + 1.
*/
void SLGroup::shapeInit(SLSceneView* sv)
{  SLNode* current = _first;
   while (current)
   {  if (current->depth() && current->depth() != depth()+1) 
      {  SL_EXIT_MSG("Scenegraph is not directed acyclic. There is a loop.");
      }
      current->init(sv, depth()+1);
      
      // Set transparent flags of the group
      if (!_aabb.hasAlpha() && ((SLShape*)current)->aabb()->hasAlpha())
         _aabb.hasAlpha(true); 
         
      current = current->next();
   }
}

/*!
SLGroup::intersect loops over all child nodes of the group and calls their
intersect method.  
*/
SLbool SLGroup::shapeHit(SLRay* ray)
{  assert(ray != 0);

   SLNode* current = _first;
   SLbool wasHit = false;
   while (current)
   {  
      // do not test origin node for shadow rays 
      if (!(current==ray->originShape && ray->type==SHADOW))
      {  if (current->hit(ray) && !wasHit) wasHit = true;
      }
      
      if (ray->isShaded()) return true;
      current = current->next();
   }
   return wasHit;
}

/*!
SLGroup::updateStats updates the statistic counters of a group. 
Be aware that when you add, insert or delete nodes in group only the 
numChildren counter is updated automatically. For the correct counters of the 
root3D group you have to call its updateStats method first. 
Achtung: the light node is counted in numShapes and numLights.
*/
void SLGroup::updateStats(SLGroup* parent)
{  SLNode* current = _first;
   numBytes      = 0;
   numBytesAccel = 0;
   numGroups     = 1;
   numShapes     = 0;
   numRefShapes  = 0;
   numLights     = 0;
   numTriangles  = 0;
   numRTTriangles= 0;
   numRTVertices = 0;
   numVoxels     = 0;
   numVoxEmpty   = 0;
   numVoxMaxTria = 0;
   

   while (current)
   {  current->updateStats(this);
      current = current->next();
   }
   
   if (parent)
   {  ((SLGroup*)parent)->numBytes      += numBytes;
      ((SLGroup*)parent)->numBytesAccel += numBytesAccel;
      ((SLGroup*)parent)->numGroups     += numGroups;
      ((SLGroup*)parent)->numShapes     += numShapes;
      ((SLGroup*)parent)->numRefShapes  += numRefShapes;
      ((SLGroup*)parent)->numTriangles  += numTriangles;
      ((SLGroup*)parent)->numRTTriangles+= numRTTriangles;
      ((SLGroup*)parent)->numRTVertices += numRTVertices;
      ((SLGroup*)parent)->numVoxels     += numVoxels;
      ((SLGroup*)parent)->numVoxEmpty   += numVoxEmpty;
      if (numVoxMaxTria > ((SLGroup*)parent)->numVoxMaxTria)
         ((SLGroup*)parent)->numVoxMaxTria = numVoxMaxTria;
   }
}