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

#include "../include/SmSceneCtrl.h"


//----------------------------------------
//
struct RenderSceneInternalFunctor
    : public std::unary_function<nw::gfx::RenderElement&, void>
{
    nw::gfx::RenderContext* m_RenderContext;
    nw::gfx::MeshRenderer* m_MeshRenderer;
    
    RenderSceneInternalFunctor(nw::gfx::RenderContext* renderContext, nw::gfx::MeshRenderer* meshRenderer)
    : m_RenderContext(renderContext), m_MeshRenderer(meshRenderer)
    {
        NW_NULL_ASSERT(renderContext);
        NW_NULL_ASSERT(meshRenderer);
    }
    
    void operator()(nw::gfx::RenderElement& element)
    {
        if (element.IsCommand())
        {
            nw::gfx::RenderCommand* command = element.GetCommand();
            NW_NULL_ASSERT(command);
            command->Invoke(m_RenderContext);
        }
        else
        {
            nw::gfx::ResMesh mesh = element.GetMesh();
            nw::gfx::Model* model = element.GetModel();
            model->PreRenderSignal()(model, mesh, m_RenderContext);
            m_MeshRenderer->RenderMesh(mesh, model);
            model->PostRenderSignal()(model, mesh, m_RenderContext);
        }
        NW_GL_ASSERT();
    }
};


//----------------------------------------
// コンストラクタ
SmSceneCtrl::SmSceneCtrl( nw::gfx::RenderContext* renderContext )
: m_SceneContext( NULL ),
  m_SceneTraverser( NULL ),
  m_SceneUpdater( NULL ),
  m_SceneInitializer( NULL ),
  m_RenderContext( renderContext ),
  m_PriorMaterialRenderKeyFactory( NULL ),
  m_PriorDepthRenderKeyFactory( NULL ),
  m_RenderQueue( NULL ),
  m_MeshRenderer( NULL )
{
    m_SceneContext = nw::gfx::SceneContext::Builder()
        .MaxSceneNodes( 128 ).Create( m_Allocator );
    
    m_SceneTraverser = nw::gfx::SceneTraverser::Builder()
        .Create( m_Allocator );

    nw::gfx::WorldMatrixUpdater* worldMatrixUpdater = nw::gfx::WorldMatrixUpdater::Builder()
        .Create( m_Allocator );

    nw::gfx::SkeletonUpdater* skeletonUpdater = nw::gfx::SkeletonUpdater::Builder()
        .Create( m_Allocator );
    
    m_SceneUpdater = nw::gfx::SceneUpdater::Builder()
        .WorldMatrixUpdaterPtr(worldMatrixUpdater)
        .SkeletonUpdaterPtr(skeletonUpdater)
        .Create( m_Allocator );

    nw::gfx::IMaterialIdGenerator* materialIdGenerator =
        nw::gfx::SortingMaterialIdGenerator::Builder()
        .IsFixedSizeMemory(true)
        .MaxMaterials(128)
        .Create(m_Allocator);

    m_SceneInitializer = nw::gfx::SceneInitializer::Builder()
        .MaterialIdGenerator(materialIdGenerator)
        .Create( m_Allocator );

    m_PriorMaterialRenderKeyFactory =
        nw::gfx::CreatePriorMaterialRenderKeyFactory( m_Allocator );

    m_PriorDepthRenderKeyFactory =
        nw::gfx::CreatePriorDepthReverseDepthRenderKeyFactory( m_Allocator );

    m_RenderQueue = nw::gfx::RenderQueue::Builder()
        .MaxRenderElements(256)
        .Create( m_Allocator );

    m_RenderQueue->Reset(
        m_PriorMaterialRenderKeyFactory,
        m_PriorDepthRenderKeyFactory,
        m_PriorMaterialRenderKeyFactory,
        m_PriorMaterialRenderKeyFactory);

    m_MeshRenderer = nw::gfx::MeshRenderer::Create( m_Allocator );
    m_MeshRenderer->SetRenderContext( m_RenderContext );
}


//----------------------------------------
// デストラクタ
SmSceneCtrl::~SmSceneCtrl()
{
    nw::gfx::SafeDestroy(m_SceneInitializer);
    nw::gfx::SafeDestroy(m_SceneTraverser);
    nw::gfx::SafeDestroy(m_SceneUpdater);
    nw::gfx::SafeDestroy(m_SceneContext);


    nw::gfx::SafeDestroy(m_MeshRenderer);
    nw::gfx::SafeDestroy(m_RenderQueue);
    nw::gfx::SafeDestroy(m_PriorMaterialRenderKeyFactory);
    nw::gfx::SafeDestroy(m_PriorDepthRenderKeyFactory);
}


