objectSensor.h

Go to the documentation of this file.

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


#pragma once

#include "vrfobjcore/simComponent.h"
#include "vrfobjcore/managedObjectList.h"
#include "vrfobjcore/platformLocalObjectFacade.h"
#include "vrfmodel/vrfmodelDefines.h"
#include <vrfutil/rwEntityTypeList.h>
#include "vrfExtObjects/sensorFieldOfViewEnums.h"

class DtSensorContactListOutputPort;
class DtEntityTypesListMultiInputPort;
class DtObjectSensorDescriptor;
class DtObjectSensorPSR;
class DtRwSensorContactInfo;
class DtObjectSensorMonitor;
class DtSpatialFilterEvaluator;
class DtCompositePredicate;
class DtEntityType;
class DtNLengthIntegerVector;
class DtOrientationInputPort;
class DtVectorInputPort;
class DtInputPortGroup;
class DtStringInputPort;
class DtBooleanInputPort;
class DtIntegerInputPort;
class DtLocalizedManagedObjectList;
class DtInterruptFlag;

class DT_DLL_vrfmodel DtObjectSensor : public DtSimComponent
{
private:
   DtObjectSensor();

   DtObjectSensor(const DtObjectSensor & 
      orig);

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

public:

   enum ContinueDetectingResult
   {
      DetectionLost = 0,
      DetectionContinued = 1,
      DetectionMissed = 2,
   };

   struct DtProcessObjectsState
   {
      DtProcessObjectsState() 
      {
         psrContactListItem = nullptr;
         changesMade = false;
         isComplete = false;
      }
      DtListItem* psrContactListItem;
      std::shared_ptr<DtLocalizedManagedObjectList> currentlyDetectableObjectList;
      DtManagedObjectList::const_iterator nextDetectableObject;
      bool changesMade;
      typedef std::set<DtUUID> TargetSet;
      TargetSet checkedTargets;
      bool isComplete;

   };

   using DtSimComponent::tick;

   DtObjectSensor(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtObjectSensor() override;

   virtual bool init() override;

   virtual bool postAddComponentsInit() override;

   virtual void preFirstTickInit() override;

   virtual const char* type() const override;

   virtual void tick() override;

   virtual bool tickWhileDestroyed() const override;

   virtual int sensorType() const;

   virtual void enable() override;
   virtual void disable() override;
   virtual void setIsEnabled(bool yesNo) override;

   virtual void setTypesToDetectForTask(const DtRwEntityTypeList& objectTypes);

   virtual void clearTypesToDetectForTask();

   virtual const DtRwEntityTypeList& typesToDetectForTask() const;

   static bool setTypesToDetectAttribute(void* ctrlr, DtReaderWriter* val);
   virtual bool setTypesToDetectAttribute(DtReaderWriter* val);

   static bool clearTypesToDetect(void* ctrlr, DtReaderWriter* val);
   virtual bool clearTypesToDetect(DtReaderWriter* val);

   static DtReaderWriter* getSensorPositionAttribute(void* ctrlr);
   virtual DtReaderWriter* getSensorPositionAttribute();

   virtual void setSensorEnabled(bool enabled);

   virtual bool sensorEnabled() const;

   static DtSimComponent * creator(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   static void printDiagnosticsCallback(const DtVrfObjectMessage* msg, void* usr);

protected:

   virtual bool createPortGroups() override;

   virtual bool createPorts() override;

   virtual DtObjectSensorPSR* createPSR();

   virtual const char* defaultPSRType() const;

   virtual void initSensorRangeRing();

   virtual void updateDetectableObjectsList();

   virtual bool initSensorGeometry();

   virtual void setupGeometryForDetection();

   virtual DtVector localSensorPosition() const;

   virtual DtVector bodySensorPosition() const;

   virtual DtTaitBryan localSensorOrientation() const;

   virtual DtTaitBryan bodySensorOrientation() const;

   virtual DtUUID targetObject() const;

   virtual DtVector targetLocation() const;

   virtual DtSensorTrackingMode trackingMode() const;

   virtual void processObjects();


   virtual void processObjectsSlice(const DtInterruptFlag& timer);

   virtual bool detectObject(DtSimObjectReference object, 
      DtRwSensorContactInfo* contactInfo);

   virtual ContinueDetectingResult continueDetectingObject(DtSimObjectReference object,
      DtRwSensorContactInfo* contactInfo, bool& contactInfoModified);

   virtual bool objectWithinSensorGeometry(const DtSimObject* object) const;

   virtual bool sensorGeometryExtent(DtExtent& extent) const;

   virtual double rangeSquaredToObject(const DtSimObject* object) const;

   virtual double rangeToObject(const DtSimObject* object) const;

   virtual void clearObjectRangeCache() const;

   virtual void printTargets() const;

   virtual void updateDetectedObjectListPort();

   virtual bool createAndInitSensorMonitors();

   virtual bool objectInDetectableList(const DtSimObject*) const;

   static void hostilitiesChangedCallback(DtU8 force, void* usr);
   virtual void processHostilitiesChanged(DtU8 force);

   virtual DtTaitBryan worldOrientationOfObject(const DtSimObject* object) const;

   virtual bool canDetectForceOfObject(const DtSimObject*);

   static void setSensorEnabledRequestCallback(DtSimMessage *msg, void * usrData);

   virtual void processSetSensorEnabledRequestMessage(DtSimMessage *msg);

   virtual void notifyContactsChanged();

   virtual void printDiagnostics(const DtVrfObjectMessage* msg);

protected:


   DtSensorContactListOutputPort * myDetectedObjectListPort;

   DtEntityTypesListMultiInputPort* myObjectsToDetectInputPort;

   

   DtInputPortGroup* mySensorOffsetInputPortGroup;

   DtOrientationInputPort* myOrientationInputPort;

   DtVectorInputPort* myPositionInputPort;

   DtStringInputPort* myTargetObjectInputPort;

   DtVectorInputPort* myTargetLocationInputPort;

   DtIntegerInputPort* myTrackingModeInputPort;

   DtBooleanInputPort* myTargetAcquiredInputPort;


   DtManagedObjectListConstPtr myDetectableObjectList;
   const DtObjectSensorDescriptor* myObjectSensorDescriptor;

   DtObjectSensorPSR* myProcessState;

   std::vector<DtObjectSensorMonitor*> myMonitors;
   DtSpatialFilterEvaluator* mySensorGeometryEvaluator;

   DtForceType myForceType;

   mutable const DtSimObject* myMutableObjectCached;
   mutable bool myMutableObjectRangeCalculated;
   mutable double myMutableObjectRangeCache;
   mutable bool myMutableObjectRangeSquaredCalculated;
   mutable double myMutableObjectRangeSquaredCache;
   
   bool myGeometrySetup;

   bool myPrep_invokeNewContactCallbacks;
   DtPlatformLocalObjectFacade myPlatformLocalObjectFacade;

   std::shared_ptr<DtProcessObjectsState> myProcessObjectsState;
};