---

SkeletalPrimitive.hpp

Go to the documentation of this file.

//
//       Title           : SkeletalPrimitive.hpp
//       Project         : D&D Demos
//       Created         : Apr. 18, 2005
//       Author          : Troy Harden, Ethan Swint, Andrew Spencer
//       Platforms       : All
//       Copyright       : Copyright© The University of Texas at Austin, 2002. All rights reserved.
//                 
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//        Purpose         : Abstract skeletal obstacle .  Defines the skeletal obstacle
//                         interface for the various obstacles.
//
//----------------------------------------------------------------------------
//
//       $Revisions$
//
//       $Log: SkeletalPrimitive.hpp,v $
//       Revision 1.18  2005/06/20 22:43:07  aspencer
//       Changed UpdateInternalParamaters to updateInternalParameters
//
//       Revision 1.17  2005/06/10 17:03:20  josh
//       Added Clone method.
//
//       Revision 1.16  2005/06/07 23:08:00  aspencer
//       Added a virtual update function to ModelingObject. Made all inheriting, implemented Update functions virtual as well.
//
//       Revision 1.15  2005/06/07 20:11:54  aspencer
//       Changed over to the new version of Node. Made appropriate changes in other files as a result. LoadRev2File in ObAvData no longer populates a node tree.
//
//       Revision 1.14  2005/06/07 18:20:48  aspencer
//       Changed how SOLID functionality was implemented so that there are no #ifdef _SOLID tags in the header files which would cause errors when the header file was included in another library.
//
//       Revision 1.13  2005/06/07 15:50:52  aspencer
//       Moved the default constructor to not be an inline function, as it was causing problems whem both the filedata and the OA libraries were used.
//
//       Revision 1.12  2005/06/07 00:08:13  aspencer
//       When a point was being set in a Plane object, the r, n, and s vectors were not automatically being updated. This is completely wrong and has now been fixed.
//
//       Revision 1.11  2005/06/06 23:28:25  aspencer
//       Fixed a syntax error
//
//       Revision 1.10  2005/06/06 23:26:14  aspencer
//       Changed all "SetInfo" functions to be "SetProperties" functions.
//
//       Revision 1.9  2005/06/03 20:03:55  aspencer
//       Changed the "GetPoint" method so that it now returns a pointer. This allows error checking, such that if the index parameter is out of range a NULL pointer can be returned. Also removed the "normal" protected atribute from the class.
//
//       Revision 1.8  2005/06/03 18:32:44  aspencer
//       Corrected header files
//
//       Revision 1.7  2005/06/02 16:38:56  aspencer
//       Moved the protected attribute localToGlobal Xform from BoxOb.hpp, ConeOb.hpp, and SkeletalPrimitive.hpp to the abstract base class ModelingObject.hpp
//
//       Revision 1.6  2005/06/01 22:27:33  chetan
//       Made changes to copyright headers
//
//       Revision 1.5  2005/06/01 19:51:06  aspencer
//       Continued making commenting changes.
//
//       Revision 1.4  2005/06/01 19:51:06  aspencer
//       Made further changes to commenting.
//
//       Revision 1.3  2005/05/31 19:38:43  aspencer
//       Changes to various function names in the primitive classes (trying to fit the "Get/Set" scheme of the rest of OSCAR). Also moved some code in primitive files from .hpp to .cpp, as it should be.
//
//       Revision 1.2  2005/05/27 15:56:49  aspencer
//       Changed "Reference" enumeration to "ReferenceFrame"
//
//       Revision 1.1  2005/05/26 21:02:43  aspencer
//       Changed "obstacle" to "primitive" in both the obstacle and the skeletalobstacle class. Inserted "modeling object" abstract class, which primitive (was obstacle) now inherits from. Updated the rest of OSCAR to reflect this/Initial Commit
//
//

#ifndef SkeletalPrimitive_h
#define SkeletalPrimitive_h

//Includes go here
#include "Primitive.hpp"

namespace OSCAR { 
class SkeletalPrimitive : public Primitive
{
public:

  SkeletalPrimitive(double rad = 0.0);

  bool SetProperties(const vector<Vector3>& pts, double rd);

  virtual ~SkeletalPrimitive(){  }

        virtual SkeletalPrimitive* Clone() const = 0;

  double GetRadius() const { return radius; }

  bool SetRadius(double rd);

  unsigned int Size() const;

  SkeletalPrimitive(const SkeletalPrimitive& arg);

  SkeletalPrimitive& operator=(const SkeletalPrimitive& rhs);

  virtual bool SetPoint(unsigned int index, const Vector3& pt);

  bool SetPoints(const vector<Vector3> pts);

  const Vector3* GetPoint(unsigned int index, ReferenceFrame globalOrLocal = Global) const;

  virtual bool Update(const Xform& transform);

  /* Legacy code: currently unimplemented and un-needed
  bool UpdateSinglePoint(const Xform& transform, const unsigned int index);
  */

  const vector<Vector3>& GetPoints(ReferenceFrame globalOrLocal = Global) const { return point[globalOrLocal]; }
  
  //Below is a function which is no longer needed
  //vector<Vector3>& GetPoints(ReferenceFrame globalOrLocal = Global) { return point[globalOrLocal]; }

  unsigned int AddPoint(const Vector3& newPt);//, ReferenceFrame globalOrLocal = Global);

  bool Clear(){point[Local].clear(); point[Global].clear(); radius=0; return true;}

protected:
  double radius;
  vector<Vector3> point[2];

  //Automatically updates any internal parameters (such as the r,n, and s vectors contained in plane)
  //Is called whenever a local point is changed by the user, but is only further implemented in Plane.cpp since it is the only
  //inheriting primitive which has internal parameters which need to be updated when a point is changed.
  virtual bool updateInternalParameters(){return false;};

};

#include "SkeletalPrimitive.ipp"
}  //namespace OSCAR
#endif //SkeletalPrimitive_h

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations