Logo Search packages:      
Sourcecode: passage version File versions  Download package

Object3D.h

/*
 * Modification History
 *
 * 2001-January-9       Jason Rohrer
 * Created.  Copied from ObjectGL.
 *
 * 2001-January-10            Jason Rohrer
 * Made class serializable.  Added a parameterless constructor
 * to facilitate deserialization.  
 *
 * 2001-January-15            Jason Rohrer
 * Fixed several bugs in the deserialize() function, as well as in the
 * destructor.  
 *
 * 2001-January-16            Jason Rohrer
 * Changed to use a Transform3D instead of Vectors, Angles, and scales for
 * each primitive in the object.
 *
 * 2001-January-24            Jason Rohrer
 * Added a copy() function. 
 * Fixed a bug in deserialize(). 
 * Made mMembersAllocated public for copy function.  
 *
 * 2001-January-26            Jason Rohrer
 * Fixed a bug in copy().
 *
 * 2001-January-31            Jason Rohrer
 * Fixed bugs in serialize() and deserialize().
 *
 * 2001-February-3            Jason Rohrer
 * Updated serialization code to use new interfaces.
 *
 * 2001-March-11   Jason Rohrer
 * Added support for paramatization and temporal animations.
 *
 * 2001-March-13   Jason Rohrer
 * Added interface for getting the number of parameters and animations.
 *
 * 2001-March-14   Jason Rohrer
 * Added use of Primitive3DFactory for typed subclass primitive
 * de/serialization.
 */
 
 
#ifndef OBJECT_3D_INCLUDED
#define OBJECT_3D_INCLUDED

#include "Primitive3D.h" 
#include "minorGems/math/geometry/Transform3D.h"  

#include "minorGems/io/Serializable.h"

#include "Primitive3DFactory.h"

/**
 * 3D object.
 *
 * Comprised of a collection of primitives.
 *
 * @author Jason Rohrer 
 */
00062 class Object3D : public Serializable { 
      
      public:
            
            
            /**
             * Constructs an Object.
             *
             * No parameters are copied, so they should not be destroyed
             * or re-accessed by caller.  All are destroyed when the 
             * object is destroyed.
             *
             * @param inNumPrimitives the number of primitives in this object.
             * @param inPrimitives the primitives comprising this object.
             * @param inTransform a transform for each object.
             */
            Object3D( long inNumPrimitives, Primitive3D **inPrimitives,
                  Transform3D **inTransform );
            
            Object3D();
            
            ~Object3D();
            
            
            /**
             * Copies this object.
             *
             * @return a copy of this object, which must be destroyed
             *   by the caller.
             */
            Object3D *copy();


            /**
             * Gets the number of parameters associated with this object.
             *
             * @return the number of parameters.
             */
            virtual int getNumParameters();

            
            /**
             * Gets the number of animations associated with this object.
             *
             * @return the number of animations.
             */
            virtual int getNumAnimations();

            
            /*
             * Note that the default implementations for all the parameter
             * and temporal animation functions do nothing.
             */
            
            /**
             * Sets a parameter for this object.
             *
             * @param inParameterIndex the index of the parameter to set.
             *   If an index for a non-existing parameter is specified,
             *   this call has no effect.
             * @param inValue the value to set the parameter to, in [-1, 1].
             *   The default value for all parameters is 0.
             */
            virtual void setParameter( int inParameterIndex, double inValue ); 


            /**
             * Gets a parameter for this object.
             *
             * @param inParameterIndex the index of the parameter to get.
             *   If an index for a non-existing parameter is specified,
             *   0 is returned.
             *
             * @return the value of the parameter, in [-1, 1].
             *   The default value for all parameters is 0.
             */
            virtual double getParameter( int inParameterIndex );
            
            
            /**
             * Steps this object forward in time.
             *
             * @param inStepSize the size of the timestep to take.
             */
            virtual void step( double inStepSize );


            /**
             * Starts a temporal animation of this object.
             * The animation progresses as step() is called repeatedly.
             * If called for a non-existent animation or for one that is
             * already running, this function has no effect.
             */
            virtual void startAnimation( int inAnimationIndex );

            
            /**
             * Stops a temporal animation of this object.  If called
             * for a non-existent animation or for one that is not currently
             * running, this function has no effect.
             */
            virtual void stopAnimation( int inAnimationIndex );

            
            long mNumPrimitives;
            
            Primitive3D **mPrimitives;
            
            Transform3D **mTransform;
            
            // implement the Serializable interface
            virtual int serialize( OutputStream *inOutputStream );
            virtual int deserialize( InputStream *inInputStream );
      
            char mMembersAllocated;
            
      };



