GsContainerNode.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef __OD_GS_CONTAINER_NODE__
#define __OD_GS_CONTAINER_NODE__
 
#include "TD_PackPush.h"
 
#include "Gs/GsNode.h"
#include "Gs/GsDrawableHolder.h"
#include "Si/SiSpatialIndex.h"
#include "OdVector.h"
#include "ThreadsCounter.h"
 
class OdGsEntityNode;
class OdGsLightNode;
class OdGsBlockNode;
 
class GS_TOOLKIT_EXPORT OdGsContainerNode : public OdGsNode
{
protected:
  enum
  {
    kEntityListValid  = OdGsNode::kLastFlag << 1,
    kCheckWorkset     = OdGsNode::kLastFlag << 2,
    kHasStockData     = OdGsNode::kLastFlag << 3,
    kVpDepCache       = OdGsNode::kLastFlag << 4,
    kLastFlag         = kVpDepCache
  };
 
  enum
  {
    kChildrenNotUpToDate = 0x80000000 //special flag to use in setChildrenUpToDate/childrenUpToDate
      //per each viewport, flags are stored in m_vpAwareFlags
  };
 
  typedef OdList<OdGsLightNode*> LightsList;
 
  struct GS_TOOLKIT_EXPORT VpData : public OdRxObject
  {
    OdGsEntityNode*         m_pFirstEntity;
    OdGsEntityNode*         m_pLastEntity;
    LightsList              m_lightPtrs; // some of the lights are entities (ones that lies in model space)
    OdSiSpatialIndexPtr     m_pSpIndex;
    OdGsEntityNode*         m_pClearSpatialQueryStateFirst;
    int                     m_nChild;
    OdUInt32                m_nChildErased, m_nChildErasedPermanently;
    OdUInt32                m_nChildSingleThreaded;
    OdUInt32                m_nChildHighlighted;
    OdUInt32                m_flags;
    OdGsUpdateExtents       m_realExtents; //Keeps real extents (for EXTMIN/MAX support)
 
    enum
    {
      kEntityListValid  = OdGsContainerNode::kEntityListValid,
      kVpDepCache       = OdGsContainerNode::kVpDepCache
    };
 
    VpData();
    static OdSmartPtr<VpData> createObject(bool bShareable = false);
  };
  typedef OdSmartPtr<VpData> VpDataPtr;
  typedef OdVector<VpDataPtr> VpDataArray;
 
  inline VpData *getVpData(OdUInt32 nVpId, bool bCreateIfNotFound = true) const;
  VpData *makeVpData(OdUInt32 nVpId) const;
  inline OdUInt32 vpDataId(const VpData *pVpData) const;
public:
  
  inline bool hasVpData(OdUInt32 nVpId) const;
  
  inline OdUInt32 numVpData() const;
  
  OdUInt32 isAttached(OdGsEntityNode *pNode) const;
  
  void setEntityListsInvalid();
  
  OdUInt32 viewportId(const OdGsViewImpl &pView, bool bForceVpId = true) const;
  
  inline bool isVpDepCache() const;
  
  void setVpDepCache(const OdGsViewImpl &pView);
public:
  void setEntityListValid(OdUInt32 nVpId, bool entityListValid);
  
  bool childrenUpToDate(OdUInt32 nVpId) const;
 
  bool needRegen(OdUInt32 nVpId) const;
 
  void addChildNode(OdUInt32 nVpId, OdGsEntityNode* pEnt);
 
  void turnOnLights(OdGsBaseVectorizer& view);
  
  virtual ENodeType nodeType() const { return kContainerNode; }
 
  virtual void displayEntityList(OdGsDisplayContext& ctx);
 
  OdGsEntityNode* firstEntityNode(OdUInt32 nVpId);
  const OdGsEntityNode* firstEntityNode(OdUInt32 nVpId) const;
  OdGsEntityNode* lastEntityNode(OdUInt32 nVpId);
  const OdGsEntityNode* lastEntityNode(OdUInt32 nVpId) const;
  OdList<OdGsLightNode*> &lightNodesList(OdUInt32 nVpId);
  const OdList<OdGsLightNode*> &lightNodesList(OdUInt32 nVpId) const;
 
