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

#include <nw/ut.h>
#include <nw/gfx.h>
#include <nw/demo.h>

#include <nw/demo/demo_Particle.h>

namespace nw
{
namespace demo
{

NW_UT_RUNTIME_TYPEINFO_DEFINITION(ParticleHandle, gfx::TransformNode);

//----------------------------------------
ParticleHandle::ParticleHandle(
    os::IAllocator* allocator,
    gfx::ResTransformNode resObj,
    const gfx::TransformNode::Description& description)
: gfx::TransformNode(allocator, resObj, description),
  m_ModelInstances(allocator),
  m_EmitterInstances(allocator)
{

}

//----------------------------------------
ParticleHandle*
ParticleHandle::DynamicBuilder::Create(
    os::IAllocator* allocator
)
{
    NW_NULL_ASSERT(allocator);

    void* memory = allocator->Alloc(sizeof(ParticleHandle));

    if (memory == NULL)
    {
        return NULL;
    }

    ParticleHandle* node = new(memory) ParticleHandle(
        allocator,
        nw::gfx::ResTransformNode(),
        m_Description);

    {
        gfx::Result result = node->Initialize(allocator);
        if (!result.IsSuccess())
        {
            SafeDestroy(node);
            return NULL;
        }
    }

    return node;
}


//--------------------------------------------------------------------------

nw::demo::ResourceSet* ParticleEffect::m_ShaderResource = NULL;
os::IAllocator* ParticleEffect::m_ShaderAllocator = NULL;

ParticleEffect*
ParticleEffect::Create(os::IAllocator* mainAllocator,
                       os::IAllocator* deviceAllocator,
                       bool autoAlocate,
                       gfx::ParticleContext* particleContext)
{
    NW_NULL_ASSERT( mainAllocator );

    void* memory = mainAllocator->Alloc( sizeof(ParticleEffect) );
    NW_ASSERT( memory != NULL );
    ParticleEffect* particleEffect = new(memory) ParticleEffect(mainAllocator,
                                                                deviceAllocator,
                                                                autoAlocate,
                                                                particleContext);

    return particleEffect;
}


//--------------------------------------------------------------------------
void
ParticleEffect::Destroy()
{
    os::IAllocator* allocator = this->m_MainAllocator;

    NW_ASSERT( allocator != NULL );

    this->~ParticleEffect();
    allocator->Free(this);
}


//----------------------------------------
void 
ParticleEffect::Setup(gfx::ResGraphicsFile resource, bool useParticleMaterial)
{
    // テクスチャはVRAMに配置します。
    resource.ForeachTexture(nw::gfx::TextureLocationFlagSetter(NN_GX_MEM_VRAMA | GL_NO_COPY_FCRAM_DMP));

    // パーティクルマテリアルを使用する場合は、フラグを使用フラグを立てます。
    if (useParticleMaterial)
    {
        resource.ForeachModelMaterial(nw::gfx::ParticleMaterialFlagSetter());
    }

    // パーティクルシェーダバイナリがリソースに含まれない場合は、
    // 外部から読みこんだシェーダをアタッチします。

    nw::gfx::Result result = resource.Setup(m_DeviceAllocator);

    if (result.IsFailure())
    {
        if (m_ShaderResource && (result.GetDescription() & nw::gfx::RESOURCE_RESULT_NOT_FOUND_SHADER))
        {
            // シェーダーが見つからなかったときは、外部ファイルを指定して再びセットアップします。
            result = resource.Setup(m_DeviceAllocator, m_ShaderResource->resource);
        }

        if (result.IsFailure())
        {
            NW_FATAL_ERROR("Fail to set up model. A result code is 0x%x", result.GetCode());
        }
    }
}

//----------------------------------------
void
ParticleEffect::Register(gfx::ResGraphicsFile resource, const char** nodeNames)
{
    nw::gfx::ResModelArray models = resource.GetModels();
    nw::gfx::ResModelArray::iterator modelsEnd = models.end();
    for (nw::gfx::ResModelArray::iterator modelResource = models.begin();
        modelResource != modelsEnd; ++modelResource)
    {
        const char *resourceName = (*modelResource).GetName();

        const char** name = nodeNames;
        bool find = false;
        while (!find && *name != NULL)
        {
            if (strcmp(resourceName, *name) == 0)
            {
                find = true;
            }

            ++name;
        }

        if (find)
        {
            m_ResModels.PushBack(nw::gfx::ResDynamicCast<nw::gfx::ResParticleModel>(*modelResource));
        }
    }

    nw::gfx::ResEmitterArray emitters = resource.GetEmitters();
    for (nw::gfx::ResEmitterArray::iterator emitterResource = emitters.begin();
        emitterResource != emitters.end(); ++emitterResource)
    {
        const char *resourceName = (*emitterResource).GetName();

        const char** name = nodeNames;
        bool find = false;
        while (!find && *name != NULL)
        {
            if (strcmp(resourceName, *name) == 0)
            {
                find = true;
            }

            ++name;
        }

        if (find)
        {
            m_ResEmitters.PushBack(*emitterResource);
        }
    }
}


//----------------------------------------
void
ParticleEffect::Register(gfx::ResGraphicsFile resource)
{
    nw::gfx::ResModelArray models = resource.GetModels();
    nw::gfx::ResModelArray::iterator modelsEnd = models.end();
    for (nw::gfx::ResModelArray::iterator modelResource = models.begin();
        modelResource != modelsEnd; ++modelResource)
    {
        nw::ut::ResTypeInfo resTypeInfo = (*modelResource).GetTypeInfo();
        if ( resTypeInfo == nw::gfx::ResParticleModel::TYPE_INFO)
        {
            m_ResModels.PushBack(nw::gfx::ResDynamicCast<nw::gfx::ResParticleModel>(*modelResource));
        }
    }

    nw::gfx::ResEmitterArray emitters = resource.GetEmitters();
    for (nw::gfx::ResEmitterArray::iterator emitterResource = emitters.begin();
        emitterResource != emitters.end(); ++emitterResource)
    {
        m_ResEmitters.PushBack(*emitterResource);
    }
}


ParticleHandle*
ParticleEffect::Allocate()
{
    // ParticleHandleを生成します。
    ParticleHandle* top = ParticleHandle::DynamicBuilder()
        .MaxCallbacks(0)
        .MaxChildren(this->m_ResModels.Size() + this->m_ResEmitters.Size())
        .Create(this->m_MainAllocator);

    top->SetID(this->m_NextId++);

    nw::ut::MoveArray<nw::gfx::SceneNode*> sceneNodeArray(this->m_MainAllocator);

    // モデル生成
    NW_FOREACH(const nw::gfx::ResParticleModel resModel, this->m_ResModels)
    {
        nw::gfx::SceneObject* sceneObject = nw::gfx::SceneBuilder()
            .Resource(resModel)
            .CreateObject(this->m_MainAllocator, this->m_DeviceAllocator);

        nw::gfx::SceneNode* node = nw::ut::DynamicCast<nw::gfx::SceneNode*>(sceneObject);
        sceneNodeArray.PushBack(node);

        nw::gfx::ParticleModel* model = nw::ut::DynamicCast<nw::gfx::ParticleModel*>(node);
        top->RegisterParticleModel(model);
    }

    // エミッタ生成
    NW_FOREACH(const nw::gfx::ResParticleEmitter resEmitter, this->m_ResEmitters)
    {
        nw::gfx::SceneObject* sceneObject = nw::gfx::SceneBuilder()
            .Resource(resEmitter)
            .CreateObject(this->m_MainAllocator, this->m_DeviceAllocator);

        nw::gfx::SceneNode* node = nw::ut::DynamicCast<nw::gfx::SceneNode*>(sceneObject);
        sceneNodeArray.PushBack(node);

        nw::gfx::ParticleEmitter* emitter = nw::ut::DynamicCast<nw::gfx::ParticleEmitter*>(node);
        top->RegisterParticleEmitter(emitter);
    }

    // 階層再構築
    nw::gfx::SceneHelper::ResolveReference(sceneNodeArray);

    // パーティクルの参照解決・初期化
    nw::gfx::ParticleUtil::SetupParticleObject(&sceneNodeArray, this->m_ParticleContext);

    // トップノードにアタッチ
    NW_FOREACH(nw::gfx::SceneNode* node, sceneNodeArray)
    {
        if (node->GetParent() == NULL)
        {
            top->AttachChild(node);
        }
    }

    return top;
}

void
ParticleEffect::DestroyParticleHandle(ParticleNode* node)
{
    NW_NULL_ASSERT(node);

    nw::gfx::SafeDestroyBranch(node);
}


//! @brief  ParticleHandleを生成します。
//! @return 生成されたParticleHandleインスタンスを返します。
ParticleHandle* 
ParticleEffect::CreateMultiEmitterParticleHandle(u32 particleEmitterNum)
{
    NW_ASSERT( particleEmitterNum != 0 );

    // ParticleHandleを生成します。
    ParticleHandle* top = ParticleHandle::DynamicBuilder()
        .MaxCallbacks(0)
        .MaxChildren(this->m_ResModels.Size()  + particleEmitterNum)
        .Create(this->m_MainAllocator);

    top->SetID(this->m_NextId++);

    nw::ut::MoveArray<nw::gfx::SceneNode*> sceneNodeArray(this->m_MainAllocator);

    // モデルを生成します。
    NW_FOREACH(const nw::gfx::ResParticleModel resModel, this->m_ResModels)
    {
        nw::gfx::SceneObject* sceneObject = nw::gfx::SceneBuilder()
            .Resource(this->m_ResModels[0])
            .CreateObject(this->m_MainAllocator, this->m_DeviceAllocator);

        nw::gfx::SceneNode* node = nw::ut::DynamicCast<nw::gfx::SceneNode*>(sceneObject);
        sceneNodeArray.PushBack(node);

        nw::gfx::ParticleModel* model = nw::ut::DynamicCast<nw::gfx::ParticleModel*>(node);
        top->RegisterParticleModel(model);
    }

    // エミッタを指定個数だけ生成します。
    for (u32 i = 0; i < particleEmitterNum; ++i)
    {
        // エミッタ生成
        NW_FOREACH(const nw::gfx::ResParticleEmitter resEmitter, this->m_ResEmitters)
        {
            nw::gfx::SceneObject* sceneObject = nw::gfx::SceneBuilder()
                .Resource(this->m_ResEmitters[0])
                .CreateObject(this->m_MainAllocator, this->m_DeviceAllocator);

            nw::gfx::SceneNode* node = nw::ut::DynamicCast<nw::gfx::SceneNode*>(sceneObject);
            sceneNodeArray.PushBack(node);

            nw::gfx::ParticleEmitter* emitter = nw::ut::DynamicCast<nw::gfx::ParticleEmitter*>(node);
            top->RegisterParticleEmitter(emitter);
        }
    }

    // 階層再構築
    nw::gfx::SceneHelper::ResolveReference(sceneNodeArray);

    // パーティクルの参照解決・初期化
    nw::gfx::ParticleUtil::SetupParticleObject(&sceneNodeArray, this->m_ParticleContext);

    // トップノードにアタッチ
    NW_FOREACH(nw::gfx::SceneNode* node, sceneNodeArray)
    {
        if (node->GetParent() == NULL)
        {
            top->AttachChild(node);
        }
    }

    return top;
}


//! @brief 外部シェーダファイルをロードします。
void 
ParticleEffect::InitializeShaderBinary(const wchar_t* shaderFilePath, os::IAllocator* deviceAllocator)
{
    NW_NULL_ASSERT(shaderFilePath);
    NW_NULL_ASSERT(deviceAllocator);

    if (m_ShaderResource) return;

    m_ShaderAllocator = deviceAllocator;

    // ファイルからシェーダリソースを読み込みます。
    m_ShaderResource = deviceAllocator->AllocAndConstruct<nw::demo::ResourceSet>(1);
    m_ShaderResource->buffer = nw::demo::Utility::LoadFile(m_ShaderAllocator, shaderFilePath);

    NW_NULL_ASSERT(m_ShaderResource->buffer);

    m_ShaderResource->resource = nw::gfx::ResGraphicsFile(&(m_ShaderResource->buffer.front()));
}

//! @brief ロードした外部シェーダファイルを破棄します。
void ParticleEffect::FinalizeShaderBinary()
{
    nw::ut::SafeCleanup(m_ShaderResource->resource);
    m_ShaderAllocator->DestructAndFree(m_ShaderResource, 1);

    m_ShaderResource = NULL;
    m_ShaderAllocator = NULL;
}

} // namespace demo
} // namespace nw