DtInstanceManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtInstanceState.h>
#include <vrvOsg/DtInstancedCullSet.h>
#include <vrvOsg/DtOsgTextureBufferObjectApplyAttribute.h>

#include <vrvCore/DtModel.h>
#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlVector.h>

#include <osgUtil/LineSegmentIntersector>
#include <osgViewer/Renderer>

#include <osg/ref_ptr>
#include <osg/LightSource>

#include <boost/unordered_map.hpp>
#include <tbb/cache_aligned_allocator.h>
#include <tbb/atomic.h>
#include <tbb/spin_rw_mutex.h>
#include <tbb/concurrent_queue.h>


class DtTaitBryan;

namespace osg
{
   class Geometry;
   class Image;
   class Texture2D;
   class Vec2f;
   class Vec3f;
   class Geode;
   class View;
}

namespace osgEarth
{
   class VirtualProgram;
}

namespace makVrv
{
   class DtGlTextureBufferObject;
   class DtInstanceProcessor;
   class DtInstanceLpProcessor;
   class DtOsgIntersectorResult;
   class DtChannelManager;
   class DtChannel;
   class DtPerViewUniformCallback;
   class DtInstanceNode;
   class DtLight;
   class DtOsgCullVisitorParameters;
   class DtViewSpecificGroup;
   class DtInstanceManagerTboUpdater;

   class DT_DLL_VRVOSG DtInstanceManager : public DtVirtualBaseClass, public DtSignalConnectionManager
   {
   public:
      typedef std::vector<osg::ref_ptr<osg::Geometry> > GeometryVec;
      typedef std::vector<char> BoolVec; // Using vec of chars for threadsafety
      typedef std::vector<char> ByteVec;
      typedef std::map<osg::ref_ptr< osgEarth::VirtualProgram >, osg::ref_ptr<osgEarth::VirtualProgram> > VpMap;
      typedef std::vector<osg::ref_ptr<osgEarth::VirtualProgram> > VpRefList;
      typedef std::vector<ArrayRange> DrawableRangeVec;
      typedef std::vector<osg::Vec2f> TextureCoordinateVec;
      typedef std::vector<float> FloatVec;

      static const unsigned int NumVec4PerInstance = 8;


      struct InstancedLod
      {
         double minRange;

         double maxRange;

         ArrayRange drawableRange;
      };

      struct InstancedSwitch
      {
         DrawableRangeVec switchRanges;

         BoolVec switchStates;

         BoolVec defaultSwitchStates;
      };

      struct InstancedSequence
      {
         enum SequenceMode { Play, Stop, Pause, Resume };

         DrawableRangeVec switchRanges;

         float timePerFrame;

         float startTime;

         float endTime;

         SequenceMode mode;

         float speed;

         int lastFrame;
      };

      struct InstancedLight
      {
         InstancedLight() : light(0), drawableIx(0) { ; }
         DtLight* light;
         osg::Vec3f position;
         osg::Vec3f direction;
         unsigned int drawableIx; // index to drawable the light is attached to
      };

      struct InstancedDof
      {
         InstancedDof() : numChildren(0), myAnimatedMatrix(NULL), skipNextAnimationFrame(false) { ; }
         InstanceMatrix transform;

         unsigned int numChildren;

         ArrayRange drawableRange;

         bool skipNextAnimationFrame;

         osg::MatrixTransform* myAnimatedMatrix;
      };

      struct ModelTypeDofData
      {
         ModelTypeDofData() : numChildren(0) { ; }
         InstanceMatrix putMatrix;

         InstanceMatrix putMatrixInverse;

         InstanceMatrix initialTransform;

         osg::Vec3f initialHpr;

         osg::Vec3f initialTranslate;

         unsigned int numChildren;

         ArrayRange drawableRange;

         std::string myAnimatedMatrixName;
      };

      struct DofAnimation
      {
         DofAnimation() : lastUpdate(-1), smoothCompleteTime(0) { ; }
         osg::Vec3f trans;

         osg::Vec3f transVel;

         osg::Vec3f hpr;

         osg::Vec3f hprVel;

         float lastUpdate;

         float smoothCompleteTime;

         osg::Vec3f smoothTransVel;

         osg::Vec3f smoothHprVel;


      };