   OdUInt32 awareFlags(OdUInt32 viewportId) const;
 
   void setAwareFlags(OdUInt32 viewportId, OdUInt32 flags);
 
protected:
  virtual void propagateLayerChanges(OdGsViewImpl& view);
  bool saveVpData(OdGsFiler *pFiler, const VpData *pVpData) const;
  bool loadVpData(OdGsFiler *pFiler, VpData *pVpData);
 
public:
  ODRX_DECLARE_MEMBERS(OdGsContainerNode);
 
  OdGsContainerNode(OdGsBaseModel* pModel, const OdGiDrawable* pUnderlyingDrawable, bool bSetGsNode = true);
  
  ~OdGsContainerNode();
 
  bool entityListValid(OdUInt32 nVpId) const;
  
  bool allEntityListsValid() const;
  
  bool isEmpty() const;
 
  void setChildrenUpToDate(bool childrenUpToDate, const OdUInt32* nVpID = NULL);
  
  bool childrenRegenDraw(OdUInt32 nVpID) const;
  
  void setChildrenRegenDraw(bool bVal, OdUInt32 nVpID);
 
  virtual void addChild(const OdGiDrawable* pDrawable, OdGsViewImpl *pView, bool unerased = false);
 
  /* \details
    Adds information about the light if the light doesn't have gsNode yet.
    \param ctx       [in]  Current update context.
    \param pDrawable [in]  Pointer to the Drawable object.
  */
  virtual void addLight(OdGsUpdateContext& ctx, const OdGiDrawable* pDrawable);
  /* \details
    Removes information about the light added through addLight method.
    \param pOwner [in]  gsNode of the owner entity.
    \param nVpId  [in]  Optional Viewport ID.
  */
  virtual void removeLights(OdGsNode *pOwner, OdUInt32 nVpId = 0xFFFFFFFF);
 
  virtual void removeChild(OdGsNode* pNode);
 
  void update(OdGsUpdateContext& ctx, OdGsContainerNode* pParent, OdSiSpatialIndex* pParentIndex);
 
  void updateVisible( OdGsViewImpl* pViewImpl );
 
  void display(OdGsDisplayContext& ctx);
 
  OdSiSpatialIndex& spatialIndex(OdUInt32 nVpId);
  const OdSiSpatialIndex& spatialIndex(OdUInt32 nVpId) const;
 
  void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask);
 
  OdUInt32 currViewChanges() const;
 
  bool extents(OdGeExtents3d& extents) const;
 
  virtual bool extents(const OdGsView* pView, OdGeExtents3d& ext) const;
 
  void propagateInvalidVpFlag();
 
  bool checkWorkset() const;
  void setCheckWorkset(bool bVal);
 
  virtual bool updateEntityList(OdGsUpdateContext& ctx);
 
  virtual void updateEntities(OdGsUpdateContext& ctx);
 
  bool findCompatibleCache(OdGsViewImpl& keyView);
 
  bool highlightSubnodes(OdUInt32 nSubnodes, bool bHighlight, bool bAll, OdUInt32 nSelStyle = 0);
 
  void destroy();
 
  void destroySubitems();
 
  inline const OdGsUpdateExtents& realExtents(OdUInt32 nVpId) const;
 
  inline void setRealExtents(OdUInt32 nVpId, const OdGsUpdateExtents& ext);
 
  inline void addViewRef(OdUInt32 nVpId);
  inline void removeViewRef(OdUInt32 nVpId);
  inline const ViewRefs& viewRefs() const;
 
  inline const StockProps& stock() const;
  void makeStock();
  void releaseStock();
  void propagateLayerChangesStock();
 
  bool saveNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL) const;
  
  bool loadNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL);
  
  bool postprocessNodeLoading(OdGsFiler *pFiler);
 
  bool safeEntityUpdate(OdGsEntityNode* pEntity, OdGsUpdateContext& ctx, OdSiSpatialIndex* pSpatialIndex);
  
  void addEntProps(const OdGsUpdateContext& ctx);
  
  bool doMTUpdate(OdGsUpdateContext& ctx);
  
  void doSTUpdate(OdGsUpdateContext& ctx);
 
  void removeErased();
 
  inline int numberOfChildren(OdUInt32 nVpId) const;
  inline OdUInt32 numberOfChildrenST(OdUInt32 nVpId) const;
  inline OdUInt32 numberOfChildrenErased(OdUInt32 nVpId) const;
