Inventor/nodes/SoRenderList.h

Go to the documentation of this file.

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2020 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
/*---------------------------------------------------------------------
 *  Header file for SoRenderList Separator node
 *
 *  Author: Brian Anderson, 
 *  Modified by Jerome Hummel, 2002
 *-------------------------------------------------------------------*/

#ifndef _SO_RENDER_LIST_HH
#define _SO_RENDER_LIST_HH

#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/actions/SoCallbackAction.h>
#include <Inventor/SbBox.h>
#include <Inventor/SbColor.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFUInt32.h>

#ifndef HIDDEN_FROM_DOC

class SoState;
class SoGLCacheList;
class SoNodeSensor;
class SoSearchAction;
class SoComplexity;

 SoDEPRECATED_CLASS(9800, "SoRenderList node and SoRenderObject class have been deprecated and will be removed in next major version.") SoRenderObject {

 public:
 
  SoRenderObject(const SoPath *p);
  virtual ~SoRenderObject();
  
  // Called when path has changed, invalidates render cache
  virtual void invalidate();
    
  // Added for bug in renderlist
  virtual SoPath *getPath(void) { return path; };
   
  // To improve spatial Traversal
  const SbBox3f& getBox(void) { return bbox; };

  // To know if the obj has transparent attribute or not
  SbBool isTranslucent;

  SbBool isOccluder;

  // We need to store the decimation value in the object.
  // For instance, this value depends on the octant, but to render
  // transparent object after having traversed the octree, we must
  // remember this value to do a traverseRenderObjectDecimated.
  // if the user wishes so
  float getDecimation() { return decimation; };
  void setDecimation(float value) { decimation = value; };

  void setIndex(int i) { index = i; };
  SbBool hasIndex(void) { return (index == -1 ? FALSE : TRUE); };
  int getIndex(void) { return index; };
  void resetIndex(void) { index = -1; };

 private:
  // This particular implementation has a SoPath in SoRenderObject; however,
  // future implementations will probably change this, so use the 
  // SoRenderList::getPathFromRenderObject() function to access the path.
  SoPath *path;
  SoGLCacheList *pathCache;
  SoPrimitiveCountCache *primCountCache;
  
  // Need it for more precise culling test in the octree and for occlusion culling
  SbBox3f bbox;
   
  float decimation;

  friend class SoRenderList;

  int index;

  int m_numRenderCaches;
};


 SoDEPRECATED_CLASS(9800, "SoRenderList node and SoRenderObjectList class have been deprecated and will be removed in next major version.") SoRenderObjectList : public SbPList{
  
 public:
  
  void append(SoRenderObject *string)
    { ((SbPList *) this)->append((void *) string); }
  
  int find(SoRenderObject *string)
    { return ((SbPList *) this)->find((void *) string); }
  
  void insert(SoRenderObject *string, int addBefore)
    { ((SbPList *) this)->insert((void *) string, addBefore); }
  
  SoRenderObject *&operator [](int i) const
    { return ( (SoRenderObject *&) ( (*(const SbPList *) this) [i] ) ); }
};

#endif // HIDDEN_FROM_DOC
class SoDEPRECATED SoRenderList : public SoSeparator{

  SO_NODE_HEADER(SoRenderList);

 public:
  SoRenderList();

  SoRenderList(int numChildren);

  void addRenderObjectType(SoType t);

  void removeRenderObjectType(SoType t);

  int getNumRenderObjectTypes() const
    { return types.getLength(); }

  SoType getRenderObjectType(int i) const
    { return  types[i]; }

  virtual void notify(SoNotList *list);

  void addRenderObjectName(SbName n);

  void removeRenderObjectName(SbName n);

  int getNumRenderObjectNames() const
    { return names.getLength(); }

  const SbName &getRenderObjectName(int i) const;

  void removeAllRenderObjectNames();
  
  SoSFBool isHead;

 private:
  static void initClass();
  static void exitClass();

 private:
  // Constructs path to Render object, the derived class can then 
  // apply an action to this path.  
  SoPath *getPathFromRenderObject (SoRenderObject *obj)
    { 
      if(obj->hasIndex())return obj->path->copy(obj->getIndex());
      else return obj->path; 
    };
  
  // Applies action to render object from the list, 
  // using caching where possible.
  void renderObject(SoGLRenderAction *action, SoRenderObject *);
  void traverseRenderObject(SoAction *action, SoRenderObject *);
  void primitiveCountRenderObject(SoGetPrimitiveCountAction *action, 
                                  SoRenderObject *);

  // Renders an object with BOUNDING_BOX complexity
  void traverseRenderObjectAsBox(SoAction *action, SoRenderObject *);

  // Traverses an object setting decimation value
  void traverseRenderObjectDecimated(SoAction *action, 
                                     SoRenderObject *, 
                                     float decimationPercentage);
  
  // Virtual callbacks for when changes are made to the RenderObject list.
  virtual SoRenderObject *createRenderObject(const SoPath *p);
  virtual void removingRenderObject(SoRenderObject *);
  virtual void renderObjectChanged(SoRenderObject *);
  virtual void ourFieldChanged(SoField *);
  