      struct LightSource
      {
         LightSource() : attachDrawableIx(0), range(0), isRangeScheme(false) { ; }
         osg::ref_ptr<osg::LightSource> lightSource;
         unsigned int attachDrawableIx;
         float range;
         bool isRangeScheme;
      };

      struct LightPoint
      {
         LightPoint() : attachDrawableIx(0), groupId(0) { ; }
         osg::ref_ptr<osg::Node> lightPoint;
         unsigned int attachDrawableIx;
         int groupId;
      };

      struct InstanceBuffer
      {
         const osg::View* view;

         DtGlTextureBufferObject* image;

         osg::ref_ptr<TextureBufferObjectApplyAttribute> applyAttribute;
      };

      typedef std::vector<LightSource> LightSourceVec;
      typedef std::vector<ModelTypeDofData> PerDofDataVec;
      typedef std::vector<InstancedSwitch> InstancedSwitchVec;
      typedef std::vector<InstancedSequence> InstancedSequenceVec;
      typedef std::vector<DofAnimation> DofAnimations;
      typedef std::vector<osg::Node*> NodeVec;
      typedef std::vector<InstancedSwitch*> SwitchVec;
      typedef std::vector<InstancedSequence*> SequenceVec;
      typedef std::vector<InstancedLod*> LodVec;
      typedef std::vector<LightPoint> LightPointVec;

      struct InstanceTemplate
      {
          InstanceTemplate()
              : myAnimatedNodeCount(0)
              , boundingRadius(0.0f)
              , intersectionBoundingRadius(0.0f)
              , nodeMask(0)
              , daylightControlledLights(false)
          { ; }

         std::string myName;

         PerDofDataVec dofTemplate;

         LightSourceVec lightSources;

         LightPointVec lightPoints;

         InstancedSwitchVec switchTemplate;

         InstancedSequenceVec sequenceTemplate;

         ArrayRange drawableRange;

         ArrayRange instanceMatrixRange;

         ArrayRange lodRange;

         float boundingRadius;

         float intersectionBoundingRadius;

         osg::Vec3f boundingCenter;

         unsigned int nodeMask;

         osg::ref_ptr<osg::Geode> modelGeode;

         bool daylightControlledLights;

         int myAnimatedNodeCount;
      };

      struct ParserOutput
      {
         ParserOutput() : myAnimatedNodeCount(0) { ; }
         LodVec myLods;
         SwitchVec mySwitches;
         PerDofDataVec myPerDofData;
         GeometryVec myDrawables;
         SequenceVec mySequences;

         LightSourceVec myLightSources;

         LightPointVec myLightPointNodes;

         NodeVec myDofNodes;

         NodeVec mySwitchNodes;

         NodeVec mySequenceNodes;

         typedef std::map<osg::Node*, ArrayRange> NodeToDrawables;

         NodeToDrawables myNodeToDrawablesMap;

         int myAnimatedNodeCount;
      };
      

      boost::signal<void(const std::string&)> signal_modelTypeRegistered;

      boost::signal<void(const std::string&, DtUniqueID, DtElementID, DtModel *)>  signal_instanceCreated;

      boost::signal<void(const CullSet&)> signal_updateFinished;

      bool intersect(const osg::Vec3d& start, const osg::Vec3d& end,
         const osg::Vec3d& reference, DtOsgIntersectorResult& result,
         std::list<DtUniqueID>* ignoreList = 0);

      bool intersect(const osg::Vec3d& start, const osg::Vec3d& end,
         std::vector<DtOsgIntersectorResult>& results,
         std::list<DtUniqueID>* ignoreList = 0);

      void setSequenceMode(const DtInstanceState& instance, unsigned int sequenceIndex, InstancedSequence::SequenceMode mode);

      void setSequenceSpeed(const DtInstanceState& instance, unsigned int sequenceIndex, float speed);

      void setSequencePlayTime(const DtInstanceState& instance, unsigned int sequenceIndex, float loopTime);

      InstanceMatrix dofState(const DtInstanceState& instanceState, unsigned int partIndex);

      void setDofState(InstanceMatrix& m, const DtInstanceState& state, unsigned int partIndex);

      void setDofAnimation(osg::Vec3f& hpr, const osg::Vec3f& hprVel, const DtInstanceState& state, unsigned int partIndex);

