GsBaseMaterialView.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 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_BASE_MATERIAL_VIEW__
#define __OD_GS_BASE_MATERIAL_VIEW__
 
#include "Gs/GsBaseInclude.h"
#include "Gs/GsExtAccum.h"
#include "Gi/GiMapperItem.h"
#include "Gi/GiMaterialItem.h"
 
#include "TD_PackPush.h"
 
class OdGsMaterialNode;
struct OdGsMaterialTextureDataFiler
{
  virtual bool saveClientMaterialTextureData(const OdGiMaterialTextureData * /*pTextureData*/, OdGsFiler * /*pFiler*/)
  {
    return false;
  }
  virtual OdGiMaterialTextureDataPtr loadClientMaterialTextureData(OdGsFiler * /*pFiler*/)
  {
    return OdGiMaterialTextureDataPtr();
  }
};
 
class GS_TOOLKIT_EXPORT OdGsBaseMaterialVectorizer : public OdGsBaseVectorizer, public OdGsMaterialTextureDataFiler
{
  public:
    enum MaterialViewFlags
    {
      kProcessMappers               = 1,        // Process material mappers
      kProcessMaterials             = (1 << 1), // Process materials
 
      kProcessMappersAndMaterials   = 3,        // Process both material mappers and materials
 
      kMappersForRender             = (1 << 2), // OdGiMapperRenderItem instead of OdGiMapperItem
      kMaterialsForRender           = (1 << 3), // OdGiMaterialRenderItem instead of OdGiMaterialItem
 
      kMappersAndMaterialsForRender = 12,       // kMappersForRender | kMaterialsForRender
 
      kProcessForRender             = 15,       // kProcessMappersAndMaterials | kMappersAndMaterialsForRender
 
      // #5127 fix. Delay cache implementation.
      kEnableDelayCache             = (1 << 4)  // Enable cache, which drop extents data after drawable extents computation
    };
 
    // Cache structures
    enum DelayCacheEntryType
    {
      kInternal = 0,
      kUser
    };
    struct DelayCacheEntry
    {
      DelayCacheEntry() : m_pNext(NULL) { }
      virtual ~DelayCacheEntry() { }
 
      DelayCacheEntry *m_pNext;
 
      // Don't return kInternal here if you want get callback
      virtual DelayCacheEntryType internalType() const { return kUser; }
 
      DelayCacheEntry *nextEntry() { return m_pNext; }
      void setNextEntry(DelayCacheEntry *pNext) { m_pNext = pNext; }
 
      virtual void play(OdGsBaseMaterialVectorizer &mView) const
      {
        mView.playDelayCacheEntry(this);
      }
    };
    friend class OdDefDelayCacheEntryMap;
    friend class OdManageMViewPerDrawableData;
  private:
    bool                m_bMaterialCommited;    // Material already emitted by GsModel
    struct ExtentsContainer
    {
      const OdGiDrawable *m_pCurrentDrawable;
      OdGeExtents3d       m_Extents;
      bool                m_bExtentsValid;
      bool                m_bAwaiting;
    };
    struct DelayCache
    {
      const OdGiMapper *m_pCurMapper,   *m_pCopyMapper;
      const OdDbStub   *m_pCurMaterial, *m_pCopyMaterial;
      DelayCacheEntry   m_Cache;
      DelayCacheEntry  *m_pTail;
 
      DelayCache() : m_pCurMapper(NULL), m_pCopyMapper(NULL)
                   , m_pCurMaterial(NULL), m_pCopyMaterial(NULL)
                   , m_pTail(&m_Cache)
      {
      }
 
      void clear();
    };
    struct MViewPerDrawableData
    {
      bool                  m_bMapperNeedExtents;     // Mapper awaiting current drawable extents
      bool                  m_bBaseLevel;
      ExtentsContainer      m_CurrentDrawableExtents;
      DelayCache            m_DelayCache;
      MViewPerDrawableData()
        : m_bMapperNeedExtents(false)
        , m_bBaseLevel(false)
      {
        m_CurrentDrawableExtents.m_bExtentsValid = m_CurrentDrawableExtents.m_bAwaiting = false;
        m_CurrentDrawableExtents.m_pCurrentDrawable = NULL;
      }
      ~MViewPerDrawableData()
      {
      }
      void clear()
      {
        m_CurrentDrawableExtents.m_bExtentsValid = m_CurrentDrawableExtents.m_bAwaiting = false;
        m_bMapperNeedExtents = false;
        m_CurrentDrawableExtents.m_pCurrentDrawable = NULL;
      }
    } *m_pCurMvDrawableData, m_mvBaseDrawableData, m_mvGlobalDrawableDataInitializer;
  protected:
    OdUInt32            m_uMaterialViewFlags;   // Set of material view flags
    OdGiMaterialItemPtr m_pCurrentMaterialItem; // Current material
    OdGiMapperItemPtr   m_pCurrentMapperItem;   // Current mapper
    OdGiMaterialTraitsData m_nullMaterialTraitsData;
    OdGiMaterialItemPtr m_pNullMaterialItem;
  public:
    explicit OdGsBaseMaterialVectorizer(OdUInt32 uMaterialViewFlags = kProcessMappersAndMaterials);
    ~OdGsBaseMaterialVectorizer();
 
