/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     gfx_TransformNode.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: 25777 $
 *---------------------------------------------------------------------------*/

#ifndef NW_GFX_TRANSFORMNODE_H_
#define NW_GFX_TRANSFORMNODE_H_

#include <nw/gfx/gfx_SceneNode.h>

#include <nw/gfx/gfx_CalculatedTransform.h>

namespace nw
{
namespace gfx
{

//---------------------------------------------------------------------------
//! @brief        変換情報を持つシーンノードを表すクラスです。
//---------------------------------------------------------------------------
class TransformNode : public SceneNode
{
private:
    NW_DISALLOW_COPY_AND_ASSIGN(TransformNode);

public:
    NW_UT_RUNTIME_TYPEINFO;

    //! @brief マトリクス計算時に呼ばれるコールバック用シグナルの定義です。
    //!
    //! @sa PostCalculateWorldMatrixSignal
    typedef ut::Signal2<void, TransformNode*, SceneContext*> CalculateMatrixSignal;
    
    //! @brief マトリクス計算時に呼ばれるコールバック用スロットの定義です。
    typedef CalculateMatrixSignal::SlotType CalculateMatrixSlot;
    
    //! @brief 設定内容です。
    struct Description : public SceneNode::Description
    {
        //! @brief コンストラクタです。
        Description(){}
    };

    //----------------------------------------
    //! @name 作成／破棄
    //@{
    
    //! @brief トランスフォームノードを動的に構築するためのクラスです。
    //!
    //! IsFixedSizeMemory の初期値は true です。false に変更すると、各種最大数の設定は無視されます。
    class DynamicBuilder
    {
    public:
        //! @brief コンストラクタです。
        DynamicBuilder() {}
        //! @brief デストラクタです。
        ~DynamicBuilder() {}

        //! @brief 生成時以外にもメモリを確保するかどうかのフラグを設定します。
        //! 
        //!        true を指定すると、生成時のみ固定サイズのメモリ確保を行います。
        //!
        //!        false を指定すると、生成時以外にも必要に応じて動的にメモリ確保が行われます。
        DynamicBuilder& IsFixedSizeMemory(bool isFixedSizeMemory)
        {
            m_Description.isFixedSizeMemory = isFixedSizeMemory;
            return *this;
        }

        //! @brief 子の最大数を設定します。
        DynamicBuilder& MaxChildren(int maxChildren)
        {
            m_Description.maxChildren = maxChildren;
            return *this;
        }

        //! @brief 管理できるコールバックの最大数を設定します。
        DynamicBuilder& MaxCallbacks(int maxCallbacks)
        {
            m_Description.maxCallbacks = maxCallbacks;
            return *this;
        }

        //! @brief        トランスフォームノードを生成します。
        //!
        //! @param[in]    allocator アロケータです。
        //!
        //! @return       生成したトランスフォームノードを返します。
        //!
        TransformNode* Create(os::IAllocator* allocator);

    private:
        TransformNode::Description m_Description;
    };
    
    //! @brief        リソースからトランスフォームノードを生成します。
    //!
    //! @param[in]    parent 親のノードです。
    //! @param[in]    resource リソースです。
    //! @param[in]    description 設定内容です。
    //! @param[in]    allocator アロケータです。
    //!
    //! @return       生成されたトランスフォームノードです。
    //!
    static TransformNode* Create(
        SceneNode* parent,
        ResSceneObject resource,
        const TransformNode::Description& description,
        os::IAllocator* allocator);

    //@}

    //----------------------------------------
    //! @name リソース
    //@{
    
    //! @brief トランスフォームノードのリソースを取得します。
    ResTransformNode GetResTransformNode() 
    {
        return ResStaticCast<ResTransformNode>( this->GetResSceneObject() );
    }
    
    //! @brief トランスフォームノードのリソースを取得します。
    const ResTransformNode GetResTransformNode() const 
    {
        return ResStaticCast<ResTransformNode>( this->GetResSceneObject() );
    }