      void setDofRotationalVelocity(const osg::Vec3f& hprVel, const DtInstanceState& state, unsigned int partIndex, bool forceUpdate = true);

      void setDofTranslation(osg::Vec3f& trans, osg::Vec3f& transVel, const DtInstanceState& state, unsigned int partIndex);

      void setSwitchState(const DtInstanceState& instance, unsigned int partIndex, unsigned int childIndex, bool state);

      void setUVOffset(DtUniqueID id, unsigned int drawableIx, unsigned int count, const osg::Vec2f& uvOffset);

      void setUserDefined(DtUniqueID id, float userDefined);

      void setLightpointRange(DtUniqueID id, float range);

      void setElementId(DtUniqueID id, DtUniqueID elementId);

      osg::StateSet* getModelTypeRootStateSet(const std::string& modelType);

      static DtInstanceManager& instance(DtDe& de);

      DtInstanceManager(DtDe& de);

      virtual ~DtInstanceManager();

      virtual void reset();

      virtual osg::Node* instanceRoot();

      bool isRegistered(const std::string& modelType);

      void registerModel(const std::string& modelType, const ParserOutput& parseOutput,
         float boundingRadius, const DtVector& boundingCenter,
         unsigned int nodeMask, const osg::ref_ptr<osg::StateSet>& rootNodeSS, bool daylightControlledLights = false);

      osg::Geode* setupModelGeode(const std::string& modelType, unsigned int nodeMask);

      void allocateImage(const osg::View* view);

      void freeInstance(DtUniqueID id);
      
      void drainFreeInstanceList();

      void setArtPartSmoothingEnabled(bool onOrOff);
      bool artPartSmoothingEnabled() const;

      void setArtPartSmoothingPeriod(float period);
      float artPartSmoothingPeriod() const;

      bool newInstance(const std::string& modelType, DtUniqueID id, DtElementID elementId, short modelSet,
         DtModel* model, const std::string &lightPointGroup, bool isSimpleModel);

      DtInstanceState* findInstanceState(DtUniqueID id);

      InstanceCullData* findInstanceCullData(DtUniqueID id);

      void setPosition(DtUniqueID uniqueID, const DtVector& vPosition);
      void setPositionOffset(DtUniqueID uniqueID, const DtVector& vPosition);
      void setOrientation(DtUniqueID uniqueID, const DtTaitBryan& orientation);
      void setOrientationOffset(DtUniqueID uniqueID, const DtTaitBryan& orientation);

      void setPosition(DtUniqueID uniqueID, const osg::Vec3d& vPosition);
      void setPositionOffset(DtUniqueID uniqueID, const osg::Vec3d& vPosition);
      void setOrientation(DtUniqueID uniqueID, const osg::Quat& orientation);
      void setOrientationOffset(DtUniqueID uniqueID, const osg::Quat& orientation);

      void setVisible(DtUniqueID uniqueID, bool bVisible);

      void setBlendColor(DtUniqueID uniqueID, float r, float g, float b, float a);

      void setModelScaling(DtUniqueID uniqueID, bool bModelScaling, float scale);

      void setCullParameters(DtUniqueID uniqueID, unsigned int nodeMask, bool visible);

      typedef std::vector<DtInstanceState> InstanceStateVec;
      typedef std::vector<DtModel*> ModelVec;
      typedef std::vector<InstancedLod> InstancedLodVec;
      typedef std::vector<InstancedDof> InstancedDofVec;
      typedef std::vector<InstanceCullData> InstanceCullDataVec;
      typedef std::vector<InstanceMatrix, tbb::cache_aligned_allocator<InstanceMatrix> > InstanceMatrixVec;
      typedef std::vector<float> InstanceScaleVec;
      typedef std::vector<DtElementID> InstanceElementIdVec;
      typedef std::vector<InstancedLight> InstancedLightVec;

      inline InstanceElementIdVec& elementIds() { return myElementIds; }

      inline InstanceScaleVec& instanceScales() { return myInstanceScales; }

      inline ByteVec& instanceVisibleSet() { return myInstanceVisibleSet; }

      inline InstanceMatrixVec& drawableInstanceMatrix() { return myDrawableInstanceMatrix; }

