GsBaseMaterialView.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_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 "Gi/GiLightTraitsData.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();
  }
};
 
struct GS_TOOLKIT_EXPORT OdGsLightsAccumulationContainter
{
  typedef OdVector<OdGiLightTraitsData *> LightDataVector;
  OdVector<OdGiLightTraitsData *> m_accumulatedLightsData;
  OdMutexPtr m_lightsAccumMutex;
  OdGsLightsAccumulationContainter() {}
  ~OdGsLightsAccumulationContainter() { clear(); }
  bool has() const { return !m_accumulatedLightsData.isEmpty(); }
  void append(bool bMtSync, OdGiLightTraitsData *pLightData);
  void append(bool bMtSync, OdGsLightsAccumulationContainter &lightsAccum);
  void clear();
};
 
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,  // Internal.
      kUser           // User-defined.
    };
    struct DelayCacheEntry
    {
      DelayCacheEntry() : m_pNext(NULL) { }
      
      virtual ~DelayCacheEntry() { }
 
      DelayCacheEntry *m_pNext;
 
      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:
    enum MaterialViewRuntimeFlags
    {
      kMaterialCommited    = (1 << 0), // Material already emitted by GsModel
      kAccumNonCacheLights = (1 << 1), // Accumulate lights which is not relate to GsModel
      kAccumCacheLights    = (1 << 2), // Accumulate GsModel-resident lights
      kAccumLights = kAccumNonCacheLights | kAccumCacheLights
    };
    struct ExtentsContainer
    {
      const OdGiDrawable *m_pCurrentDrawable;
      OdGeExtents3d       m_Extents;
      enum Flags
      {
        kExtentsValid        = (1 << 0),
        kExtentsAwaitingCalc = (1 << 1),
        kLastFlag            = kExtentsAwaitingCalc
      };
      ExtentsContainer() : m_pCurrentDrawable(NULL) {}
      void clear() { m_pCurrentDrawable = NULL; }
    };
    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 : public ExtentsContainer
    {
      DelayCache   m_DelayCache;
      OdGeMatrix3d m_ModelTransform;
      OdUInt32     m_flags;
      enum Flags
      {
        kMapperNeedExtents = (ExtentsContainer::kLastFlag << 1), // Mapper awaiting current drawable extents
        kBaseLevel         = (ExtentsContainer::kLastFlag << 2),
        kHasModelTransform = (ExtentsContainer::kLastFlag << 3),
        kIsEntity          = (ExtentsContainer::kLastFlag << 4)
      };
      MViewPerDrawableData()
        : m_flags(0)
      {
      }
      ~MViewPerDrawableData()
      {
      }
      void clear()
      {
        ExtentsContainer::clear();
        SETBIT_0(m_flags, ~kBaseLevel);
      }
    } *m_pCurMvDrawableData, m_mvBaseDrawableData, m_mvGlobalDrawableDataInitializer;
  protected:
    OdUInt32            m_uMaterialViewFlags;   // Set of material view flags
    OdUInt32            m_uMaterialViewRtFlags; // Runtime flags
    OdGiMaterialItemPtr m_pCurrentMaterialItem; // Current material
    OdGiMapperItemPtr   m_pCurrentMapperItem;   // Current mapper
    OdGiMaterialTraitsData m_nullMaterialTraitsData;
    OdGiMaterialItemPtr m_pNullMaterialItem;
    OdGsLightsAccumulationContainter m_lightsAccum;
  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);
 
    // Lights-related functionality
 
    void beginLightsAccumulation(bool bAccumNonCached = true, bool bAccumCached = false, bool bClear = false);
    void playAccumulatedLights(OdGsLightsAccumulationContainter *pAccumLights = NULL, bool bClear = true);
    const OdGsLightsAccumulationContainter &getAccumulatedLights() const { return m_lightsAccum; }
    OdGsLightsAccumulationContainter &getAccumulatedLights() { return m_lightsAccum; }
    bool isLightsAccumulation() const
    { return (GETBIT(m_uMaterialViewRtFlags, kAccumNonCacheLights) && !GETBIT(m_flags, kModelCache)) ||
             (GETBIT(m_uMaterialViewRtFlags, kAccumCacheLights)    &&  GETBIT(m_flags, kModelCache)); }
 
    virtual void addPointLight(const OdGiPointLightTraitsData&);
    
    virtual void addSpotLight(const OdGiSpotLightTraitsData&);
    
    virtual void addDistantLight(const OdGiDistantLightTraitsData&);
    
    virtual void addWebLight(const OdGiWebLightTraitsData&);
 
    // 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 updateMViewModelTransform();
    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__