/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, 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-2016 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;
/** <group !!RECORDS_TD_APIRef>
*/
struct OdGsMaterialTextureDataFiler
{
  virtual bool saveClientMaterialTextureData(const OdGiMaterialTextureData * /*pTextureData*/, OdGsFiler * /*pFiler*/)
  {
    return false;
  }
  virtual OdGiMaterialTextureDataPtr loadClientMaterialTextureData(OdGsFiler * /*pFiler*/)
  {
    return OdGiMaterialTextureDataPtr();
  }
};

/** \details
    This class provides material support for OdGsBaseVectorizeView.

    \remarks
    OdGsBaseMaterialView works only with diffuse material/mapping channel and not applicable for
    complete rendering devices.
    
    Library: TD_Gs

    <group OdGs_Classes> 
*/
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_pCurMaterial(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

    /** \details
      Returns current material item.
    */
    OdGiMaterialItemPtr currentMaterial() const;
    /** \details
      Sets current material item.
      \param pMaterial [in]  New material item.
    */
    void resetCurrentMaterial(OdGiMaterialItemPtr pMaterial);
    /** \details
      Returns true if and only if materials support enabled.
    */
    bool isMaterialEnabled() const;
    /** \details
      Returns true if and only if current material available.
    */
    bool isMaterialAvailable() const;
    /** \details
      Removes current material item.
    */
    void resetCurrentMaterial();
    /** \details
      Returns current material mapper item.
      \param bForCoords [in]  Set to true if mapper item pointer will be used for texture coordinates calculations.
    */
    OdGiMapperItemPtr currentMapper(bool bForCoords = true) const;
    /** \details
      Sets current material mapper item.
      \param pMapper [in]  New material mapper item.
    */
    void resetCurrentMapper(OdGiMapperItemPtr pMapper);
    /** \details
      Returns true if and only if mappers support enabled.
    */
    bool isMapperEnabled() const;
    /** \details
      Returns true if and only if current mapper item available.
    */
    bool isMapperAvailable() const;

    /** \details
      Returns true if and only if delay cache is enabled and drawable extents is not available.
    */
    bool isMappingDelayed() const;

    // Output callbacks

    /** \details
      Can be overrided by device for setup additional transform matrix to material mapper.
      \param dm [out]  Transform matrix.
      \remarks
      Return true if transform matrix initialized.
    */
    virtual bool getDeviceMapperMatrix(OdGeMatrix3d &dm) const;
    /** \details
      Test does current material need to be processed.
      \param materialId [in]  Material id.
      \remarks
      Return true material need to be skipped.
      As default returns true for 2d optimized, wireframe and hidden render modes and if materialId null.
    */
    virtual bool skipMaterialProcess(OdDbStub *materialId) const;
    /** \details
      Can be overrided by device for process null materials.
    */
    virtual void nullMaterialStub();
    /** \details
      Called by OdGsBaseMaterialView for initialize/reinitialize material cache.
      \param prevCache [in]  Previous cache, if available.
      \param materialId [in]  Material id.
      \param materialData [in]  Current material traits.
      \remarks
      As default returns null pointer.
    */
    virtual OdGiMaterialItemPtr fillMaterialCache(OdGiMaterialItemPtr prevCache, OdDbStub *materialId, const OdGiMaterialTraitsData &materialData);
    /** \details
      Called by OdGsBaseMaterialView for render material cache.
      \param pCache [in]  Material cache.
      \param materialId [in]  Material id.
      \remarks
      As default does nothing.
    */
    virtual void renderMaterialCache(OdGiMaterialItemPtr pCache, OdDbStub *materialId);

    /** \details
      Called by delay cache entry as default handler.
      \param pEntry [in]  Pointer to caller entry.
    */
    virtual void playDelayCacheEntry(const DelayCacheEntry *pEntry);
    /** \details
      Sets user entry to delay cache.
      \param pEntry [in]  Pointer to newly created cache entry.
    */
    void appendDelayCacheEntry(DelayCacheEntry *pEntry);
    /** \details
      Called by delay cache writer if mapping entry was changed.
      \remarks
      Can be used for link cache markers with texture coordinates which must be recalculated after extents
      will be calculated.
    */
    virtual void mapperChangedForDelayCache();
    /** \details
      Called by delay cache writer after execution of all cache entries.
      \remarks
      Can be overrided for clear device's internal caches. If you want clear caches before execution,
      you could override computeDelayedExtents method instead of delayCacheProcessed.
    */
    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:
    /** \details
      Called internally if extents needed for current drawable (delay cache disabled).
      \param pDrawable [in]  Pointer to current drawable.
      \param extents [out]  Computed extents.
      \remarks
      Returns true if and only if computed extents valid.
      Can be overrided by device if it needs more fast implementation.
    */
    virtual bool computeDrawableExtents(const OdGiDrawable *pDrawable, OdGeExtents3d &extents);
    /** \details
      Called internally if extents needed for current drawable (if delay cache enabled).
      \param pDrawable [in]  Pointer to current drawable.
      \param extents [out]  Computed extents.
      \remarks
      Returns true if and only if computed extents valid.
      Can be overrided by device if it needs more fast implementation.
    */
    virtual bool computeDelayedExtents(const OdGiDrawable *pDrawable, OdGeExtents3d &extents);
  private:
    void computeDrawableExtents();
    bool tryGsModelExtents(OdGeExtents3d &extents) const;
  protected:
    OdGiMapperItemPtr _itlCreateMapperItem() const;
    OdGiMaterialItemPtr _itlCreateMaterialItem() const;
};

/** \details
    Implements OdGsBaseMaterialVectorizer pseudo constructor.

    Library: Gs

    <group OdGs_Classes> 
*/
class GS_TOOLKIT_EXPORT OdGsBaseMaterialViewPC : public OdGsBaseMaterialVectorizer
{
  protected:
    void resetConstructorFlags(OdUInt32 uMaterialViewFlags);
  public:
    OdGsBaseMaterialViewPC() { }
};

/** \details
    Joins OdGsBaseVectorizeView and OdGsBaseMaterialVectorizer classes with default behavior.

    Library: Gs

    <group OdGs_Classes> 
*/
class GS_TOOLKIT_EXPORT OdGsBaseMaterialView : public OdGsBaseVectorizeViewJoin<OdGsBaseMaterialViewPC>
{
  public:
    explicit OdGsBaseMaterialView(OdUInt32 uMaterialViewFlags = kProcessMappersAndMaterials)
    {
      resetConstructorFlags(uMaterialViewFlags);
    }
};

/** \details
    Joins OdGsBaseVectorizeView and OdGsBaseMaterialVectorizer classes with multithread behavior.

    Library: Gs

    <group OdGs_Classes> 
*/
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__