      inline InstanceCullDataVec& instanceCullData() { return myInstanceCullData; }

      inline InstanceStateVec& instances() { return myInstances; }

      inline TextureCoordinateVec& uvOffsets() { return myUVOffsets; }

      inline InstancedLodVec& instancedLods() { return myInstancedLods; }

      inline InstancedSwitchVec& instancedSwitches() { return myInstancedSwitches; }

      inline InstancedSequenceVec& instancedSequences() { return myInstancedSequences; }

      inline InstancedDofVec& instancedDofs() { return myInstancedDofs; }

      typedef std::vector<InstanceTemplate*> InstanceTemplateVec;

      inline InstanceTemplateVec& instanceTemplates() { return myInstanceTemplates; }

      inline std::vector<float>& distanceToEye() { return myDistanceToEye; }

      inline DofAnimations& dofAnimations() { return myDofAnimations; }

      inline double& lastUpdateTime() { return myLastUpdateTime; }

      inline const DtOsgCullVisitorParameters* lastCullParameters() { return myLastCullParameters.get(); }

      inline BoolVec& visibleSet() { return myVisibleSet; }

      inline osg::Vec3d& cameraPosition() { return myCameraPosition; }

      inline const osg::View* lastView() { return myLastView; }

      inline const osg::Camera* lastCamera() { return myLastCamera; }

      inline unsigned int drawableIndex(unsigned int instanceIx) {
         return myInstanceDataOffsets[instanceIx].myDrawables.offset;
      }

      inline unsigned int matrixIndex(unsigned int instanceIx)
      {
         return myInstanceDataOffsets[instanceIx].myMatrixes.offset;
      }

      inline unsigned int drawableOffsetMatrixIndex(const DtInstanceState& instanceState, unsigned int instanceIx, unsigned int drawableOffset) 
      {
         unsigned int matrixIx = myInstanceDataOffsets[instanceIx].myMatrixes.offset;
         // only bother with the first drawable matrix if there are no dofs
         if (instanceState.dofRange.count != 0)
         {
            matrixIx += drawableOffset;
         }
         return matrixIx;
      }

      void reloadShaders();

      inline GeometryVec& drawables(){ return myDrawables; }

      inline unsigned int visibleCount() const { return myVisibleCount; }

      inline unsigned int dynamicBufferDataSize() const { return myDynamicBufferDataSz; }

      virtual void traverse(osg::NodeVisitor& nv);

      virtual void update(osg::NodeVisitor& nv);
      
      virtual void updateForIntersection(double simTime, const osg::View* view, osg::Camera* camera, unsigned int nodeMask, DtOsgCullVisitorParameters* params);
      
      virtual void updateForDrawing(osgUtil::CullVisitor* cv, const DtOsgCullVisitorParameters* params);
      
      virtual float lightpointRange(unsigned int instanceIx);

      virtual void setDefaultLightPointMaxDistance( float distance );

      virtual float defaultLightPointMaxDistance() const;

      virtual void setLightPointFadeBias( float bias );

      virtual bool cullDistanceEnabled();

      virtual float cullDistance();

      virtual std::string modelDefinitionNameProxy(const std::string& modelDefName);

      DtVirtualBaseClass* findCachedData(const std::string& modelType, const std::string& name);

      void setCachedData(const std::string& modelType, const std::string& name, DtVirtualBaseClass* data);

      void clearCachedData();

      void releaseGLObjects(osg::State* state);

      void updateBuffers(const osg::View* view);

      void updateLightPoints(const osg::Camera* camera, const osg::FrameStamp* frameStamp, osgUtil::CullVisitor* cv, const osg::Camera* sceneCamera = NULL);

      void addImguiStats() const;

      void resetTboSendFlag();

   protected:

      struct Eyepoint
      {
         osg::Vec3d center;
         osg::Vec3d eye;
         osg::Vec3d up;
      };

      struct Frustum
      {
         double l, r, b, t, n, f;
      };

      struct InstancingHit
      {
         unsigned int instanceIx;
         unsigned int drawableMatrixIx;
         osg::Vec3f pos;
         osgUtil::LineSegmentIntersector::Intersection result;
      };


      struct RenderState
      {
         InstanceMatrix l2w;
         float scale;
         float userDefined;
         osg::Vec2f uvOffset;
         osg::Vec3f filterColor;
         float lightpointRange;
      };

