/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     gfx_ParticleTime.h

  Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Revision: 25420 $
 *---------------------------------------------------------------------------*/

#ifndef NW_GFX_PARTICLETIME_H_
#define NW_GFX_PARTICLETIME_H_

#include <nw/math.h>
#include <nw/gfx/gfx_Common.h>

//! この定義を有効にするとパーティクルの時間管理がf32になります。
//#define NW_GFX_NO_USE_PARTICLETIME

namespace nw
{
namespace gfx
{

#ifdef NW_GFX_PARTICLE_COMPAT_1_1

//! @brief パーティクル処理用の時間の型です。
typedef f32 ParticleTime;

#else

#ifndef NW_GFX_NO_USE_PARTICLETIME
//--------------------------------------------------------------------------
//! @brief        パーティクル処理用の時間のユーティリティです。
//---------------------------------------------------------------------------
class ParticleTime
{
    friend ParticleTime operator -(const ParticleTime& rhs);

public:
    //! @brief        デフォルトコンストラクタです。
    ParticleTime() : m_ParticleTime(0) {}

    //! @brief        コンストラクタです。
    //!
    //! @param[in]    value   ParticleTimeです。
    ParticleTime(const ParticleTime& value)
    {
        m_ParticleTime = value.m_ParticleTime;
    }

    //! @brief        コンストラクタです。
    //!
    //! @param[in]    ivalue   整数値です。
    ParticleTime(s32 value)
    {
        m_ParticleTime = S32ToParticleTime(value);
    }

    //! @brief        コンストラクタです。
    //!
    //! @param[in]    fvalue   32bit 浮動小数の値です。
    ParticleTime(f32 value)
    {
        m_ParticleTime = Float32ToParticleTime(value);
    }

    //! @brief        浮動小数点数で値を取得します。
    //! @return       値を浮動小数点数で返します。
    f32     GetFloat32Value() const { return ParticleTimeToFloat32(m_ParticleTime); }

    //! @brief        符号付き整数で値を取得します。
    //! @return       値を符号付き整数で返します。
    s32     GetS32Value() const { return m_ParticleTime / 0x100; }

    //! @brief        内部表現で値を取得します。
    //! @details :private
    //! @return       値を内部表現で返します。
    s32     GetParticleTimeValue() const { return m_ParticleTime; }

    ParticleTime operator +(ParticleTime right) const
    {
        ParticleTime result;
        result.m_ParticleTime = this->m_ParticleTime + right.m_ParticleTime;
        return result;
    }

    ParticleTime operator -(ParticleTime right) const
    {
        ParticleTime result;
        result.m_ParticleTime = this->m_ParticleTime - right.m_ParticleTime;
        return result;
    }

    //! @brief        整数部を取得します。
    //! @return       整数部を符号付き整数で返します。
    s32 GetIntegralParts() const
    {
        return m_ParticleTime / 0x100;
    }

    //! @brief        小数部を取得します。
    //! @return       小数部を浮動小数点数で返します。
    f32 GetFractionalParts() const
    {
        return (m_ParticleTime & 0xff) / 0x100;
    }

    //! @brief        格納している値を超えない最大の整数を取得します。
    //! @return       格納している値を超えない最大の整数を返します。
    s32 Floor() const
    {
        return m_ParticleTime / 0x100;
    }

    //! @brief        格納している値を下回らない最小の整数を取得します。
    //! @return       格納している値を下回らない最小の整数を返します。
    s32 Ceil() const
    {
        return (m_ParticleTime + 0xff) / 0x100;
    }

    //! @brief        格納している値の剰余を取得します。
    //! @param[in] value 格納している値を割る値です。
    //! @return       剰余をParticleTimeで返します。
    ParticleTime& FMod(s32 value)
    {
        this->m_ParticleTime %= S32ToParticleTime(value);
        return *this;
    }

    ParticleTime& operator =(f32 value) { this->m_ParticleTime = Float32ToParticleTime(value); return *this; }
    ParticleTime& operator =(s32 value) { this->m_ParticleTime = S32ToParticleTime(value); return *this; }
    ParticleTime& operator =(ParticleTime value) { this->m_ParticleTime = value.m_ParticleTime; return *this; }
    ParticleTime& operator +=(f32 value) { this->m_ParticleTime += Float32ToParticleTime(value); return *this; }
    ParticleTime& operator +=(s32 value) { this->m_ParticleTime += S32ToParticleTime(value); return *this; }
    ParticleTime& operator +=(ParticleTime value) { this->m_ParticleTime += value.m_ParticleTime; return *this; }
    ParticleTime& operator -=(f32 value) { this->m_ParticleTime -= Float32ToParticleTime(value); return *this; }
    ParticleTime& operator -=(s32 value) { this->m_ParticleTime -= S32ToParticleTime(value); return *this; }
    ParticleTime& operator -=(ParticleTime value) { this->m_ParticleTime -= value.m_ParticleTime; return *this; }