protected:
  mutable VpDataArray m_vpData;
  mutable VpDataPtr m_shareableData;
  OdUInt32Vector m_vpAwareFlags; //this memory is never shared, no need in OdArray with refcounter on buffer
  ViewRefs m_viewRefs;
  StockProps m_stock;
  OdMutexPtr m_lightsMutex;
public:
  mutable OdMutex m_nodesMutex; // to protect nodes list from modification when acessing it
 
public:
  void addContentToUpdateManager( OdUInt32 viewportId, OdGsUpdateManager* pManager, const UpdateManagerContext& context );
  
  bool isMetafilesCompatible( const OdGsViewImpl* pView1, const OdGsViewImpl* pView2, OdGsUpdateContext* ctx );
};
 
inline OdGsContainerNode::VpData *OdGsContainerNode::getVpData(OdUInt32 nVpId, bool bCreateIfNotFound) const
{
  if (!GETBIT(m_flags, kVpDepCache))
    return m_shareableData;
  VpData *pVpData = (m_vpData.size() > nVpId) ? m_vpData[nVpId].get() : NULL;
  if (!pVpData && bCreateIfNotFound)
    return makeVpData(nVpId);
  return pVpData;
}
 
inline OdUInt32 OdGsContainerNode::vpDataId(const VpData *pVpData) const
{
  if (GETBIT(m_flags, kVpDepCache))
  {
    const OdUInt32 nVpData = m_vpData.size();
    const VpDataPtr *pVpDataPtr = m_vpData.getPtr();
    for (OdUInt32 nVpId = 0; nVpId < nVpData; nVpId++)
    {
      if (pVpDataPtr[nVpId].get() == pVpData)
        return nVpId;
    }
  }
  return 0;
}
 
inline bool OdGsContainerNode::hasVpData(OdUInt32 nVpId) const
{
  if (!GETBIT(m_flags, kVpDepCache))
    return true;
  return ((m_vpData.size() > nVpId) && !m_vpData.getAt(nVpId).isNull());
}
 
inline OdUInt32 OdGsContainerNode::numVpData() const
{
  if (!GETBIT(m_flags, kVpDepCache))
    return 1;
  return m_vpData.size();
}
 
inline bool OdGsContainerNode::isVpDepCache() const
{
  return GETBIT(m_flags, kVpDepCache);
}
 
inline bool OdGsContainerNode::entityListValid(OdUInt32 nVpId) const
{
  if (!isVpDepCache())
    return GETBIT(m_flags, kEntityListValid);
  const VpData *pVpData = getVpData(nVpId, false);
  if (pVpData)
    return GETBIT(pVpData->m_flags, kEntityListValid);
  return false;
}
 
inline bool OdGsContainerNode::allEntityListsValid() const
{
  return GETBIT(m_flags, kEntityListValid);
}
 
inline bool OdGsContainerNode::isEmpty() const
{
  const OdUInt32 nVpData = numVpData();
  for (OdUInt32 nView = 0; nView < nVpData; nView++)
  {
    const VpData *pVpData = getVpData(nView, false);
    if (pVpData && pVpData->m_pFirstEntity)
      return false;
  }
  return true;
}
 