      typedef std::vector<RenderState> RenderStateVec;

      struct GeometryRenderList
      {
         GeometryRenderList()
         {
            count = 0;
            memoryOffset = 0;
         }
         tbb::atomic<unsigned int> count;
         int memoryOffset;
         unsigned int getcount() const
         {
            return count;
         }
         RenderStateVec states;
      };

      InstanceTemplateVec myInstanceTemplates;

      // all the drawables all the models have
      
      bool myRenderListDirty;

      typedef std::vector<GeometryRenderList> RenderList;

      RenderList myRenderList;

      GeometryVec myDrawables;

      //scratch list of active drawables
      std::vector<unsigned int> myActiveDrawablesScratch;

      // per instance stuff

      BoolVec myVisibleSet;

      InstanceMatrixVec myDrawableInstanceMatrix;


      TextureCoordinateVec myUVOffsets;

      ByteVec myInstanceVisibleSet;

      std::vector<float> myDistanceToEye;

      InstanceScaleVec myInstanceScales;

      FloatVec myInstanceUserDefined;

      FloatVec myInstanceLightpointRange;

      InstanceCullDataVec myInstanceCullData;

      InstanceElementIdVec myElementIds;

      InstanceStateVec myInstances;
      ModelVec myModelInstances;
      NodeVec myAnimatedModels;

      struct InstanceDataOffsets
      {
         ArrayRange myDrawables;
         ArrayRange myMatrixes;
         ArrayRange myAnimatedDofs;
      };
      std::vector<InstanceDataOffsets> myInstanceDataOffsets;

      InstancedLodVec myInstancedLods;
      InstancedSwitchVec myInstancedSwitches;
      InstancedSequenceVec myInstancedSequences;
      InstancedDofVec myInstancedDofs;
      InstancedLightVec myInstancedLights;
      LightPointVec myInstancedLightPoints;


      DofAnimations myDofAnimations;

      double myLastUpdateTime;

      unsigned int myLastNodeMask;


      osg::Vec3d myCameraPosition;

      const osg::View* myLastView;

      const osg::Camera* myLastCamera;

      CullSet myPerViewCullResults;

      typedef boost::unordered_map<std::string, DtVirtualBaseClass*> CacheMap;
      CacheMap myRuntimeCache;

      tbb::concurrent_queue<unsigned int> myListToRemove;

   protected:
      
      void update(double simTime, const osg::View* view, osg::Camera* camera,
         unsigned int nodeMask, osgUtil::CullVisitor* cv,
         const DtOsgCullVisitorParameters* params, bool suppressLastUpdateTime);

      void registerGeometry(unsigned int templateIx, osg::Geometry* geometry, VpMap& vpMap);

      float computeDistanceToEye(const Eyepoint& eye, const osg::Vec3d& pos) const;

      void updateOffsetsAndDistancesToEye(const Eyepoint& eye);

      void _updateOffsetsAndDistancesToEye(const Eyepoint& eye, unsigned int instanceOffset, unsigned int numInstances);

      void allocateRenderList();

      void updateDataAndDrawables( unsigned int offset, unsigned int count);

      unsigned int updateRenderList(const Eyepoint& eye, const osg::Matrixd& viewMat, unsigned int nodeMask);

      void updateLights(const osg::View* view);
      void resizeBuffersIfNecessary(const osg::View* view, int visibleCount);
      void resizeTBOIfNecessary(const osg::View* view, int visibleCount);
      
      void allocateInstanceData();

      unsigned int fillRenderList( unsigned int instanceOffset, unsigned int numInstances);

      void cullRange(const Eyepoint& eye
         , const std::vector<osg::Vec4d>& planes, bool useScale, unsigned int nodeMask
         , unsigned int instanceOffset, unsigned int instanceCount);

      void slot_channelAdded(DtChannelManager* mgr, DtChannel* channel);

      void slot_channelRemoved(DtChannelManager* mgr, DtChannel* channel);

      void clearTBO(InstanceBuffer& instanceBuffer);

      void createHitList(const osg::Vec3d& end, const osg::Vec3d& start, std::vector<InstancingHit>& hitList);

      void loadInstanceShaders(osgEarth::VirtualProgram* vp);