    //@}
    
    //----------------------------------------
    //! @name トランスフォーム
    //@{
    
    //! @brief 変換情報を取得します。
    CalculatedTransform& Transform() { return m_Transform; }

    //! @brief 変換情報を取得します。
    const CalculatedTransform& Transform() const { return m_Transform; }

    //! @brief ワールドマトリクスを取得します。
    math::MTX34& WorldMatrix() { return m_WorldMatrix; }
    
    //! @brief ワールドマトリクスを取得します。
    const math::MTX34& WorldMatrix() const { return m_WorldMatrix; }

    //! @brief WorldMatrix 計算後の詳細な変換情報を取得します。
    //!        
    CalculatedTransform& WorldTransform() { return m_CalculatedTransform; }
    
    //! @brief WorldMatrix 計算後の詳細な変換情報を取得します。
    //!        TransformMatrix にはこのノードの Rotate と Translate に親ノードまでの Scale が掛かっています。
    //!        Scale は親ノードまでの累積のスケールとなります。
    const CalculatedTransform& WorldTransform() const { return m_CalculatedTransform; }

    //! @brief ワールド行列の逆行列を取得します。2回目以降は、キャッシュを利用します。
    const math::MTX34& InverseWorldMatrix() const;

    //! @brief ワールド行列の逆行列のキャッシュを無効化します。(ワールド行列を更新する際に呼び出します。)
    void InvalidateInverseWorldMatrix();
    
    //! @brief 方向情報を更新します。
    virtual void UpdateDirection() {}

    //! @brief        変換情報に関する更新を行います。
    //!
    //! @param[in]    worldMatrixUpdater ワールドマトリクス更新クラスです。
    //! @param[in]    sceneContext シーンコンテキストです。
    //!
    virtual void UpdateTransform(
        WorldMatrixUpdater* worldMatrixUpdater,
        SceneContext* sceneContext);
    
    //@}
    
    //----------------------------------------
    //! @name シーンツリー
    //@{
    
    //! @brief        ビジターを受け付けます。
    //!
    //! @param[in]    visitor ビジターです。
    //!
    virtual void Accept(ISceneVisitor* visitor);

    //! @brief 親ノードをたどりワールドマトリクスを取得します。
    virtual const math::MTX34& TrackbackWorldMatrix() const
    {
        return this->WorldMatrix();
    }

    //! @brief 親ノードをたどりワールドトランスフォームを取得します。
    virtual const CalculatedTransform& TrackbackWorldTransform() const
    {
        return this->WorldTransform();
    }
    
    //! @brief 親ノードをたどりローカルトランスフォームを取得します。
    virtual const CalculatedTransform& TrackbackLocalTransform() const
    {
        return this->Transform();
    }

    //! @brief 親ノードからのトランスフォーム変換情報を継承します。
    NW_DEPRECATED_FUNCTION(NW_INLINE void InheritTransformStates());

    //! @brief 親ノードから変換情報を継承します。
    NW_INLINE virtual void InheritTraversalResults();
    
    //@}
    
    //----------------------------------------
    //! @name コールバック
    //@{
    
    //! @brief ワールドマトリクス計算後のシグナルを取得します。
    //!
    //! @sa CalculateMatrixSignal
    CalculateMatrixSignal& PostCalculateWorldMatrixSignal()
    {
        return *m_PostCalculateWorldMatrixSignal;
    }
    
    //! @brief ワールドマトリクス計算後のシグナルを取得します。
    //!
    //! @sa CalculateMatrixSignal
    const CalculateMatrixSignal& PostCalculateWorldMatrixSignal() const
    {
        return *m_PostCalculateWorldMatrixSignal;
    }
    
    //@}

protected:
    //----------------------------------------
    //! @name コンストラクタ／デストラクタ
    //@{
    