00182 inline Object3D::Object3D( long inNumPrimitives, Primitive3D **inPrimitives,
      Transform3D **inTransform )
      : mNumPrimitives( inNumPrimitives ), mPrimitives( inPrimitives ),
      mTransform( inTransform ), mMembersAllocated( true ) {
            
      }



inline Object3D::Object3D()
      : mMembersAllocated( false ) {
            
      }



inline Object3D::~Object3D() {
      if( mMembersAllocated ) {
            for( int i=0; i<mNumPrimitives; i++ ) {
                  delete mPrimitives[i];
                  delete mTransform[i];
                  }
            delete [] mTransform;
            }
      }



00210 inline Object3D *Object3D::copy() {
      Object3D *objCopy = new Object3D();
      
      objCopy->mNumPrimitives = mNumPrimitives;
      
      objCopy->mPrimitives = new Primitive3D*[ mNumPrimitives ];
      objCopy->mTransform = new Transform3D*[ mNumPrimitives ];
      
      int i;
      for( i=0; i<mNumPrimitives; i++ ) {
            objCopy->mPrimitives[i] = mPrimitives[i]->copy();
            objCopy->mTransform[i] = new Transform3D( mTransform[i] );
            }
      
      objCopy->mMembersAllocated = true;
      
      return objCopy;   
      }



00231 inline int Object3D::getNumParameters() {
      return 0;
      }



00237 inline int Object3D::getNumAnimations() {
      return 0;
      }



// the base class versions of these functions do nothing

00245 inline void Object3D::setParameter( int inParameterIndex, double inValue ) {

      }



00251 inline double Object3D::getParameter( int inParameterIndex ) {

      return 0;
      }



00258 inline void Object3D::step( double inStepSize ) {

      }



00264 inline void Object3D::startAnimation( int inAnimationIndex ) {

      }



00270 inline void Object3D::stopAnimation( int inAnimationIndex ) {

      }


      
00276 inline int Object3D::serialize( OutputStream *inOutputStream ) {
      int i;
      int numBytes = 0;
      
      numBytes += inOutputStream->writeLong( mNumPrimitives );

      
      // write each primitive
      for( i=0; i<mNumPrimitives; i++ ) {
            // write a type flag for each primitive
            long typeFlag =
                  Primitive3DFactory::primitive3DToInt( mPrimitives[i] ); 
            numBytes += inOutputStream->writeLong( typeFlag );
            
            // write the primitive
            numBytes += mPrimitives[i]->serialize( inOutputStream );
            }

      // write each primitive's transform
      for( i=0; i<mNumPrimitives; i++ ) {
            numBytes += mTransform[i]->serialize( inOutputStream );
            }
      
      return numBytes;
      }
      
      
      
00304 inline int Object3D::deserialize( InputStream *inInputStream ) {
      
      if( mMembersAllocated ) {
            // first, delete current contents of object
            for( int i=0; i<mNumPrimitives; i++ ) {
                  delete mPrimitives[i];
                  delete mTransform[i];
                  }
            delete [] mPrimitives;
            delete [] mTransform;
            }
      
      int i;
      int numBytes = 0;
      
      numBytes += inInputStream->readLong( &mNumPrimitives );
      
      printf( "receiving %d primitives\n", mNumPrimitives );
      mPrimitives = new Primitive3D*[mNumPrimitives];
      
      for( i=0; i<mNumPrimitives; i++ ) {
            // read the type flag for this primitive
            long typeFlag;
            numBytes += inInputStream->readLong( &typeFlag );
            
            // construct a new object based on the type flag
            mPrimitives[i] =
                  Primitive3DFactory::intToPrimitive3D( typeFlag );

            // deserialize it
            numBytes += mPrimitives[i]->deserialize( inInputStream );
            }
      
      mTransform = new Transform3D*[mNumPrimitives];
      for( i=0; i<mNumPrimitives; i++ ) {
            mTransform[i] = new Transform3D();
            numBytes += mTransform[i]->deserialize( inInputStream );
            }
      
      mMembersAllocated = true;
      
      return numBytes;
      }


#endif

Generated by  Doxygen 1.6.0   Back to index