  // Destructor
  virtual ~SoRenderList();
  
  // Our list of paths to shapes below us:
  SoRenderObjectList shapes;    
  
  // CallbackAction used to find paths to shapes within scene graph,
  // creating list of RenderObjects. Keep it around always to keep 
  // overhead down.  Make it protected so subclasses can affect search.
  SoCallbackAction *shapeSearchAction;
  
  // Convenience function to get DecimationPercentageValue from state
  float getDecimationValue(SoState *state);
  
  // Detach and attach change sensor, so that derived classes can turn
  // off the notification during certain actions:
  void detachChangeSensor();
  void attachChangeSensor();
  
  // Returns TRUE if RenderList should keep a path to this node, 
  // with given type.  Subclasses could override this to 
  // change the algorithm used; this function checks the type against
  // the type list and the node's name against the name list.
  virtual SbBool lookingForNode(SoType t, const SoNode *n);   

  //add on to make different culling operations work together.
  SoSearchAction *searchForRenderList;
  SoRenderList* coworker;
  SbBool searchForACoworker;

  enum SortType {
    BUBBLE,
    MERGE
  };

  //To sort objects-The furthest object will be the first one (yourList[0]) unless backToFront is FALSE
  //2 types of sort are available. Bubble is sometimes faster if the stack is already partially sorted.
  void sortObjects(SoState* state, 
                   SoRenderObjectList &vobject,
                   int firstIndex,
                   int lastIndex,
                   SbBool backToFront=TRUE,
                   SortType type = SoRenderList::MERGE);

  // This will check in the current state if the renderObject has attributes (transparency, ...).
  void checkForAttribute(SoRenderObject*);

  // Added and used by octree or occlusion to manage trans obj
  SbBool sortTransparentObjs;

  // Manage transparency only if DELAYED or SORTED mode
  SbBool manageTransparency;


 private:
  // Common code for the two constructors:
  void commonConstructor();
  
  // Our complexity node for adjusting rendering:
  SoComplexity *boxComplexity;
  
  // List of whether a path has been affected or not by the last change
  SbIntList pathsAffected;
  void markAffected(int whichPath);
  // this function calls "pathChanged" for each path that was affected
  // by the last change
  void callAffectedPathsCallbacks();
  
  // List of types to search for
  SoTypeList types;
  SbPList names;
  
  // Get paths to renderObjects under graph
  int indexIntoShapes;
  SoRenderObject* mergePath(const SoPath *path, int where);
  SoRenderObject* addRenderObject(const SoPath *p, int where);
  void removeRenderObject(int where);
  void renderObjectChanged(int where);
  
  // SearchAction for finding affected paths:      
  SoSearchAction *pathSearchAction;
  void findAffectedPaths(SoNode *node);
  void findContainingPaths(SoNode *node, int start);
  int findTruncatedPaths();
  
  // Save the relationship between field change and affected paths:
  void saveRelationship(SoNode* changedNode, 
                        const SbIntList &affectedPaths);
  SbBool haveRelationship(SoNode *changedNode, 
                          SbIntList &affectedPaths);
  void clearRelationships();
  SbPList relateNodes, relatePaths;
  
  // Node sensor for finding when nodes underneath this node are added
  // and removed:
  SoNodeSensor *childChangeSensor;
  SbPList sensorList;
  static void childSensorCB(void *data, SoSensor *sensor)
    { ((SoRenderList*)data)->childChange( (SoNodeSensor*) sensor); };
  void childChange(SoNodeSensor *sensor);
  static void tailSensorCB(void *data, SoSensor *sensor)
    { ((SoRenderList*)data)->tailChange( (SoNodeSensor*) sensor); };
  void tailChange(SoNodeSensor *sensor);
  
  // PRE Callbacks from SoCallbackAction, looking for render objects
  static SoCallbackAction::Response foundRenderObjectCB(void *userData,
                                                        SoCallbackAction *action,
                                                        const SoNode *);
  // POST Callbacks from SoCallbackAction, looking for render objects
  static SoCallbackAction::Response afterFoundingRenderObjectCB(void *userData,
                                                        SoCallbackAction *action,
                                                        const SoNode *);

  //for LOD case
  SbBool doNotCreateRenderObject;
  SoRenderObject* objectToCheck;
  // Utility functions to sort objects from front to back or B to F
  void mergeSort(float *A, int firstIndex, int lastIndex, SoRenderObjectList &obj,SbBool);
  void mergeBtoF(float *A, int f, int m, int l, SoRenderObjectList &obj);
  void mergeFtoB(float *A, int f, int m, int l, SoRenderObjectList &obj);

  void bubbleSort(float *A, int firstIndex, int lastIndex,SoRenderObjectList &obj,SbBool);
  void bubbleBtoF(float *A, int firstIndex, int lastIndex, SoRenderObjectList &obj);
  void bubbleFtoB(float *A, int firstIndex, int lastIndex, SoRenderObjectList &obj);

  // Save current state when creating renderObject to checkForAttribute.
  SoState *currentState;
};

#endif

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/