simObjectStateRepository.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2001 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once



#include "vrfutil/readerWriter.h"
#include <vlutil/vlString.h>
#include <vlpi/disEnums.h>
#include <vrfExtProtocol/objectType.h>
#include <vlutil/vlString.h>
#include <vl/hostStructs.h>
#include "vrfobjcore/simKinematicState.h"
#include "vrfobjcore/vrfObjectGeometry.h"
#include "vrfobjcore/vrfObjectReference.h"
#include "vrfobjcore/simObjectStateRepositoryFactory.h"
#include "vrfutil/rwObjectType.h"
#include "vrfutil/rwForceType.h"
#include "vrfutil/rwString.h"
#include <vrfutil/rwUUID.h>

class DtVrfObject;
class DtAttachmentManager;
class DtVrfObjectGeometry;
class DtVrfKinematicState;

#include "vrfobjcore/vrfobjcoreDefines.h"
class DT_DLL_vrfobjcore DtSimObjectStateRepository : public DtReaderWriter
{
public:
   DtSimObjectStateRepository(DtVrfObject* simObject, 
      const DtObjectType& objectType, 
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

protected:
   DtSimObjectStateRepository(const DtSimObjectStateRepository& orig,
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

public:

   const DtSimObjectStateRepository& operator=(
      const DtSimObjectStateRepository& orig);

   virtual ~DtSimObjectStateRepository();

   virtual DtSimObjectStateRepository* clone(
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0) const;

   virtual DtString type() const;

   virtual const int objectStateRepositorySubType() const;

   virtual bool init();

   virtual void updatePositionFromModelVertices();
   virtual void updateBVolFromModelVertices();

   virtual const DtObjectType& objectType() const;
   virtual void setObjectType(const DtObjectType& objectType);

   virtual bool createKinematicState();
   virtual DtVrfKinematicState* vrfKinematicState();
   virtual const DtVrfKinematicState* vrfKinematicState() const;

   virtual bool createObjectGeometry();
   virtual DtVrfObjectGeometry* vrfObjectGeometry();
   virtual const DtVrfObjectGeometry* vrfObjectGeometry() const;

   virtual bool createAttachments();
   virtual DtAttachmentManager* attachments();
   virtual const DtAttachmentManager* attachments() const;

   virtual DtSimObjectStateRepository* parent();
   virtual const DtSimObjectStateRepository* parent() const;

   virtual bool isEmbarkedOn(const DtUUID& parent) const;

   virtual void attachToParent(const DtUUID& parent);

   virtual void attachToParent(DtSimObjectStateRepository* parent);

   virtual void detachFromParent();

   virtual const DtUUID& attachedToRepository();

   virtual DtSimObjectStateRepository* findRootSimStateRepository();
   virtual const DtSimObjectStateRepository* findRootSimStateRepository()
       const;

   virtual void ancestorObjectChanged();

   virtual void getSelf(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);  

   virtual void preGetSelf() {}
   
   virtual void postGetSelf() {}


   static void completeAttachmentCallback(DtVrfObject * simObject, void * usr);
   virtual bool processCompleteAttachment(DtVrfObject*);
   static void objectAboutToBeRemovedCallback(DtVrfObject * simObject, void * usr);
   virtual void processObjectAboutToBeRemovedCallback(DtVrfObject * simObject);

   static DtSimObjectStateRepository* isSimObjectStateRepository(
      DtSimObjectStateRepository* repository);

   static const DtSimObjectStateRepository* isSimObjectStateRepository(
      const DtSimObjectStateRepository* repository);

   virtual class DtVrfObjectStateRepository* toVrfObjectStateRepository();
   virtual const class DtVrfObjectStateRepository* toVrfObjectStateRepository() const;

   virtual void setCoordinateSystem(const Coordinate_System* coordinateSystem);

   virtual DtVrfObject* vrfObject();
   virtual const DtVrfObject* vrfObject() const;
   virtual void setVrfObject(DtVrfObject* vrfObject);

   virtual DtSimKinematicState* kinematicState();
   virtual const DtSimKinematicState* kinematicState() const;

   virtual DtVrfObjectGeometry* objectGeometry();
   virtual const DtVrfObjectGeometry* objectGeometry() const;

   //***

   virtual const DtVector & bodyPosition() const;

   virtual void setBodyPosition(const DtVector & pos);
   virtual void setBodyPosition(DtFloat64 x, DtFloat64 y, DtFloat64 z);

   const DtDcm & bodyOrientationMatrix() const;

   virtual void embarkOnParent(const DtUUID& parent);

public:
   virtual void removeVertex(int iIndex);
   virtual void addLocalVertex(const DtVector& vertex);
   virtual void addLocalVertex(const DtVector& vertex, DtVector& newGeometricCenter);
   virtual void setLocalVertices(const DtLocalVertexList& vertices, DtVector& newGeometricCenter);
   virtual void setLocalVertices(const DtList& vertices, DtVector& newGeometricCenter);
   virtual const DtLocalVertexList& localVertices() const;
   virtual const DtLocalVectorIterator& localVertexIterator() const;

   virtual void addWorldVertex(const DtVector& vertex, DtVector& newGeometricCenter);
   virtual void setWorldVertices(const DtVertexList& vertices, DtVector& newGeometricCenter);
   virtual void setWorldVertices(const DtList& vertices, DtVector& newGeometricCenter);
   virtual const DtVertexList& worldVertices() const;
   virtual const DtRwVectorIterator& worldVertexIterator() const;

   virtual void setRelativeVertices(const DtLocalVertexList& vertices);
   virtual void setRelativeVertices(const DtList& vertices);
   virtual const DtLocalVertexList& relativeVertices() const;
   virtual const DtLocalVectorIterator& relativeVertexIterator() const;

   virtual bool leftOf(const DtVector& localVector) const;
   virtual bool inside(const DtVector& point) const;

   const DtVector & localPosition() const;
   void setLocalPosition(const DtVector & pos);

   const DtVector & localVelocity() const;
   void setLocalVelocity(const DtVector & vel);

   const DtVector & localAcceleration() const;
   void setLocalAcceleration(const DtVector & acc);

   const DtVector & relativeVelocity() const;
   void setRelativeVelocity(const DtVector & vel);

   const DtVector & relativeAcceleration() const;
   void setRelativeAcceleration(const DtVector & acc);

   const DtTaitBryan & localOrientation() const;
   void setLocalOrientation(const DtTaitBryan & angles);

   const DtVector & worldPosition() const;
   void setWorldPosition(const DtVector & pos);

   const DtVector & worldVelocity() const;
   void setWorldVelocity(const DtVector & vel);

   const DtVector & worldAcceleration() const;
   void setWorldAcceleration(const DtVector & acc);

   const DtTaitBryan & worldOrientation() const;
   void setWorldOrientation(const DtTaitBryan & angles);

   const DtVector &rotationalVelocity() const;
   void setRotationalVelocity(const DtVector& rotationalVelocity);

   const DtDcm & localOrientationMatrix() const;
   void setLocalOrientationMatrix(const DtDcm & orient);

   virtual double distanceToLocalVector(const DtVector& localVector) const;

   const Coordinate_System* coordinateSystem() const;

protected:
   DtSimObjectStateRepository();

   virtual void setOrientationRelativeToParent();

protected:

   DtVrfObject*             mySimObject;

   DtRwObjectType           myObjectType;

   DtVrfObjectGeometry*     myObjectGeometry;
   DtVrfKinematicState*     myKinematicState;

   DtAttachmentManager*     myAttachments;

   DtSimObjectStateRepository* myAttachedToRepository;

   DtRwUUID myAttachedToRepositoryUUID;

   DtSimObjectStateRepository* myRootSimStateRepository;

   const Coordinate_System* myCoordinateSystemPtr;   

   DtKinematicStateCS* myEmbarkedKinematicState;
};