nw/gfx/gfx_SkeletalModel.h

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

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

  These coded instructions, statements, and computer programs contain proprietary
  information of Nintendo and/or its licensed developers and are protected by
  national and international copyright laws. 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.

  The content herein is highly confidential and should be handled accordingly.

  $Revision: 31311 $
 *---------------------------------------------------------------------------*/

#ifndef NW_GFX_SKELETALMODEL_H_
#define NW_GFX_SKELETALMODEL_H_

#include <nw/gfx/gfx_Model.h>
#include <nw/gfx/gfx_Skeleton.h>
#include <nw/gfx/gfx_StandardSkeleton.h>
#include <nw/gfx/gfx_AnimObject.h>

namespace nw
{
namespace anim
{
namespace res
{
class ResAnimGroupMember;
}
}
}

namespace nw
{
namespace gfx
{

//---------------------------------------------------------------------------
//! @brief        内部に軽量な階層構造を持てるモデルクラスです。
//---------------------------------------------------------------------------
class SkeletalModel  : public Model
{
private:
    NW_DISALLOW_COPY_AND_ASSIGN(SkeletalModel);

public:
    NW_UT_RUNTIME_TYPEINFO;

    //! @brief 設定内容です。
    struct Description : public Model::Description
    {
        Skeleton* sharedSkeleton; //!< 共有するスケルトンです。

        //! @brief コンストラクタです。
        Description()
            : sharedSkeleton(NULL)
        {}
    };

    //! @brief スケルタルモデルを構築するためのクラスです。
    //!
    //! IsFixedSizeMemory の初期値は true です。false に変更すると、各種最大数の設定は一部を除いて無視されます。
    class Builder
    {
    public:
        //! コンストラクタです。
        Builder() {}

        //! デストラクタです。
        ~Builder() {}

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

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

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

        //! @brief バッファの生成オプションを設定します。
        //!
        //!
        //! @param bufferOption Model::BufferOptionで定義されるフラグの組み合わせです。
        //!        SharedMaterialModel が指定された場合、BufferOption は指定することができません。
        //!        BufferOption が指定された場合は動作を停止します。
        //!
        //! @param[in] bufferOption Model::BufferOptionで定義されるフラグの組み合わせです。
        //!
        Builder& BufferOption(bit32 bufferOption)
        {
            m_Description.bufferOption = bufferOption;
            return *this;
        }

        //! @brief マテリアルを共有する場合に共有元のモデルを設定します。
        //!
        //!        所有権の移動を行いません。
        //!        マテリアルを最初に生成したモデルがマテリアルの所有権を持ちます。
        //!        共有元のモデルが先に破棄された場合は未定義の動作となります。
        //!
        //! @param[in] model 共有するマテリアルを持つモデルです。
        //!
        Builder& SharedMaterialModel(Model* model)
        {
            m_Description.sharedMaterialModel = model;
            return *this;
        }

        //! @brief 共有するスケルトンを設定します。
        //!
        //!        作成時には所有権の移動を行いません。
        //!        スケルトンを最初に生成したモデルがスケルトンの所有権を持ちます。
        //!        共有元のモデルが先に破棄された場合は未定義の動作となります。
        //!        描画前には所有権を持つ SkeletalModel は必ず SubmitView を行う必要があります。
        //!        所有権を持つ SkeletalModel の SubmitView を行わないと、スケルトンを共有している他の SkeletalModel の更新が行われません。
        //!
        //! @param[in]  sharedSkeleton 共有するスケルトンです。
        //!
        //! @sa SwapSkeleton
        Builder& SharedSkeleton(Skeleton* sharedSkeleton)
        {
            m_Description.sharedSkeleton = sharedSkeleton;
            return *this;
        }

        //! @brief AnimGroup ごとの AnimObject の最大数を指定します。
        //!
        //!        MaxAnimObjectsPerGroup の指定は IsFixedSizeMemory が false でも有効になります。
        Builder& MaxAnimObjectsPerGroup(s32 maxAnimObjectCount)
        {
            m_Description.maxAnimObjectsPerGroup = maxAnimObjectCount;
            return *this;
        }

        //! @brief アニメーション可能かを設定します。
        //!
        //!        false を指定すると AnimBinding の生成を行いません。
        //!        そのためアニメーションのバインドができなくなりますが、
        //!        アニメーション更新の処理が行われなくなるため、
        //!        シーンアップデートのパフォーマンスが向上します。
        Builder& IsAnimationEnabled(bool isAnimationEnabled)
        {
            m_Description.isAnimationEnabled = isAnimationEnabled;
            return *this;
        }

        //! @brief          スケルタルモデルを生成します。
        //!
        //!                 parent に NULL を指定した場合は、親ノードへの取り付けを行いません。
        //!
        //! @param[in]    allocator アロケータです。
        //! @param[in]    parent 親ノードです。
        //! @param[in]    resource リソースです。
        //!
        //! @return       生成したスケルタルモデルを返します。
        //!
        SkeletalModel* Create(
            SceneNode* parent,
            ResSceneObject resource,
            os::IAllocator* allocator);