    //! @brief コンストラクタです。
    TransformNode(
        os::IAllocator* allocator,
        ResTransformNode resObj,
        const TransformNode::Description& description);

    //! @brief デストラクタです。
    virtual ~TransformNode()
    {
        SafeDestroy(m_PostCalculateWorldMatrixSignal);
    }

    virtual Result Initialize(os::IAllocator* allocator);

    //@}

    //! @brief 親ノードの変換情報を継承した方向を計算します。
    void CalcInheritingDiretion(
        math::VEC3& inheritingDirection,
        const math::VEC3 &direction) const
    {
        if (this->GetParent() == NULL)
        {
            inheritingDirection = direction;
        }
        else
        {
            const math::MTX34& parentWorldMatrix =  this->TrackbackWorldMatrix();
            inheritingDirection.x =
                parentWorldMatrix.f._00 * direction.x +
                parentWorldMatrix.f._01 * direction.y +
                parentWorldMatrix.f._02 * direction.z;
    
            inheritingDirection.y =
                parentWorldMatrix.f._10 * direction.x +
                parentWorldMatrix.f._11 * direction.y +
                parentWorldMatrix.f._12 * direction.z;
    
            inheritingDirection.z =
                parentWorldMatrix.f._20 * direction.x +
                parentWorldMatrix.f._21 * direction.y +
                parentWorldMatrix.f._22 * direction.z;
        }
    }

    
    //! @brief   Initialize() の実行に必要なメモリサイズを取得します。
    //!
    //! @details :private
    static void GetMemorySizeForInitialize( 
        os::MemorySizeCalculator* pSize,
        ResTransformNode resTransformNode,
        Description description)
    {
        NW_ASSERT(description.isFixedSizeMemory);

        SceneNode::GetMemorySizeForInitialize(pSize, resTransformNode, description);

        // TransformNode::CreateCallbacks
        if (description.maxCallbacks == 0)
        {
            CalculateMatrixSignal::GetMemorySizeForInvalidateSignalInternal(pSize);
        }
        else
        {
            CalculateMatrixSignal::GetMemorySizeForFixedSizedSignalInternal(pSize, description.maxCallbacks);
        }
    }
    
private:
    //! @brief コールバック関数を生成します。
    Result CreateCallbacks(os::IAllocator* allocator);
    
    CalculatedTransform m_Transform;
    math::MTX34 m_WorldMatrix;
    CalculatedTransform m_CalculatedTransform;

    mutable math::MTX34 m_InverseWorldMatrix;
    mutable bool m_IsInverseWorldMatrixValid;

    CalculateMatrixSignal* m_PostCalculateWorldMatrixSignal;
    bool m_IsBranchWorldMatrixCalculationEnabled;
    Description m_Description;
};

//----------------------------------------
NW_INLINE void
TransformNode::InheritTraversalResults()
{
    SceneNode::InheritTraversalResults();

    SceneNode* parent = this->GetParent();
    bit32 results = this->GetTraversalResults();

    if (this->Transform().IsEnabledFlags(CalculatedTransform::FLAG_IS_DIRTY))
    {
        results = ut::EnableFlag(results, SceneNode::FLAG_IS_DIRTY);
    }
    else if (parent== NULL)
    {
        results = ut::DisableFlag(results, SceneNode::FLAG_IS_DIRTY);
    }
    else if (parent->IsEnabledResults(SceneNode::FLAG_IS_DIRTY))
    {
        results = ut::EnableFlag(results, SceneNode::FLAG_IS_DIRTY);
    }
    else
    {
        results = ut::DisableFlag(results, SceneNode::FLAG_IS_DIRTY);
    }

    this->SetTraversalResults(results);
}

//----------------------------------------
NW_INLINE void
TransformNode::InheritTransformStates()
{
    this->InheritTraversalResults();
}


} // namespace gfx
} // namespace nw

#endif // NW_GFX_TRANSFORMNODE_H_