Initial source commit

minorGems/graphics/3d/Object3D.h

@@ -0,0 +1,349 @@
+/*
+ * 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 
+ */
+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;
+		
+	};
+
+
+
+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;
+		}
+	}
+
+
+
+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;	
+	}
+
+
+
+inline int Object3D::getNumParameters() {
+	return 0;
+	}
+
+
+
+inline int Object3D::getNumAnimations() {
+	return 0;
+	}
+
+
+
+// the base class versions of these functions do nothing
+
+inline void Object3D::setParameter( int inParameterIndex, double inValue ) {
+
+	}
+
+
+
+inline double Object3D::getParameter( int inParameterIndex ) {
+
+	return 0;
+	}
+
+
+
+inline void Object3D::step( double inStepSize ) {
+
+	}
+
+
+
+inline void Object3D::startAnimation( int inAnimationIndex ) {
+
+	}
+
+
+
+inline void Object3D::stopAnimation( int inAnimationIndex ) {
+
+	}
+
+
+	
+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;
+	}
+	
+	
+	
+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