        //! @brief        生成時に必要なメモリサイズを取得します。
        //!
        //! @param[in]    resModel リソースです。
        //! @param[in]    alignment 計算に用いるアライメントです。2 のべき乗である必要があります。
        size_t GetMemorySize(
            ResSkeletalModel resModel,
            size_t alignment = os::IAllocator::DEFAULT_ALIGNMENT) const
        {
            os::MemorySizeCalculator size(alignment);

            GetMemorySizeInternal(&size, resModel);

            return size.GetSizeWithPadding(alignment);
        }

        //! @brief        生成時に必要なデバイスメモリサイズを取得します。
        //!
        //! @param[in]    alignment 計算に用いるアライメントです。2 のべき乗である必要があります。
        size_t GetDeviceMemorySize(
            ResSkeletalModel,
            size_t alignment = os::IAllocator::DEFAULT_ALIGNMENT) const
        {
            NW_UNUSED_VARIABLE(alignment);

            return 0;
        }

        //! @details :private
        void GetMemorySizeInternal(
            os::MemorySizeCalculator* pSize,
            ResSkeletalModel resModel) const
        {
            os::MemorySizeCalculator& size = *pSize;

            if (m_Description.sharedSkeleton == NULL)
            {
                ResSkeleton resSkeleton = resModel.GetSkeleton();

#ifdef NW_MOVE_ARRAY_CACHE_LINE_ALIGNMENT_ENABLED
                size.Add(
                    sizeof(Skeleton::TransformPose::Transform) * resSkeleton.GetBonesCount(),
                    Skeleton::TransformPose::TransformArray::MEMORY_ALIGNMENT);
#else
                size += sizeof(Skeleton::TransformPose::Transform) * resSkeleton.GetBonesCount();
#endif
                StandardSkeleton::GetMemorySizeInternal(
                    pSize,
                    resSkeleton,
                    m_Description.maxCallbacks);
            }

            // モデル作成
            size += sizeof(SkeletalModel);
            SkeletalModel::GetMemorySizeForInitialize(pSize, resModel, m_Description);
        }

        //! @details :private
        void GetDeviceMemorySizeInternal(
            os::MemorySizeCalculator*,
            ResSkeletalModel) const
        {
        }

    private:
        SkeletalModel::Description m_Description;
    };

    //----------------------------------------
    //! @name シーンツリー
    //@{

    //! @brief        ビジターを受け付けます。
    //!
    //! @param[in]    visitor ビジターです。
    //!
    virtual void Accept(ISceneVisitor* visitor);

    //@}

    //----------------------------------------
    //! @name リソース
    //@{

    //! スケルタルモデルのリソースを取得します。
    ResSkeletalModel GetResSkeletalModel()
    {
        return ResDynamicCast<ResSkeletalModel>(this->GetResSceneObject());
    }

    //! スケルタルモデルのリソースを取得します。
    const ResSkeletalModel GetResSkeletalModel() const
    {
        return ResDynamicCast<ResSkeletalModel>(this->GetResSceneObject());
    }

    //@}

    //----------------------------------------
    //! @name スケルトン
    //@{

    //! スケルトンを取得します。
    Skeleton* GetSkeleton() { return m_Skeleton.Get(); }

    //! スケルトンを取得します。
    const Skeleton* GetSkeleton() const { return m_Skeleton.Get(); }

    //! 他モデルのスケルトンを共有している場合は true を返します。
    bool IsSharingSkeleton() const { return this->m_SharingSkeleton; }

    //! @brief スケルトンの所有権を交換します。
    //!
    //! 保有するスケルトンの所有権を交換します。
    //! 共有スケルトンのオーナーとなる SkeletalModel を変更する場合などに用いることができます。
    //!
    //! @param[in] skeletalModel スケルトンを交換するスケルタルモデルです。
    //!
    void SwapSkeleton( SkeletalModel* skeletalModel )
    {
        this->m_Skeleton.Swap(skeletalModel->m_Skeleton);
        bool sharingSkeleton = this->m_SharingSkeleton;
        this->m_SharingSkeleton = skeletalModel->m_SharingSkeleton;
        skeletalModel->m_SharingSkeleton = sharingSkeleton;
    }

    //@}

    //----------------------------------------
    //! @name アニメーション
    //@{

    //! スケルタルアニメーショングループを取得します。
    AnimGroup* GetSkeletalAnimGroup() { return m_SkeletalAnimGroup; }

    //! スケルタルアニメーショングループを取得します。
    const AnimGroup* GetSkeletalAnimGroup() const { return m_SkeletalAnimGroup; }

    //! スケルタルアニメーショングループのアニメーションバインディング中のインデックスを取得します。
    int GetSkeletalAnimBindingIndex() const { return m_SkeletalAnimBindingIndex; }

    //! スケルタルアニメーションオブジェクトを取得します。
    const AnimObject* GetSkeletalAnimObject(int objectIndex = 0) const
    {
        NW_NULL_ASSERT(m_AnimBinding);
        return m_AnimBinding->GetAnimObject(m_SkeletalAnimBindingIndex, objectIndex);
    }