//----------------------------------------
// シーンを更新する
void
SmSceneCtrl::UpdateScene()
{
    m_SceneUpdater->UpdateAll(m_SceneContext);
}


//----------------------------------------
// シーンを初期化する
void
SmSceneCtrl::InitializeScene(nw::gfx::SceneNode* sceneRoot)
{
    m_SceneTraverser->Begin(m_SceneContext);
    sceneRoot->Accept(m_SceneInitializer);
    m_SceneTraverser->End();

    TraverseScene(sceneRoot);
}


//----------------------------------------
void
SmSceneCtrl::TraverseScene(nw::gfx::SceneNode* sceneRoot)
{
    this->m_SceneTraverser->Begin(this->m_SceneContext);
    sceneRoot->Accept(this->m_SceneTraverser);
    this->m_SceneTraverser->End();

    // パーティクルセットの依存順でソートする
    std::sort(
        this->m_SceneContext->GetParticleSetBegin(),
        this->m_SceneContext->GetParticleSetEnd(),
        nw::gfx::ParticleSetCompare());
}

//----------------------------------------
void 
SmSceneCtrl::SetSceneEnvironmentSetting( nw::gfx::SceneEnvironmentSetting* sceneEnvironmentSetting )
{
    nw::gfx::SceneEnvironment& sceneEnvironment = m_RenderContext->GetSceneEnvironment();
    sceneEnvironmentSetting->ResolveReference(*m_SceneContext);
    sceneEnvironment.ApplyFrom(*sceneEnvironmentSetting);
}



//----------------------------------------
// カメラの視界に基づいてシーンを更新し、描画キューを構築します。
void
SmSceneCtrl::SubmitView( nw::gfx::Camera* currentCamera )
{
    nw::gfx::SceneEnvironment& sceneEnvironment = m_RenderContext->GetSceneEnvironment();     
//    nw::gfx::Camera* camera = sceneEnvironment.GetActiveCamera();

    // Fog を更新します。
    nw::gfx::FogArray::iterator fogEnd = m_SceneContext->GetFogEnd();
    for (nw::gfx::FogArray::iterator fog = m_SceneContext->GetFogBegin();
        fog != fogEnd;
        ++fog)
    {
        if (*fog != NULL)
        {
            (*fog)->Update( currentCamera );
        }
    }

    m_RenderQueue->Reset();
    m_SceneUpdater->SubmitView( m_RenderQueue, m_SceneContext, *currentCamera, 0 );

    // ソートする
    std::sort( m_RenderQueue->Begin(), m_RenderQueue->End(), nw::gfx::RenderElementCompare());
}

//----------------------------------------
// 描画を行います。
void 
SmSceneCtrl::Render()
{
//    m_RenderContext->SetCameraMatrix(camera);
    
    std::for_each(
        m_RenderQueue->Begin(),
        m_RenderQueue->End(),
        RenderSceneInternalFunctor(m_RenderContext, m_MeshRenderer));
}

#if 0
//----------------------------------------
// 描画環境をセットする
void
SmSceneCtrl::SetEnvironment( s32 cameraIndex )
{
    NW_UNUSED_VARIABLE(cameraIndex);

    nw::gfx::SceneEnvironment& sceneEnvironment = m_RenderContext->GetSceneEnvironment();

//    sceneEnvironment.SetActiveCamera(cameraIndex);
    m_RenderContext->SetActiveCamera(cameraIndex);

    if (m_SceneContext->GetAmbientLightsBegin() != m_SceneContext->GetAmbientLightsEnd())
    {
        sceneEnvironment.SetAmbientLight(*m_SceneContext->GetAmbientLightsBegin());
    }

    if (m_SceneContext->GetHemiSphereLightsBegin() != m_SceneContext->GetHemiSphereLightsEnd())
    {
        sceneEnvironment.SetHemiSphereLight(*m_SceneContext->GetHemiSphereLightsBegin());
    }

    std::for_each(
        m_SceneContext->GetFragmentLightsBegin(),
        m_SceneContext->GetFragmentLightsEnd(),
        std::bind1st(std::mem_fun(&nw::gfx::SceneEnvironment::SetFragmentLight), &sceneEnvironment));

    std::for_each(
        m_SceneContext->GetVertexLightsBegin(),
        m_SceneContext->GetVertexLightsEnd(),
        std::bind1st(std::mem_fun(&nw::gfx::SceneEnvironment::SetVertexLight), &sceneEnvironment));

    if (m_SceneContext->GetFogBegin() != m_SceneContext->GetFogEnd())
    {
        sceneEnvironment.SetFog(0, *m_SceneContext->GetFogBegin());
    }
}
#endif