    // OdGsBaseVectorizerView overrides
 
    virtual void onTraitsModified();
 
    virtual void beginMetafile(OdRxObject* pMetafile);
    virtual void endMetafile(OdRxObject* pMetafile);
    virtual void beginViewVectorization();
    virtual void endViewVectorization();
 
    virtual void processMaterialNode(OdDbStub *materialId, OdGsMaterialNode *node);
    virtual bool saveMaterialCache(const OdGsMaterialNode *pNode, OdGsFiler *pFiler);
    virtual bool loadMaterialCache(OdGsMaterialNode *pNode, OdGsFiler *pFiler);
 
    virtual bool doDraw(OdUInt32 drawableFlags, const OdGiDrawable *pDrawable);
 
    // OdGsBaseMaterialView methods
 
    OdGiMaterialItemPtr currentMaterial() const;
    void resetCurrentMaterial(OdGiMaterialItemPtr pMaterial);
    bool isMaterialEnabled() const;
    bool isMaterialAvailable() const;
    void resetCurrentMaterial();
    OdGiMapperItemPtr currentMapper(bool bForCoords = true) const;
    void resetCurrentMapper(OdGiMapperItemPtr pMapper);
    bool isMapperEnabled() const;
    bool isMapperAvailable() const;
 
    bool isMappingDelayed() const;
 
    // Output callbacks
 
    virtual bool getDeviceMapperMatrix(OdGeMatrix3d &dm) const;
    virtual bool skipMaterialProcess(OdDbStub *materialId) const;
    virtual void nullMaterialStub();
    virtual OdGiMaterialItemPtr fillMaterialCache(OdGiMaterialItemPtr prevCache, OdDbStub *materialId, const OdGiMaterialTraitsData &materialData);
    virtual void renderMaterialCache(OdGiMaterialItemPtr pCache, OdDbStub *materialId);
 
    virtual void playDelayCacheEntry(const DelayCacheEntry *pEntry);
    void appendDelayCacheEntry(DelayCacheEntry *pEntry);
    virtual void mapperChangedForDelayCache();
    virtual void delayCacheProcessed(const OdGiDrawable *pDrawable);
 
    bool saveMaterialItem(const OdGiMaterialItem *pMatItem, OdGsFiler *pFiler);
    OdGiMaterialItemPtr loadMaterialItem(OdGsFiler *pFiler);
    static bool saveMaterialTexture(const OdGiMaterialTexture *pTexture, OdGsFiler *pFiler);
    static OdGiMaterialTexturePtr loadMaterialTexture(OdGsFiler *pFiler);
    static bool saveMaterialTextureManager(const OdGiMaterialTextureManager *pManager, OdGsFiler *pFiler, OdGsMaterialTextureDataFiler *pSaver);
    static bool loadMaterialTextureManager(OdGiMaterialTextureManager *pManager, OdGsFiler *pFiler, OdGsMaterialTextureDataFiler *pSaver);
    virtual bool saveClientMaterialCache(const OdRxObject* pMtl, OdGsFiler *pFiler);
    virtual OdRxObjectPtr loadClientMaterialCache(OdGsFiler *pFiler, OdGiMaterialItem *pMatItem);
  protected:
    virtual bool computeDrawableExtents(const OdGiDrawable *pDrawable, OdGeExtents3d &extents);
    virtual bool computeDelayedExtents(const OdGiDrawable *pDrawable, OdGeExtents3d &extents);
  private:
    void computeDrawableExtents();
    bool tryGsModelExtents(OdGeExtents3d &extents) const;
  protected:
    OdGiMapperItemPtr _itlCreateMapperItem() const;
    OdGiMaterialItemPtr _itlCreateMaterialItem() const;
};
 
class GS_TOOLKIT_EXPORT OdGsBaseMaterialViewPC : public OdGsBaseMaterialVectorizer
{
  protected:
    void resetConstructorFlags(OdUInt32 uMaterialViewFlags);
  public:
    OdGsBaseMaterialViewPC() { }
};
 
class GS_TOOLKIT_EXPORT OdGsBaseMaterialView : public OdGsBaseVectorizeViewJoin<OdGsBaseMaterialViewPC>
{
  public:
    explicit OdGsBaseMaterialView(OdUInt32 uMaterialViewFlags = kProcessMappersAndMaterials)
    {
      resetConstructorFlags(uMaterialViewFlags);
    }
};
 
class GS_TOOLKIT_EXPORT OdGsBaseMaterialViewMT : public OdGsBaseVectorizeViewJoinMT<OdGsBaseMaterialViewPC>
{
  public:
    explicit OdGsBaseMaterialViewMT(OdUInt32 uMaterialViewFlags = kProcessMappersAndMaterials)
    {
      resetConstructorFlags(uMaterialViewFlags);
    }
 
    bool isMTView() const
    {
      return (&view() != this);
    }
};
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_BASE_MATERIAL_VIEW__