    //! スケルタルアニメーションオブジェクトを取得します。
    AnimObject* GetSkeletalAnimObject(int objectIndex = 0)
    {
        NW_NULL_ASSERT(m_AnimBinding);
        return m_AnimBinding->GetAnimObject(m_SkeletalAnimBindingIndex, objectIndex);
    }

    //! @brief スケルタルアニメーションオブジェクトを設定します。
    //!
    //! @param[in] animObject 設定するアニメーションオブジェクトです。NULL を指定するとアニメーションを解除します。
    void SetSkeletalAnimObject(AnimObject* animObject, int objectIndex = 0)
    {
        NW_NULL_ASSERT(m_AnimBinding);
        m_AnimBinding->SetAnimObject(m_SkeletalAnimBindingIndex, animObject, objectIndex);
    }

    //! フルベイクアニメーションを使用するかを取得します。
    bool GetFullBakedAnimEnabled() const
    {
        return m_FullBakedAnimEnabled;
    }

    //! @brief フルベイクアニメーションを使用するかを設定します。
    //!
    //! true を指定すると、スケルトンの更新処理が省略されます。
    //! また、 ResSkeletonData::FLAG_MODEL_COORDINATE フラグが有効に設定されます。
    //! true を指定した状態では、通常のアニメーションは正常に再生できませんので注意してください。
    //!
    //! false を指定すると、 ResSkeletonData::FLAG_MODEL_COORDINATE フラグが無効に設定されます。
    //!
    //! 共有スケルトンを使用している場合は、
    //! 共有元のスケルトンの上記フラグが変更されますので注意してください。
    void SetFullBakedAnimEnabled(bool enable);

    //@}

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

    //! @brief   Initialize() の実行に必要なメモリサイズを取得します。
    //!
    //! @details :private
    static void GetMemorySizeForInitialize(
        os::MemorySizeCalculator* pSize,
        ResSkeletalModel resModel,
        Description description)
    {
        // SkeletalModel::Initialize
        os::MemorySizeCalculator& size = *pSize;

        Model::GetMemorySizeForInitialize(pSize, resModel, description);

        // SkeletalModel::CreateSkeletalAnimGroup
        if (description.isAnimationEnabled)
        {
            const int animGroupCount = resModel.GetAnimGroupsCount();
            for (int animGroupIdx = 0; animGroupIdx < animGroupCount; ++animGroupIdx)
            {
                anim::ResAnimGroup resAnimGroup = resModel.GetAnimGroups(animGroupIdx);
                const int targetType = resAnimGroup.GetTargetType();
                const bool transformFlag =
                    (resAnimGroup.GetFlags() & anim::ResAnimGroup::FLAG_IS_CALCULATED_TRANSFORM) != 0;
                if (transformFlag &&
                    targetType == anim::ResGraphicsAnimGroup::TARGET_TYPE_BONE)
                {
                    AnimGroup::Builder()
                        .ResAnimGroup(resAnimGroup)
                        .UseOriginalValue(true)
                        .GetMemorySizeInternal(pSize);
                    break; // 他にスケルタルモデル専用のアニメーショングループがないので
                }
            }
        }
    }

    //----------------------------------------
    //! @name コンストラクタ／デストラクタ
    //@{

    //! コンストラクタです。
    SkeletalModel(
        os::IAllocator* allocator,
        ResSkeletalModel resource,
        GfxPtr<Skeleton>& skeleton,
        bool isSharingSkeleton,
        const SkeletalModel::Description& description)
    : Model(
        allocator,
        resource,
        description),
      m_Skeleton(skeleton),
      m_SkeletalAnimGroup(NULL),
      m_SkeletalAnimBindingIndex(-1),
      m_SharingSkeleton(isSharingSkeleton),
      m_FullBakedAnimEnabled(false)
    {
        if (!isSharingSkeleton)
        {
            m_Skeleton->SetOwnerSkeletalModel(this);
        }
    }

    //! デストラクタです。
    virtual ~SkeletalModel()
    {
        SafeDestroy(m_SkeletalAnimGroup);
    }

    //@}

    //! スケルタルアニメーション用のアニメーショングループを生成します。
    Result CreateSkeletalAnimGroup(os::IAllocator* allocator);

    //! スケルタルアニメーションに登録するモデルデータのポインタを取得します。
    void* GetAnimTargetObject(const anim::ResAnimGroupMember& anim);

private:
    void SetupAnimGroup(AnimGroup* animGroup, bool fullBakedAnimEnabled) const;

    GfxPtr<Skeleton> m_Skeleton;
    AnimGroup* m_SkeletalAnimGroup;
    int m_SkeletalAnimBindingIndex;
    bool m_SharingSkeleton;
    bool m_FullBakedAnimEnabled;
};

} // namespace gfx
} // namespace nw

#endif // NW_GFX_SKELETALMODEL_H_