humanStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <vrfOM/sets/writeDIGuyAppearanceRepository.hpp>
#include <vrfOM/sets/readDIGuyAppearanceRepository.hpp>
#include <legionStandardOM/sets/writeLifeformRepository.hpp>
#include <legionStandardOM/sets/readLifeformRepository.hpp>
#include <vlpi/patchIdentifier.h>
#include <matrix/vlVector.h>

namespace makVrf
{


   class DT_DLL_vrfStateData DtHumanStateComponent : public DtFrameStateInterface
   {
   public:

      DEFINE_STATE_COMPONENT_TYPE( DtStateComponent::HumanStateComponent )

      DtHumanStateComponent( DtStateData* sd )
         : DtFrameStateInterface( sd )
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtString, diguyAppearance, DiguyAppearance );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtString, diguyType, DiguyType );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtString, diguyHeadAppearance, DiguyHeadAppearance );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtString, diguyItemAppearance, DiguyItemAppearance );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtPatchIdentifier, diguyPrimaryUnitPatch, DiguyPrimaryUnitPatch );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtPatchIdentifier, diguySecondaryUnitPatch, DiguySecondaryUnitPatch );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtPatchIdentifier, diguyRankPatch, DiguyRankPatch );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtString, diguyCharacterName, DiguyCharacterName );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtString, diguyAction, DiguyAction );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( double, bodyWeight, BodyWeight );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( bool, diguyUsingAnimationOffset, DiguyUsingAnimationOffset );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( DtVector, diguyAnimationOffset, DiguyAnimationOffset );
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR( float, diguyTransitionSpeed, DiguyTransitionSpeed );

      virtual void setDiguyType( const DtString& newType, const DtString& newAppearance ) { throw DtUnimplementedMethod("setDiguyType() is not implemented for this class"); };
   };

   class DT_DLL_vrfStateData DtHumanStateComponentNextFrame : public DtHumanStateComponent
   {
   public:

      DtHumanStateComponentNextFrame(DtStateData* sd);
      virtual ~DtHumanStateComponentNextFrame();

      const DtString diguyAppearance() const;
      void setDiguyAppearance(const DtString&);

      const DtString diguyType() const;
      void setDiguyType(const DtString&);

      const DtString diguyHeadAppearance() const;
      void setDiguyHeadAppearance(const DtString&);

      const DtString diguyItemAppearance() const;
      void setDiguyItemAppearance(const DtString&);

      const DtPatchIdentifier diguyPrimaryUnitPatch() const;
      void setDiguyPrimaryUnitPatch( const DtPatchIdentifier& );

      const DtPatchIdentifier diguySecondaryUnitPatch() const;
      void setDiguySecondaryUnitPatch( const DtPatchIdentifier& );

      const DtPatchIdentifier diguyRankPatch() const;
      void setDiguyRankPatch( const DtPatchIdentifier& );

      const DtString diguyCharacterName() const;
      void setDiguyCharacterName( const DtString& );

      const DtString diguyAction() const;
      void setDiguyAction(const DtString&);

      const double bodyWeight() const;
      void setBodyWeight(const double&);

      const bool diguyUsingAnimationOffset() const;
      void setDiguyUsingAnimationOffset(const bool&);

      const float diguyTransitionSpeed() const;
      void setDiguyTransitionSpeed(const float&);

      const DtVector diguyAnimationOffset() const;
      void setDiguyAnimationOffset(const DtVector&);

      void setDiguyType( const DtString& newType, const DtString& newAppearance );

      virtual void makeWritable();

      virtual void makeReadOnly();

   protected:

      VRF::WriteDIGuyAppearanceRepository myWriteHumanComponent;
      LOM::WriteLifeformRepository myWriteLifeformRepository;
      DtStateData* myStateData;

   };

   class DT_DLL_vrfStateData DtHumanStateComponentCurrentFrame : public DtHumanStateComponent
   {
   public:

      DtHumanStateComponentCurrentFrame( DtStateData* );

      virtual ~DtHumanStateComponentCurrentFrame();

      const DtString diguyAppearance() const;
      const DtString diguyType() const;
      const DtString diguyHeadAppearance() const;
      const DtString diguyItemAppearance() const;
      const DtPatchIdentifier diguyPrimaryUnitPatch() const;
      const DtPatchIdentifier diguySecondaryUnitPatch() const;
      const DtPatchIdentifier diguyRankPatch() const;
      const DtString diguyCharacterName() const;
      const DtString diguyAction() const;
      const double bodyWeight() const;
      const bool diguyUsingAnimationOffset() const;
      const DtVector diguyAnimationOffset() const;
      const float diguyTransitionSpeed() const;

      bool readComponentValid() const;

      bool findReadComponent();

   protected:

      VRF::ReadDIGuyAppearanceRepository myReadHumanComponent;
      LOM::ReadLifeformRepository myReadLifeformRepository;
      DtStateData* myStateData;

   };

   class DT_DLL_vrfStateData DtHumanStateComponentImplementation : public DtDoubleBufferedStateComponent<DtHumanStateComponent>
   {
   public:

      DtHumanStateComponentImplementation(DtStateData* sd);
      virtual ~DtHumanStateComponentImplementation();

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage();

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual bool forceAdvance();

      virtual void firstFrameAdvance() override;

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtHumanStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:

      DtHumanStateComponentCurrentFrame myCurrentFrameState;
      DtHumanStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;

   };


   typedef DtStateComponentCreator<DtHumanStateComponentImplementation> DtHumanStateComponentCreator;

}