// managerunitlod.h

#ifndef _3DRENDERER_MANAGERUNITLOD_H_
#define _3DRENDERER_MANAGERUNITLOD_H_

#include "managerbase.h"
#include <programcommon/wzflag.h>

// À¯´Ö LOD ¿É¼Ç
#define ULO_ENABLE_UNITLOD          (0x00000001)    // À¯´Ö LOD Àû¿ë
#define ULO_USE_UNITSUBTYPE_LOD     (0x00000002)    // À¯´ÖÀÇ ¼­ºê ŸÀÔ LOD Àû¿ë
#define ULO_ENABLE_LODSKINNING      (0x00000004)    // °Å¸®¿¡ µû¶ó ½ºÅ°´× Àû¿ë
#define ULO_ENABLE_LODNORMALMAP     (0x00000008)    // °Å¸®¿¡ µû¶ó ³ë¸»¸Ê Àû¿ë
#define ULO_ENABLE_LODUNITFADE      (0x00000010)    // °Å¸®¿¡ µû¶ó ÆäÀ̵ù Àû¿ë
#define ULO_AFFECTED_BY_UNITSIZE    (0x00000020)    // °Å¸® °è»ê½Ã À¯´Ö Å©±â ¹Ý¿µ

//------------------------------------------------------------------------------
/**
    @class CManagerUnitLOD

    * LOD °Å¸® ¼³Á¤
    - À¯´ÖÀÌ Ä«¸Þ¶ó¿Í °¡±î¿öÁú ¶§¿Í ¸Ö¾îÁú ¶§ °Å¸®°ª ´Ù¸£°Ô Àû¿ë(Áøµ¿ ¹æÁö)
    - ·¹º§ÀÌ ÀÛÀ» ¼ö·Ï(Ä«¸Þ¶ó¿Í °¡±î¿ï ¼ö·Ï) °í Ä÷¸®Æ¼

                 0·¹º§        1·¹º§      2·¹º§      3·¹º§
                         [1]         [3]        [5]
                 --->     |           |          |
        Ä«¸Þ¶ó ---------|-|---------|-|--------|-|---- À¯´Ö
                 <---   |           |          |
                       [0]         [2]        [4]

        * À¯´Ö°ú Ä«¸Þ¶ó°¡ ¸Ö¾îÁú ¶§´Â À§ °Å¸®(1, 3, 5)º¸´Ù ¸Ö¾îÁ®¾ß ·¹º§ÀÌ ¹Ù²î°í
          ¹Ý´ë·Î °¡±î¿öÁú ¶§´Â ¾Æ·¡ °Å¸®(0, 2, 4)º¸´Ù °¡±î¿öÁ®¾ß ·¹º§ÀÌ ¹Ù²ñ
*/
class CManagerUnitLOD : public CManagerBase
{
public:
    // »ý¼ºÀÚ/¼Ò¸êÀÚ
    CManagerUnitLOD();
    virtual ~CManagerUnitLOD();

    // Æı«
    virtual void Destroy();

    // xxx: ±âÁ¸ ȣȯ (Á¦°Å ¿¹Á¤)
    WZRND_API void UpdateUnitLOD( CWzUnitDraw* pUnitDraw );

    // °Å¸® ¼³Á¤/¾ò±â
    WZRND_API void SetDistanceOfLOD( float* apfDist, int iNumDist );
    float* GetDistanceOfLOD();
    // °Å¸® ¼ö ¾ò±â
    int GetNumberOfDistance() const;

    // °Å¸®¿¡ µû¸¥ ½ºÅ°´× Àû¿ë ¿©ºÎ °ü·Ã
    void AutoInvalidSkinning( BOOL bUse, float* apfDist = NULL );
    float* GetSkinningDistance();
    BOOL IsSkinningLOD() const;

    // °Å¸®¿¡ µû¸¥ ³ë¸»¸Ê Àû¿ë ¿©ºÎ °ü·Ã
    void AutoInvalidNormalMap( BOOL bUse, float* apfDist = NULL );
    float* GetNormalMapDistance();
    BOOL IsNormalMapLOD() const;

    // °Å¸®¿¡ µû¸¥ ÆäÀ̵å È¿°ú Àû¿ë ¿©ºÎ °ü·Ã
    void AutoUnitFade( BOOL bUse, float* apfDist = NULL );
    float* GetFadeDistance();
    BOOL IsEnableUnitFade() const;

    // À¯´Ö LOD È°¼º ¿©ºÎ ¼³Á¤/¾ò±â
    void EnableUnitLOD( BOOL bEnable );
    BOOL IsUnitLOD() const;

    // À¯´ÖÀÇ ¼­ºê ŸÀÔ LOD Àû¿ë ¿©ºÎ ¼³Á¤/¾ò±â
    void EnableUnitSubTypeLOD( BOOL bEnable );
    BOOL IsUnitSubTypeLOD() const;

    // À¯´Ö Å©±â¿¡ µû¸¥ °Å¸® °è»ê ¿©ºÎ ¼³Á¤/¾ò±â
    void EnableAffectedByUnitSize( BOOL bEnable );
    BOOL IsAffectedByUnitSize() const;

