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

  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: 25728 $
 *---------------------------------------------------------------------------*/

#include "precompiled.h"

#include <nw/gfx/gfx_SkeletalModel.h>
#include <nw/gfx/gfx_ISceneVisitor.h>
#include <nw/gfx/gfx_AnimObject.h>

#include <nw/anim/res/anim_ResAnimGroup.h>

#include <nw/ut/ut_ResUtil.h>
#include <nw/ut/ut_ResDictionary.h>
#include <nw/ut/ut_Foreach.h>

namespace nw
{
namespace gfx
{

NW_UT_RUNTIME_TYPEINFO_DEFINITION( SkeletalModel, Model );

//----------------------------------------
SkeletalModel*
SkeletalModel::Builder::Create(
            SceneNode* parent,
            ResSceneObject resource,
            os::IAllocator* allocator)
{
    NW_NULL_ASSERT(allocator);

    ResSkeletalModel resModel = ResStaticCast<ResSkeletalModel>(resource);

    GfxPtr<Skeleton> skeleton;
    bool isSharedSkeleton = true;
    if (m_Description.sharedSkeleton != NULL)
    {
        // 所有権の移動を行いません。
        skeleton.Reset(m_Description.sharedSkeleton, false);
        isSharedSkeleton = true;
    }
    else
    {
        // スケルトン作成
        ResSkeleton resSkeleton = resModel.GetSkeleton();
        NW_ASSERT(resSkeleton.IsValid());
        Skeleton::TransformPose::TransformArray poseTransforms(resSkeleton.GetBonesCount(), allocator);
        ResBoneArray bones = resSkeleton.GetBones();
        ResBoneArray::iterator bonesEnd = bones.end();
        for (ResBoneArray::iterator bone = bones.begin(); bone != bonesEnd; ++bone)
        {
            // リソースから計算済みトランスフォームへデータをコピーします。
            poseTransforms.PushBackFast(*bone);
        }
        skeleton.Reset(StandardSkeleton::Create(
            resSkeleton,
            m_Description.maxCallbacks,
            m_Description.isFixedSizeMemory,
            poseTransforms,
            allocator));

        isSharedSkeleton = false;
    }

    // モデル作成
    void* memory = allocator->Alloc(sizeof(SkeletalModel));
    NW_NULL_ASSERT(memory);
    
    SkeletalModel* model = new(memory) SkeletalModel(
        allocator,
        resModel,
        skeleton,
        isSharedSkeleton,
        m_Description);

    Result result = model->Initialize(allocator);
    NW_ASSERT(result.IsSuccess());

    if (parent)
    {
        bool isAttached = parent->AttachChild(model);
        NW_ASSERT(isAttached);
    }

    return model;
}

//----------------------------------------
void
SkeletalModel::Accept(
    ISceneVisitor* visitor
)
{
    visitor->VisitSkeletalModel(this);
    AcceptChildren(visitor);
}

//----------------------------------------
Result
SkeletalModel::CreateSkeletalAnimGroup(os::IAllocator* allocator)
{
    Result result = INITIALIZE_RESULT_OK;

    AnimBinding* animBinding = GetAnimBinding();
    if (animBinding == NULL)
    {
        return result;
    }

    ResSceneObject resSceneObject = GetResSceneObject();
    ResSkeletalModel resModel = *reinterpret_cast<ResSkeletalModel*>(&resSceneObject);
    NW_ASSERT(resModel.IsValid());

    ResSkeleton resSkeleton = resModel.GetSkeleton();
    Skeleton::TransformPose& pose = m_Skeleton->LocalTransformPose();
    Skeleton::OriginalPose& originalPose = m_Skeleton->LocalOriginalPose();

    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* animGroup = AnimGroup::Builder()
                .ResAnimGroup(resAnimGroup)
                .SetSceneNode(this)
                .UseOriginalValue(true)
                .Create(allocator);

            if (animGroup == NULL)
            {
                result |= Result::MASK_FAIL_BIT;
            }

            NW_ENSURE_AND_RETURN(result);

            const int animMemberCount = animGroup->GetMemberCount();
            for (int memberIdx = 0; memberIdx < animMemberCount; ++memberIdx)
            {
                anim::ResAnimGroupMember resAnimGroupMember =
                    animGroup->GetResAnimGroupMember(memberIdx);

                // TODO: ResBoneMemberDataの情報を利用する
                ResBone bone = resSkeleton.GetBones(resAnimGroupMember.GetPath());
                NW_ASSERT(bone.IsValid());
                const int boneIdx = bone.GetIndex();
                animGroup->SetTargetObjectIndex(memberIdx, boneIdx);
                animGroup->SetTargetPtr(memberIdx, pose.GetTransform(boneIdx));
                animGroup->SetOriginalValue(memberIdx, originalPose.GetTransform(boneIdx));

                void* object = GetAnimTargetObject(resAnimGroupMember);
                animGroup->SetTargetObject(memberIdx, object);
            }
            animBinding->SetAnimGroup(animGroupIdx, animGroup);
            m_SkeletalAnimGroup = animGroup;
            m_SkeletalAnimBindingIndex = animGroupIdx;
            break; // 他にスケルタルモデル専用のアニメーショングループがないので
        }
    }

    return result;
}

//----------------------------------------
void*
SkeletalModel::GetAnimTargetObject(const anim::ResAnimGroupMember& anim)
{
    switch(anim.GetObjectType())
    {
    case nw::anim::ResAnimGroupMember::OBJECT_TYPE_BONE:
        {
            nw::anim::ResBoneMember member = ResStaticCast<nw::anim::ResBoneMember>(anim);
            const char* boneName = member.GetBoneName();

            const int boneIndex =
                GetResSkeletalModel().GetSkeleton().GetBones(boneName).GetIndex();

            // 型が変更されたらコンパイルエラーが起きるよう、
            // いったん目的の型に代入してからreturnで返す
            CalculatedTransform* ptr =
                GetSkeleton()->LocalTransformPose().GetTransform(boneIndex);
            return ptr;
        }

    default:
        NW_ASSERT(false);
        return NULL;
    }
}

//----------------------------------------
Result
SkeletalModel::Initialize(os::IAllocator* allocator)
{
    Result result = INITIALIZE_RESULT_OK;

    result |= Model::Initialize(allocator);
    NW_ENSURE_AND_RETURN(result);

    result |= CreateSkeletalAnimGroup(allocator);
    NW_ENSURE_AND_RETURN(result);

    return result;
}

} // namespace gfx
} // namespace nw