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

#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 ).MaxModels(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(512)
        .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));
}


//----------------------------------------
// ログを出力します。
void 
SmSceneCtrl::OutputLog()
{
    // m_SceneContextが保持するノードの状況を出力します。
    {
        u32 cnt = 0;
        {
            nw::gfx::SceneContext::SceneNodeArray::iterator end = m_SceneContext->GetSceneNodesEnd();
            for (nw::gfx::SceneContext::SceneNodeArray::iterator i = m_SceneContext->GetSceneNodesBegin(); i != end;)
            {
                i++;
                cnt++;
            }
            NW_DEV_LOG( "SceneContex:SceneNode Num %d\n", cnt );
            cnt = 0;
        }

        {
            nw::gfx::SceneContext::ModelArray::iterator end = m_SceneContext->GetModelsEnd();
            for (nw::gfx::SceneContext::ModelArray::iterator i = m_SceneContext->GetModelsBegin(); i != end;)
            {
                i++;
                cnt++;
            }
            NW_DEV_LOG( "SceneContex:ModelArray Num %d\n", cnt );
            cnt = 0;
        }

        {
            nw::gfx::SceneContext::ParticleModelArray::iterator end = m_SceneContext->GetParticleModelEnd();
            for (nw::gfx::SceneContext::ParticleModelArray::iterator i = m_SceneContext->GetParticleModelBegin(); i != end;)
            {
                i++;
                cnt++;
            }
            NW_DEV_LOG( "SceneContex:Particle Model Array Num %d\n", cnt );
            cnt = 0;
        }

        {
            nw::gfx::SceneContext::ParticleSetArray::iterator end = m_SceneContext->GetParticleSetEnd();
            for (nw::gfx::SceneContext::ParticleSetArray::iterator i = m_SceneContext->GetParticleSetBegin(); i != end;)
            {
                i++;
                cnt++;
            }
            NW_DEV_LOG( "SceneContex:Particle Set Array Num %d\n", cnt );
            cnt = 0;
        }
    }

}


#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