    bool operator ==(const ParticleTime& rhs) const { return this->m_ParticleTime == rhs.m_ParticleTime; }
    bool operator !=(const ParticleTime& rhs) const { return this->m_ParticleTime == rhs.m_ParticleTime; }
    bool operator >=(const ParticleTime& rhs) const { return this->m_ParticleTime >= rhs.m_ParticleTime; }
    bool operator <=(const ParticleTime& rhs) const { return this->m_ParticleTime <= rhs.m_ParticleTime; }
    bool operator >(const ParticleTime& rhs) const { return this->m_ParticleTime > rhs.m_ParticleTime; }
    bool operator <(const ParticleTime& rhs) const { return this->m_ParticleTime < rhs.m_ParticleTime; }

    bool operator ==(s32 rhs) const { return this->m_ParticleTime == S32ToParticleTime(rhs); }
    bool operator !=(s32 rhs) const { return this->m_ParticleTime == S32ToParticleTime(rhs); }
    bool operator >=(s32 rhs) const { return this->m_ParticleTime >= S32ToParticleTime(rhs); }
    bool operator <=(s32 rhs) const { return this->m_ParticleTime <= S32ToParticleTime(rhs); }
    bool operator >(s32 rhs) const { return this->m_ParticleTime > S32ToParticleTime(rhs); }
    bool operator <(s32 rhs) const { return this->m_ParticleTime < S32ToParticleTime(rhs); }

    // 暗黙的にf32に変換されると遅くなるので、f32への変換は用意していない

    //! @detail :private
    //! lengthで割ってからfactorを掛ける
    //! オーバーフローを考慮していないので16ビット程度の値に留めること
    ParticleTime Interp(const ParticleTime& length, s32 factor) const
    {
        s32 work = this->m_ParticleTime * factor * 0x100;
        work /= length.m_ParticleTime;

        ParticleTime result;
        result.m_ParticleTime = work;
        return result;
    }

    //! @brief        パーティクル用時間から 32bit float に変換します。
    //! @param[in]    particleTime   パーティクル用時間を表現した整数値です。
    //! @return       f32 に変換した値を返します。
    static f32 ParticleTimeToFloat32(s32 particleTime)
    {
        f32 float32 = static_cast<f32>(particleTime);
        return float32 / 0x100;
    }
    
    //! @brief        f32 からパーティクル用時間に変換します。
    //! @param[in]    value   32bit float の値です。
    //! @return       パーティクル用時間を返します。
    static s32 Float32ToParticleTime(f32 value)
    {
        s32 fixed = (int)(value * 0x100);
        return fixed;
    }

    //! @brief        s32 からパーティクル用時間に変換します。
    //! @param[in]    value   32bit signed int の値です。
    //! @return       パーティクル用時間を返します。
    static s32 S32ToParticleTime(s32 value)
    {
        return value * 0x100;
    }

private:
    s32 m_ParticleTime;
};

NW_FORCE_INLINE ParticleTime operator -(const ParticleTime& rhs)
{
    ParticleTime result;
    result.m_ParticleTime = -rhs.m_ParticleTime;
    return result;
}

#else // f32と互換にします

//--------------------------------------------------------------------------
//! @brief        パーティクル処理用の時間のユーティリティです。
//---------------------------------------------------------------------------
class ParticleTime
{
    friend ParticleTime operator -(const ParticleTime& rhs);

public:
    //! @brief        デフォルトコンストラクタです。
    ParticleTime() : m_ParticleTime(0) {}

    //! @brief        コンストラクタです。
    //! @param[in]    value   ParticleTimeです。
    ParticleTime(const ParticleTime& value)
    {
        m_ParticleTime = value.m_ParticleTime;
    }

    //! @brief        コンストラクタです。
    //! @param[in]    ivalue   整数値です。
    ParticleTime(s32 ivalue)
    {
        m_ParticleTime = ivalue;
    }

    //! @brief        コンストラクタです。
    //! @param[in]    fvalue   32bit 浮動小数の値です。
    ParticleTime(f32 fvalue)
    {
        m_ParticleTime = Float32ToParticleTime(fvalue);
    }

    //! @brief        浮動小数点数で値を取得します。
    //! @return       値を浮動小数点数で返します。
    f32     GetFloat32Value() const { return m_ParticleTime; }

    //! @brief        符号付き整数で値を取得します。
    //! @return       値を符号付き整数で返します。
    s32     GetS32Value() const { return m_ParticleTime; }

    //! @brief        内部表現で値を取得します。
    //! @details :private
    //! @return       値を内部表現で返します。
    f32     GetParticleTimeValue() const { return m_ParticleTime; }