    // ±âº» À¯´Ö Å©±â ¼³Á¤/¾ò±â (À¯´Ö Å©±â¿¡ µû¸¥ °Å¸® °è»ê½Ã »ç¿ë)
    void SetDefaultUnitSize( float fSize );
    float GetDefaultUnitSize() const;

private:
    // ÃʱâÈ­
    void Initialize();
    // ÇØÁ¦
    void Release();

protected:
    CWzFlag<DWORD> m_opt;

    float* m_apfLODDist;
    int m_iNumLODDist;

    float m_fSkinningDist[2];
    float m_fNormalMapDist[2];
    float m_fFadeDist[2];

    float m_fDefUnitSize;
};

//------------------------------------------------------------------------------
/**
*/
inline float* CManagerUnitLOD::GetDistanceOfLOD()
{
    return m_apfLODDist;
}

//------------------------------------------------------------------------------
/**
*/
inline int CManagerUnitLOD::GetNumberOfDistance() const
{
    return m_iNumLODDist;
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::AutoInvalidSkinning( BOOL bUse, float* apfDist )
{
    if( bUse )
    {
        m_opt.Set( ULO_ENABLE_LODSKINNING );

        if( apfDist )
        {
            memcpy( m_fSkinningDist, apfDist, sizeof( float ) * 2 );
        }
    }
    else
    {
        m_opt.Unset( ULO_ENABLE_LODSKINNING );
    }
}

//------------------------------------------------------------------------------
/**
*/
inline float* CManagerUnitLOD::GetSkinningDistance()
{
    return m_fSkinningDist; 
}

//------------------------------------------------------------------------------
/**
*/
inline BOOL CManagerUnitLOD::IsSkinningLOD() const
{
    return m_opt.Check( ULO_ENABLE_LODSKINNING ); 
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::AutoInvalidNormalMap( BOOL bUse, float* apfDist )
{
    if( bUse )
    {
        m_opt.Set( ULO_ENABLE_LODNORMALMAP );

        if( apfDist )
        {
            memcpy( m_fNormalMapDist, apfDist, sizeof( float ) * 2 );
        }
    }
    else
    {
        m_opt.Unset( ULO_ENABLE_LODNORMALMAP );
    }
}

//------------------------------------------------------------------------------
/**
*/
inline float* CManagerUnitLOD::GetNormalMapDistance()
{
    return m_fNormalMapDist; 
}

//------------------------------------------------------------------------------
/**
*/
inline BOOL CManagerUnitLOD::IsNormalMapLOD() const
{
    return m_opt.Check( ULO_ENABLE_LODNORMALMAP ); 
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::AutoUnitFade( BOOL bUse, float* apfDist )
{
    if( bUse )
    {
        m_opt.Set( ULO_ENABLE_LODUNITFADE );

        if( apfDist )
        {
            memcpy( m_fFadeDist, apfDist, sizeof( float ) * 2 );
        }
    }
    else
    {
        m_opt.Unset( ULO_ENABLE_LODUNITFADE );
    }
}

//------------------------------------------------------------------------------
/**
*/
inline float* CManagerUnitLOD::GetFadeDistance()
{
    return m_fFadeDist; 
}

//------------------------------------------------------------------------------
/**
*/
inline BOOL CManagerUnitLOD::IsEnableUnitFade() const
{
    return m_opt.Check( ULO_ENABLE_LODUNITFADE );; 
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::EnableUnitLOD( BOOL bEnable )
{
    m_opt.SetB( ULO_ENABLE_UNITLOD, bEnable );
}

//------------------------------------------------------------------------------
/**
*/
inline BOOL CManagerUnitLOD::IsUnitLOD() const
{
    return m_opt.Check( ULO_ENABLE_UNITLOD );
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::EnableUnitSubTypeLOD( BOOL bEnable )
{
    m_opt.SetB( ULO_USE_UNITSUBTYPE_LOD, bEnable );
}

//------------------------------------------------------------------------------
/**
*/
inline BOOL CManagerUnitLOD::IsUnitSubTypeLOD() const
{
    return m_opt.Check( ULO_USE_UNITSUBTYPE_LOD ); 
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::EnableAffectedByUnitSize( BOOL bEnable )
{
    m_opt.SetB( ULO_AFFECTED_BY_UNITSIZE, bEnable );
}

//------------------------------------------------------------------------------
/**
*/
inline BOOL CManagerUnitLOD::IsAffectedByUnitSize() const
{
    return m_opt.Check( ULO_AFFECTED_BY_UNITSIZE ); 
}

//------------------------------------------------------------------------------
/**
*/
inline void CManagerUnitLOD::SetDefaultUnitSize( float fSize )
{
    WzAssert( fSize > 0.0f );

    m_fDefUnitSize = max( fSize, 0.00001f ); 
}

//------------------------------------------------------------------------------
/**
*/
inline float CManagerUnitLOD::GetDefaultUnitSize() const
{
    return m_fDefUnitSize; 
}

#endif // _3DRENDERER_MANAGERUNITLOD_H_