animationModel.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/animationModel.h"
#include "vrfobjcore/vrfObjectReference.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfutil/rwReal.h"
#include "vrfutil/rwString.h"
#include "vrfutil/rwInt.h"
#include "vrfutil/rwBoolean.h"
#include "vrfutil/rwTaitBryan.h"
#include "vrfutil/rwVector.h"
#include "vrfutil/scriptedMovementObject.h"
#include "vrfutil/movementFile.h"
#include "vrfutil/rwList.h"

class DtSimManager;
class DtDeadReckoner;


class DT_DLL_vrfobjcore DtAnimationModel : public DtReaderWriter
{
public:
   class AnimationChange : public DtReaderWriter
   {
   public:
      AnimationChange(const DtString&);

      virtual ~AnimationChange();

   public:
      DtRwInt myRow;
      DtRwInt myChange;
      DtRwVector myVector;
      DtRwTaitBryan myOrientation;
      DtRwReal myTimeDelta;
   };

   class AnimationChangeList : public DtRwList
   {
   public:
      AnimationChangeList();
      virtual ~AnimationChangeList();

      virtual void addAnimationChange(int row, int change, const DtVector& vector, const DtTaitBryan& orientation, double timeDelta);

      virtual DtlObjPtr getData(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
         const DtVariableBindingsList& variableBindings);
   };

public:
   //Constructor
   DtAnimationModel(DtVrfObject*,
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

   //Copy constructor
   DtAnimationModel(const DtAnimationModel& orig, 
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

   //Assignment Operator
   DtAnimationModel& operator=(const DtAnimationModel& orig);

   //Destructor
   virtual ~DtAnimationModel();

   virtual void setTimeScale(double d);
   virtual double timeScale() const;

   virtual void setReferencePoint(const DtVector&);
   virtual DtVector referencePoint() const;

   virtual void setReferenceOrientation(const DtTaitBryan&);
   virtual DtTaitBryan referenceOrientation() const;

   virtual void setTarget(const DtUUID&);

   virtual DtSharedVrfObjectReference target();

   virtual void setForceAutomaticOrientation(bool forceAuto);
   virtual const bool forceAutomaticOrientation() const;

   virtual void setMoveOutHeading(double);
   virtual double moveOutHeading() const;

   virtual void setScriptedMovementFile(const DtString&);
   virtual const DtString& scriptedMovementFile() const;

   virtual void setClampType(int);
   virtual int clampType() const;

   virtual void setCompletionRule(int);
   virtual int completionRule() const;

   virtual void setFileConfiguration(const DtString&);
   virtual const DtString& fileConfiguration() const;

   virtual double calculateOrientation(int frame, double dt, DtTaitBryan&, DtVector& rotationalVelocity) const;

   virtual DtVector calculateLocation(int frameA, int frameB = -1, double timePastFrameA = 0) const;

   virtual void calculateSpeed(int frame, DtVector& velocity) const;

   virtual DtVector targetPosition() const;

   virtual DtVector localReferencePosition() const;

   virtual DtTaitBryan targetOrientation() const;

   virtual DtVector groundClamp(const DtVector&) const;

   virtual DtVector bodyOffsetVector(int frame) const;

   virtual DtTaitBryan orientationOffset(int frame) const;

   virtual bool groundClampHighFidelity(const DtVector& location, double heading, DtTaitBryan& newLocalOrienationTb, DtVector& newLocalLocation) const;

   virtual DtVector velocityForFrame(int frame) const;

   virtual DtVector calculateRotationalVelocity(int frame, double dt) const;

   virtual DtVector calculateRotationalVelocity(const DtTaitBryan& currentFrame, int frame) const;

   virtual DtVector heightAdjustedLocation(const DtVector&) const;

   virtual DtTaitBryan orientationForFrame(int frame, double& heading) const;

   virtual bool canBeAnimated() const;

   virtual int animationRow(double, int frameHint = 0) const;

   virtual int animationRows() const;

   virtual double deltaTimeForFrame(int frame) const;

   virtual void resetAnimationVariables();

   virtual void reset();

   virtual void setupForAnimation();

   virtual double simulationTime(int) const;

   virtual void setFrameTime(double);

   virtual double frameTime() const;

   virtual void setAnimationFrame(int);
   virtual int animationFrame() const;

   virtual void setNeedsSetup(bool);
   virtual bool needsSetup() const;

   virtual bool simulate(double simulateFor, DtVector& newLocation, DtTaitBryan& newOrientation,
      DtVector& newVelocity, DtVector& newRotationalVelocity, bool debug = false);

   virtual void setElapsedAnimationTime(double);
   virtual double elapsedAnimationTime() const;

   virtual void setTransitionSpeed(double);
   virtual double transitionSpeed() const;

   virtual int setObjectOffsetLocation(int row, const DtVector&);

   virtual int setObjectOffsetOrientation(int row, const DtTaitBryan&);

   virtual void setTimeDeltaFromPreviousRow(int forRow, double timeDelta);

   virtual int addAnimationRow(double deltaTime, double lateral, double range, double altitude,
      double headingOffset = 0, double pitchOffset = 0, double rollOffset = 0);

   virtual void removeRow(int);

   virtual void setEntity(DtVrfObject*);
   virtual DtVrfObject* entity() const;
   virtual const char* readerWriterType() const;

   virtual int frameToTravelSpeed(int base, double speed) const;

   virtual double lastSimulationTime() const;

   virtual bool isFinished() const;

protected:

   void createDeadReckoner();

   static void objectAboutToBeRemovedCallback(DtVrfObject* object, void* usr);
   virtual void processObjectAboutToBeRemoved(DtVrfObject*);

   virtual void putSelf(std::string& fp, int indentLevel, bool writeUnspecified,
                              const DtFilename& path);

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

   virtual void initializeReferenceObject();

   virtual int nextFrameToMaintainSpeed(int frame, double speed) const;

   virtual void deadReckon(double overTime, DtVector& newWorldLocation,
      DtTaitBryan& newLocalOrientation, DtVector& newVelocity, 
      DtVector& newRotationalVelocity) const;

protected:
   DtMovementFile myMovementFile;

   DtVrfObject* myEntity;

   DtRwReal myTimeScale;
   DtRwVector myReferencePoint;
   DtRwTaitBryan myReferenceOrientation;
   DtRwVrfObjectReference myTarget;
   DtRwReal myMoveOutHeading;
   DtRwString myScriptedMovementFile;
   DtRwInt myClampType;
   DtRwInt myCompletionRule;
   DtRwString myFileConfiguration;
   DtRwReal myFrameTime;
   DtRwBoolean myMaintainCurrentSpeed;
   DtRwInt myAnimationFrame;
   DtRwBoolean myLastFrameWasAnimated;
   DtRwReal myTransitionSpeed;
   DtRwReal myElapsedAnimationTime;
   DtRwReal myLastAnimationFrameTime;
   DtRwBoolean myForceAutomaticOrientation;

   struct LocalAnimationChange
   {
      LocalAnimationChange() : change(0), timeDelta(0) {};
      LocalAnimationChange(const LocalAnimationChange& orig) : change(orig.change),
         vector(orig.vector), orientation(orig.orientation), timeDelta(orig.timeDelta) {};
      virtual ~LocalAnimationChange() {};

      int change;

      DtVector vector;

      DtTaitBryan orientation;

      double timeDelta;
   };

   typedef std::map<int, LocalAnimationChange> AnimationChanges;
   AnimationChanges myAnimationChanges;

   DtTaitBryan myLastOrientation;
   DtVector myLastLocation;
   DtVector myLastRotationalVelocity;
   DtVector myLastRelativeVelocity;
   DtVector myLastVelocity;

   DtVector myOriginalLocation;
   DtTaitBryan myOriginalOrientation;

   double myLastSimulationTime;
   DtRwBoolean myNeedsSetup;

   DtDeadReckoner* myDeadReckoner;

   bool myIsEmbarked;
};