    ParticleTime operator +(ParticleTime right) const
    {
        return ParticleTime(this->m_ParticleTime + right.m_ParticleTime);
    }

    ParticleTime operator -(ParticleTime right) const
    {
        return ParticleTime(this->m_ParticleTime - right.m_ParticleTime);
    }

    //! @brief        整数部を取得します。
    //! @return       整数部を符号付き整数で返します。
    s32 GetIntegralParts() const
    {
        return (int)m_ParticleTime;
    }

    //! @brief        小数部を取得します。
    //! @return       小数部を浮動小数点数で返します。
    f32 GetFractionalParts() const
    {
        return m_ParticleTime - (int)m_ParticleTime;
    }

    //! @brief        格納している値を超えない最大の整数を取得します。
    //! @return       格納している値を超えない最大の整数を返します。
    s32 Floor() const
    {
        return math::FFloor(m_ParticleTime);
    }

    //! @brief        格納している値を下回らない最小の整数を取得します。
    //! @return       格納している値を下回らない最小の整数を返します。
    s32 Ceil() const
    {
        return math::FCeil(m_ParticleTime);
    }

    //! @brief        格納している値の剰余を取得します。
    //! @param[in] value 格納している値を割る値です。
    //! @return       剰余をParticleTimeで返します。
    ParticleTime& FMod(s32 value)
    {
        this->m_ParticleTime = nw::math::FMod(this->m_ParticleTime, static_cast<f32>(value));
        return *this;
    }

    ParticleTime& operator =(f32 value) { this->m_ParticleTime = Float32ToParticleTime(value); return *this; }
    ParticleTime& operator =(s32 value) { this->m_ParticleTime = value; return *this; }
    ParticleTime& operator =(ParticleTime value) { this->m_ParticleTime = value.m_ParticleTime; return *this; }
    ParticleTime& operator +=(f32 value) { this->m_ParticleTime += value; return *this; }
    ParticleTime& operator +=(s32 value) { this->m_ParticleTime += value; return *this; }
    ParticleTime& operator +=(ParticleTime value) { this->m_ParticleTime += value.m_ParticleTime; return *this; }
    ParticleTime& operator -=(f32 value) { this->m_ParticleTime -= value; return *this; }
    ParticleTime& operator -=(s32 value) { this->m_ParticleTime -= value; return *this; }
    ParticleTime& operator -=(ParticleTime value) { this->m_ParticleTime -= value.m_ParticleTime; return *this; }

    bool operator ==(const ParticleTime& rhs) const { return this->m_ParticleTime == rhs.m_ParticleTime; }
    bool operator !=(const ParticleTime& rhs) const { return this->m_ParticleTime == rhs.m_ParticleTime; }
    bool operator >=(const ParticleTime& rhs) const { return this->m_ParticleTime >= rhs.m_ParticleTime; }
    bool operator <=(const ParticleTime& rhs) const { return this->m_ParticleTime <= rhs.m_ParticleTime; }
    bool operator >(const ParticleTime& rhs) const { return this->m_ParticleTime > rhs.m_ParticleTime; }
    bool operator <(const ParticleTime& rhs) const { return this->m_ParticleTime < rhs.m_ParticleTime; }

    bool operator ==(s32 rhs) const { return this->m_ParticleTime == rhs; }
    bool operator !=(s32 rhs) const { return this->m_ParticleTime == rhs; }
    bool operator >=(s32 rhs) const { return this->m_ParticleTime >= rhs; }
    bool operator <=(s32 rhs) const { return this->m_ParticleTime <= rhs; }
    bool operator >(s32 rhs) const { return this->m_ParticleTime > rhs; }
    bool operator <(s32 rhs) const { return this->m_ParticleTime < rhs; }

    // 暗黙的にf32に変換されると遅くなるので、f32への変換は用意していない

    ParticleTime Interp(const ParticleTime& length, s32 factor) const
    {
        return ParticleTime(this->GetFloat32Value() / length.GetFloat32Value() * factor);
    }

    //! @brief        パーティクル用時間から 32bit float に変換します。
    //! @param[in]    particleTime   パーティクル用時間を表現した整数値です。
    //! @return       f32 に変換した値を返します。
    static f32 ParticleTimeToFloat32(f32 particleTime)
    {
        return particleTime;
    }
    
    //! @brief        f32 からパーティクル用時間に変換します。
    //! @param[in]    value   32bit float の値です。
    //! @return       パーティクル用時間を返します。
    static f32 Float32ToParticleTime(f32 value)
    {
        return value;
    }

private:
    f32 m_ParticleTime;
};

NW_FORCE_INLINE ParticleTime operator -(const ParticleTime& rhs)
{
    return ParticleTime(-rhs.m_ParticleTime);
}


#endif
#endif

} // namespace gfx
} // namespace nw

#endif // NW_GFX_PARTICLETIME_H_