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

#include "precompiled.h"

#include <nw/gfx/gfx_Light.h>
#include <nw/gfx/gfx_ISceneVisitor.h>

namespace nw
{
namespace gfx
{

NW_UT_RUNTIME_TYPEINFO_DEFINITION(Light, TransformNode);

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

//----------------------------------------
Result
Light::CreateAnimGroup(os::IAllocator* allocator)
{
    Result result = INITIALIZE_RESULT_OK;

    NW_ASSERT(m_OriginalValue.IsValid());

    if (!m_AnimBinding)
    {
        // DynamicBuilderを使用した場合は生成されない
        return result;
    }

    ResSceneNode resSceneNode = GetResSceneNode();
    NW_ASSERT(resSceneNode.IsValid());

    NW_ASSERT(resSceneNode.GetAnimGroupsCount() == 1);
    anim::ResAnimGroup resAnimGroup = resSceneNode.GetAnimGroups(0);

    NW_ASSERT(resAnimGroup.GetTargetType() == anim::ResGraphicsAnimGroup::TARGET_TYPE_LIGHT);

    AnimGroup* animGroup = AnimGroup::Builder()
        .ResAnimGroup(resAnimGroup)
        .SetSceneNode(this)
        .UseOriginalValue(true) // TODO: 選択できる必要はある？
        .Create(allocator);

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

    NW_ENSURE_AND_RETURN(result);

    m_AnimGroup = animGroup;

    // 各メンバの参照解決
    const int animMemberCount = m_AnimGroup->GetMemberCount();
    for (int memberIdx = 0; memberIdx < animMemberCount; ++memberIdx)
    {
        anim::ResAnimGroupMember member = m_AnimGroup->GetResAnimGroupMember(memberIdx);

        void* object = GetAnimTargetObject(member);
        m_AnimGroup->SetTargetObject(memberIdx, object);

        // TODO: アドレス算出もSetterに似た実装で行う？
        if (member.GetObjectType() == anim::ResAnimGroupMember::OBJECT_TYPE_TRANSFORM &&
            member.GetMemberType() == anim::ResTransformMember::MEMBER_TYPE_TRANSFORM)
        {
            m_AnimGroup->SetTargetPtr(memberIdx, &this->Transform());
        }
        else
        {
            u8* target = static_cast<u8*>(object);
            target += member.GetMemberOffset();
            m_AnimGroup->SetTargetPtr(memberIdx, target);
        }

        m_AnimGroup->SetTargetObjectIndex(memberIdx, 0); // TODO: 要検討

        if (member.GetObjectType() == nw::anim::ResAnimGroupMember::OBJECT_TYPE_TRANSFORM)
        {
            m_AnimGroup->SetOriginalValue(memberIdx, &m_OriginalTransform);
        }
        else
        {
            u8* originalValue = reinterpret_cast<u8*>(m_OriginalValue.ptr());
            originalValue += member.GetMemberOffset();
            m_AnimGroup->SetOriginalValue(memberIdx, originalValue);
        }
    }

    m_AnimBinding->SetAnimGroup(0, m_AnimGroup);

    return result;
}

//----------------------------------------
void
Light::DestroyOriginalValue()
{
    NW_ASSERT(m_OriginalValue.IsValid());

    GetAllocator().Free(m_OriginalValue.ptr());
    m_OriginalValue = ResLight(NULL);
}

//----------------------------------------
void*
Light::GetAnimTargetObject(const anim::ResAnimGroupMember& anim)
{
    switch (anim.GetObjectType())
    {
    case anim::ResAnimGroupMember::OBJECT_TYPE_TRANSFORM:
        {
            return static_cast<gfx::TransformNode*>(this);
        }

    case anim::ResAnimGroupMember::OBJECT_TYPE_LIGHT:
        {
            ResLight resLight = ResDynamicCast<ResLight>(this->GetResSceneObject());
            NW_ASSERT(resLight.IsValid());

            ResLightData* ptr = resLight.ptr();
            return ptr;
        }

    case anim::ResAnimGroupMember::OBJECT_TYPE_FRAGMENT_LIGHT:
        {
            NW_ASSERT(ut::IsTypeOf<gfx::FragmentLight>(this));
            ResFragmentLightData* ptr = static_cast<gfx::FragmentLight&>(*this).GetResFragmentLight().ptr();
            return ptr;
        }

    case anim::ResAnimGroupMember::OBJECT_TYPE_AMBIENT_LIGHT:
        {
            NW_ASSERT(ut::IsTypeOf<gfx::AmbientLight>(this));
            ResAmbientLightData* ptr = static_cast<gfx::AmbientLight&>(*this).GetResAmbientLight().ptr();
            return ptr;
        }

#if defined(NW_GFX_VERTEX_LIGHT_ENABLED)
    case anim::ResAnimGroupMember::OBJECT_TYPE_VERTEX_LIGHT:
        {
            NW_ASSERT(ut::IsTypeOf<gfx::VertexLight>(this));
            ResVertexLightData* ptr = static_cast<gfx::VertexLight&>(*this).GetResVertexLight().ptr();
            return ptr;
        }
#endif
    case anim::ResAnimGroupMember::OBJECT_TYPE_HEMISPHERE_LIGHT:
        {
            NW_ASSERT(ut::IsTypeOf<gfx::HemiSphereLight>(this));
            ResHemiSphereLightData* ptr = static_cast<gfx::HemiSphereLight&>(*this).GetResHemiSphereLight().ptr();
            return ptr;
        }

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

//----------------------------------------
bool
Light::ValidateLightAnimType(AnimObject* animObject)
{
    if (animObject == NULL)
    {
        // NULLの時はアニメを取り外そうとしているので、型チェックは通る
        return true;
    }

    // blenderならば、再帰的に調べないといけない
    AnimBlender* blender = ut::DynamicCast<AnimBlender*>(animObject);

    if (blender != NULL)
    {
        const int animObjCount = blender->GetAnimObjectCount();
        for (int i = 0; i < animObjCount; ++i)
        {
            AnimObject* animObj = blender->GetAnimObject(i);
            
            // ひとつでもvalidateに失敗したらfalseを返す
            if (!ValidateLightAnimType(animObj))
            {
                return false;
            }
        }

        // 全てのAnimObjectのチェックを通過すれば成功
        return true;
    }
    else
    {
        // blenderではなかったので、AnimEvaluatorのはず
        AnimEvaluator* evaluator = ut::DynamicCast<AnimEvaluator*>(animObject);
        NW_NULL_ASSERT(evaluator);

        anim::ResLightAnim lightAnim(evaluator->GetAnimData().ptr());

        return (
            (lightAnim.GetLightType() == GetLightType()) &&
            (lightAnim.GetLightKind() == GetLightKind()));
    }
}

} // namespace gfx
} // namespace nw