      bool isOnExcludeList(DtUniqueID elementId,
         const std::list<DtUniqueID>& ignoreList);

   protected:

      typedef boost::unordered_map<DtUniqueID, unsigned int> InstanceStateMap;

      InstanceStateMap myIdToInstances;
      tbb::spin_rw_mutex myMapMutex;

      osg::Vec4* myDynamicBufferData;
      unsigned int myDynamicBufferDataSz;
      unsigned int myCurrentDynamicBufferDataSize;
      
      typedef std::vector<InstanceBuffer> InstanceBufferVec;

      InstanceBufferVec myInstanceBuffers;

      typedef boost::unordered_map<std::string, int> modelTypeToTemplateMap;

      modelTypeToTemplateMap myModelTypeToTemplate;

      DtDe& myDe;


      unsigned int myRequiredUvOffsets;

      unsigned int myNumThreads;

      // FIXME GNP shouldn't these be vectors? we never delete templates?

      
      std::vector<int> myTemplateMaxInstances;

      std::vector<int> myTemplateActiveInstances;

      VpMap myVpMap;
      VpRefList myVpRefs;

      class DT_DLL_VRVOSG AlwaysCull : public osg::Drawable::CullCallback
      {
         virtual bool cull(osg::NodeVisitor* nv, osg::Drawable* drawable, osg::RenderInfo* renderInfo) const
         {
            return true;
         }
      };

      osg::ref_ptr<AlwaysCull> myAlwaysCullCallback;

      osg::ref_ptr<DtInstanceNode> myInstanceRoot;

      typedef std::vector<DtInstanceProcessor*> InstanceProcessorVec;

      InstanceProcessorVec myPostCullInstanceProcessors;

      InstanceProcessorVec myPreCullInstanceProcessors;

      typedef std::vector<osg::View*> ViewVec;
      ViewVec myKnownViews;

      typedef boost::unordered_map<const osg::View*, osg::ref_ptr<DtViewSpecificGroup> > ViewToGroup;
      ViewToGroup myViewToGroup;

      typedef boost::unordered_map<osg::Geometry*, osg::ref_ptr<DtPerViewUniformCallback> > GeometryToCallback;
      GeometryToCallback myGeometryToCallback;

      osg::ref_ptr<const DtOsgCullVisitorParameters> myLastCullParameters;
      //DtInstanceLpProcessor* myLpProcessor;
      float myDefaultLightPointRange;
      float myLightPointFadeBias;

      void addInstanceRootToSceneGraphIfNecessary(void);

      void processNewInstanceLights(const InstanceTemplate& instanceTemplate);
      void processNewInstanceDOFs(DtModel* model, const InstanceTemplate& instanceTemplate);
      void processNewInstanceSwitches(const InstanceTemplate& instanceTemplate, bool isSimpleModel);
      void processNewInstanceSequences(const InstanceTemplate& instanceTemplate);
      
      void processNewInstanceLightPoints(const InstanceTemplate& instanceTemplate, const std::string& lightPointGroup);

      void preCull();
      void frustumCull(const osg::View* view, const Eyepoint& eye, unsigned int nodeMask);
      void postCull();

      std::vector<osg::Vec4d> vecScratchPadPlanes;

      void _fillRenderList(bool globalScaling, unsigned int instanceOffset, unsigned int numInstances);

      tbb::atomic<int> myVisibleCount;
      osg::ref_ptr<DtInstanceManagerTboUpdater> myDrawCallUpdater;
      int myNeedsMainThreadTextureUpdate;

      std::string myInstanceVS, myInstanceViewVS, myInstanceFS;
      std::map <const InstanceTemplate*, int> myNewTemplates;
      unsigned int myCurrentTBBChunkSize;

      bool myArtPartSmoothingEnabled;
      float myArtPartSmoothingPeriod;
      bool myTboSendFlag;
};

   class DT_DLL_VRVOSG DtInstanceManagerCreator : public DtVirtualBaseClass
   {
   public:
      virtual ~DtInstanceManagerCreator();

      static DtInstanceManagerCreator& instance(DtDe& de);

      virtual DtInstanceManager* create();

   protected:
      DtInstanceManagerCreator(DtDe& de);

   protected:
      DtDe& myDe;
   };
}