inline void OdGsContainerNode::setEntityListsInvalid()
{
  for (OdUInt32 nView = 0; nView < numVpData(); nView++)
  {
    if (hasVpData(nView))
      SETBIT_0(getVpData(nView, false)->m_flags, VpData::kEntityListValid);
  }
  SETBIT_0(m_flags, kEntityListValid);
}
 
inline void OdGsContainerNode::setEntityListValid(OdUInt32 nVpId, bool bValid)
{
  SETBIT(getVpData(nVpId)->m_flags, kEntityListValid, bValid);
  if (!bValid || !isVpDepCache())
    SETBIT(m_flags, kEntityListValid, bValid);
  else
  { // Check does all entity lists valid
    const OdUInt32 nViews = numVpData();
    bool bAllListsValid = true;
    for (OdUInt32 nView = 0; nView < nViews; nView++)
    {
      const VpData *pVpData = getVpData(nView, false);
      if (pVpData && !GETBIT(pVpData->m_flags, VpData::kEntityListValid))
      {
        bAllListsValid = false;
        break;
      }
    }
    SETBIT(m_flags, kEntityListValid, bAllListsValid);
  }
}
 
inline OdSiSpatialIndex& OdGsContainerNode::spatialIndex(OdUInt32 nVpId)
{
  return *getVpData(nVpId)->m_pSpIndex.get();
}
 
inline const OdSiSpatialIndex& OdGsContainerNode::spatialIndex(OdUInt32 nVpId) const
{
  return *getVpData(nVpId)->m_pSpIndex.get();
}
 
inline OdGsEntityNode* OdGsContainerNode::firstEntityNode(OdUInt32 nVpId)
{
  VpData *pVpData = getVpData(nVpId, false);
  if (!pVpData)
    return NULL;
  return pVpData->m_pFirstEntity;
}
 
inline const OdGsEntityNode* OdGsContainerNode::firstEntityNode(OdUInt32 nVpId) const
{
  VpData *pVpData = getVpData(nVpId, false);
  if (!pVpData)
    return NULL;
  return pVpData->m_pFirstEntity;
}
 
inline OdGsEntityNode* OdGsContainerNode::lastEntityNode(OdUInt32 nVpId)
{
  VpData *pVpData = getVpData(nVpId, false);
  if (!pVpData)
    return NULL;
  return pVpData->m_pLastEntity;
}
 
inline const OdGsEntityNode* OdGsContainerNode::lastEntityNode(OdUInt32 nVpId) const
{
  VpData *pVpData = getVpData(nVpId, false);
  if (!pVpData)
    return NULL;
  return pVpData->m_pLastEntity;
}
 
inline OdList<OdGsLightNode*> &OdGsContainerNode::lightNodesList(OdUInt32 nVpId)
{
  return getVpData(nVpId)->m_lightPtrs;
}
 
inline const OdList<OdGsLightNode*> &OdGsContainerNode::lightNodesList(OdUInt32 nVpId) const
{
  return getVpData(nVpId)->m_lightPtrs;
}
 
inline bool OdGsContainerNode::childrenUpToDate(OdUInt32 nVpID) const
{
  if(m_vpAwareFlags.size()>nVpID)
    return !GETBIT(m_vpAwareFlags[nVpID], kChildrenNotUpToDate);
  return false;
}
 
inline void OdGsContainerNode::setChildrenUpToDate(bool bValid, const OdUInt32* nVpID)
{
  if(nVpID)
  {
    OdUInt32Array::size_type n = m_vpAwareFlags.size();
    if(n <= *nVpID)
      m_vpAwareFlags.insert(m_vpAwareFlags.end(), (*nVpID)+1-n, 0xFFFFFFFF);
    SETBIT(m_vpAwareFlags[*nVpID], kChildrenNotUpToDate, !bValid);
  }
  else
  {
    ODA_ASSERT(!bValid);
    for(OdUInt32 i = 0; i < m_vpAwareFlags.size(); ++i)
      SETBIT(m_vpAwareFlags[i], kChildrenNotUpToDate, true);
  }
}
 
inline OdUInt32 OdGsContainerNode::awareFlags(OdUInt32 nVpID) const
{
  if(m_vpAwareFlags.size()>nVpID)
    return m_vpAwareFlags[nVpID] & ~kChildrenNotUpToDate;
  return 0xFFFFFFFF;
}
 
inline void OdGsContainerNode::setAwareFlags(OdUInt32 nVpID, OdUInt32 flags)
{
  flags &= ~kChildrenNotUpToDate;
  OdUInt32Array::size_type n = m_vpAwareFlags.size();
  if(n <= nVpID)
  {
    m_vpAwareFlags.insert(m_vpAwareFlags.end(), nVpID+1-n, 0xFFFFFFFF);
    m_vpAwareFlags[nVpID] = flags;
  }
  else
  {
    m_vpAwareFlags[nVpID] = ((m_vpAwareFlags[nVpID] & kChildrenNotUpToDate) | flags);
  }
}
 
inline bool OdGsContainerNode::needRegen(OdUInt32 nVpID) const
{
  if(!childrenUpToDate(nVpID))
    return true;
 
  OdUInt32 nAF = awareFlags(nVpID);
  return ( nAF == 0xFFFFFFFF || ( baseModel()->viewChanges(nVpID) & nAF) != 0 );
}
 
inline bool OdGsContainerNode::checkWorkset() const
{
  return GETBIT(m_flags, kCheckWorkset);
}
 
inline void OdGsContainerNode::setCheckWorkset(bool bVal)
{
  SETBIT(m_flags, kCheckWorkset, bVal);
}
 
inline bool OdGsContainerNode::childrenRegenDraw(OdUInt32 nVpID) const
{
  if(m_vpAwareFlags.size()>nVpID)
    return GETBIT(m_vpAwareFlags[nVpID], kEntityRegenDraw);
  return false;
}
 
inline void OdGsContainerNode::setChildrenRegenDraw(bool bVal, OdUInt32 nVpID)
{
  OdUInt32Array::size_type n = m_vpAwareFlags.size();
  if(n <= nVpID)
    m_vpAwareFlags.insert(m_vpAwareFlags.end(), nVpID+1-n, 0xFFFFFFFF);
  SETBIT(m_vpAwareFlags[nVpID], kEntityRegenDraw, bVal);
}
 
inline const OdGsUpdateExtents& OdGsContainerNode::realExtents(OdUInt32 nVpId) const
{
  VpData *pVpData = getVpData(nVpId, false);
  if (!pVpData)
    return OdGsUpdateExtents::kInvalid;
  return getVpData(nVpId)->m_realExtents;
}
 
inline void OdGsContainerNode::setRealExtents(OdUInt32 nVpId, const OdGsUpdateExtents& ext)
{
  VpData *pVpData = getVpData(nVpId);
  pVpData->m_realExtents = ext;
}
 
inline void OdGsContainerNode::addViewRef(OdUInt32 nVpId)
{
  m_viewRefs.add(nVpId);
}
 
inline void OdGsContainerNode::removeViewRef(OdUInt32 nVpId)
{
  m_viewRefs.remove(nVpId);
}
 
inline const ViewRefs& OdGsContainerNode::viewRefs() const
{
  return m_viewRefs;
}
 
inline const StockProps& OdGsContainerNode::stock() const
{
  return m_stock;
}
 
inline int OdGsContainerNode::numberOfChildren(OdUInt32 nVpId) const
{
  return getVpData(nVpId)->m_nChild;
}
 
inline OdUInt32 OdGsContainerNode::numberOfChildrenST(OdUInt32 nVpId) const
{
  return getVpData(nVpId)->m_nChildSingleThreaded;
}
 
inline OdUInt32 OdGsContainerNode::numberOfChildrenErased(OdUInt32 nVpId) const
{ VpData *pVpData = getVpData(nVpId);
  return pVpData->m_nChildErased + pVpData->m_nChildErasedPermanently;
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_CONTAINER_NODE__