LowLayerAnimationDemo/sources/LowLayerAnimationDemo.cpp

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

#define NW_DEBUG_CHECK_MEMORY_LEAK

#include <nn/os.h>
#include <nn/fs.h>
#include <nn/gx.h>

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

namespace
{

//----------------------------------------
// メモリ関係
// デモではデバイスメモリから全てのメモリを確保するようになっています。

// デモで使用するメモリサイズです。
const size_t DEMO_MEMORY_SIZE = 0x1000000;

// デバイスメモリを確保するためのアロケータです。
nw::demo::DemoAllocator s_DeviceAllocator;

nw::demo::GraphicsMemoryAllocator s_GraphicsMemoryAllocator;

const int MAX_FILE = 256;
const int MAX_DIRECTORY = 16;

//----------------------------------------
// ファイル名の定義です。
static const wchar_t* MODEL_RESOURCE_FILES[] =
{
    NW_DEMO_FILE_PATH(L"Male.bcmdl"),
    NW_DEMO_FILE_PATH(L"Walk.bcskla"),
    NW_DEMO_FILE_PATH(L"FragmentLight.bcenv"),
};

//----------------------------------------
// 描画関係
nw::gfx::IRenderTarget* s_RenderTarget = NULL;

nw::gfx::RenderContext* s_RenderContext = NULL;
nw::gfx::MeshRenderer* s_MeshRenderer = NULL;
nw::demo::DisplayBufferSwapper* s_UpperSwapper = NULL;
nw::demo::DisplayBufferSwapper* s_ExtensionSwapper = NULL;

const size_t COMMAND_BUFFER_SIZE = 0x100000;
const size_t REQUEST_COUNT = 512;
nw::demo::CommandListSwapper* s_CommandListSwapper = NULL;

//----------------------------------------
// リソース関係
const int RESOURCES_COUNT = 3;
struct ResourceSet
{
    nw::ut::MoveArray<u8> buffer;
    nw::gfx::ResGraphicsFile resource;
};
typedef nw::ut::FixedSizeArray<ResourceSet, RESOURCES_COUNT> ResourceArray;

ResourceArray s_Resources;

//----------------------------------------
// シーン関係
s32 s_FrameCount = 0;
nw::gfx::WorldMatrixUpdater* s_WorldMatrixUpdater = NULL;
nw::gfx::SkeletonUpdater* s_SkeletonUpdater = NULL;
nw::gfx::BillboardUpdater* s_BillboardUpdater = NULL;

const s32 s_BaseCameraIndex = 0;
nw::gfx::Camera* s_BaseCamera = NULL;
nw::gfx::Camera* s_LeftCamera = NULL;
nw::gfx::Camera* s_RightCamera = NULL;
const f32 s_NearPlane = 0.1f;

nw::demo::CameraController* s_CameraController = NULL;

nn::ulcd::CTR::StereoCamera* s_StereoCamera;

const int MODEL_COUNT = 1;
const int LIGHT_COUNT = 1;

typedef nw::ut::FixedSizeArray<nw::gfx::SkeletalModel*, MODEL_COUNT> SkeletalModelArray;
typedef nw::ut::FixedSizeArray<nw::gfx::FragmentLight*, LIGHT_COUNT> FragmentLightArray;

SkeletalModelArray s_SkeletalModels;
FragmentLightArray s_FragmentLights;

//----------------------------------------
// アニメーション関係
nw::gfx::AnimObject* s_AnimObject;

const int ANIMATION_RESOURCES_COUNT = 3;
nw::ut::FixedSizeArray<nw::gfx::ResGraphicsFile, ANIMATION_RESOURCES_COUNT> s_ResAnims;

void UpdateNode(nw::gfx::TransformNode* node);

/*!--------------------------------------------------------------------------*
  @brief        グラフィックスメモリのアロケータです。

                関数ポインタが nngxInitialize の引数として使用されます。
 *---------------------------------------------------------------------------*/
void* AllocateGraphicsMemory(GLenum area, GLenum aim, GLuint id, GLsizei size)
{
    void* buffer = s_GraphicsMemoryAllocator.Allocate(area, aim, id, size);
    return buffer;
}

/*!--------------------------------------------------------------------------*
  @brief        グラフィックスメモリのデアロケータです。

                関数ポインタが nngxInitialize の引数として使用されます。
*---------------------------------------------------------------------------*/
void DeallocateGraphicsMemory(GLenum area, GLenum aim, GLuint id, void* addr)
{
    s_GraphicsMemoryAllocator.Deallocate(area, aim, id, addr);
}

/*!--------------------------------------------------------------------------*
  @brief        グラフィックスシステムに必要なメモリなどの初期化を行います。
*---------------------------------------------------------------------------*/
void
InitializeGraphicsSystem()
{
    nn::os::Initialize();
    nn::fs::Initialize();

    nw::demo::InitializeDemoMemory();

    nw::demo::InitializeDemoAllocator(&s_DeviceAllocator, DEMO_MEMORY_SIZE, nn::os::ALLOCATE_OPTION_LINEAR);

    // デバイスメモリを用いるグラフィックスメモリアロケータを初期化します。
    s_GraphicsMemoryAllocator.Initialize(&s_DeviceAllocator);

    s32 workingMemorySize = nn::fs::GetRomRequiredMemorySize(MAX_FILE, MAX_DIRECTORY);
    NW_ASSERT(workingMemorySize != 0);
    void* workingMemory = nw::demo::Alloc(workingMemorySize);
    nn::Result result = nn::fs::MountRom(MAX_FILE, MAX_DIRECTORY, workingMemory, workingMemorySize);

    NW_ASSERT(result.IsSuccess());
}

/*!--------------------------------------------------------------------------*
  @brief        グラフィックスシステムに必要なメモリなどの終了処理を行います。
*---------------------------------------------------------------------------*/
void
FinalizeGraphicsSystem()
{
    s_GraphicsMemoryAllocator.Finalize();

    nw::demo::FinalizeDemoAllocator(&s_DeviceAllocator);
}

/*!--------------------------------------------------------------------------*
  @brief        グラフィックス関連の初期化を行います。
*---------------------------------------------------------------------------*/
void
InitializeGraphics()
{
    if (nngxInitialize(AllocateGraphicsMemory, DeallocateGraphicsMemory) == GL_FALSE)
    {
        NW_FATAL_ERROR("nngxInitialize failed.\n");
    }

    //-----------------------------
    nw::demo::DisplayBufferSwapper::Description upperScreenDescription;
    upperScreenDescription.screenKind = nw::demo::UPPER_SCREEN;
    upperScreenDescription.width  = 400;
    upperScreenDescription.height = 240;
    upperScreenDescription.bufferCount = 2;

    nw::demo::DisplayBufferSwapper::Description extensionScreenDescription;
    extensionScreenDescription.screenKind = nw::demo::EXTENSION_SCREEN;
    extensionScreenDescription.width  = upperScreenDescription.width;
    extensionScreenDescription.height = upperScreenDescription.height;
    extensionScreenDescription.bufferCount = upperScreenDescription.bufferCount;

    s_UpperSwapper = nw::demo::DisplayBufferSwapper::Builder()
        .BufferDescription(upperScreenDescription)
        .Create(&s_DeviceAllocator);

    s_ExtensionSwapper = nw::demo::DisplayBufferSwapper::Builder()
        .BufferDescription(extensionScreenDescription)
        .Create(&s_DeviceAllocator);

    //-----------------------------
    nw::demo::CommandListSwapper::Description commandListSwapperDescription;
    commandListSwapperDescription.commandListCount = 1;
    commandListSwapperDescription.bufferSize = COMMAND_BUFFER_SIZE;
    commandListSwapperDescription.requestCount = REQUEST_COUNT;
    commandListSwapperDescription.reusableBufferSize = COMMAND_BUFFER_SIZE;
    commandListSwapperDescription.reusableRequestCount = REQUEST_COUNT;
    commandListSwapperDescription.maxGpuProfilingEntryCount = 0;
    s_CommandListSwapper =
        nw::demo::CommandListSwapper::Create(&s_DeviceAllocator, commandListSwapperDescription);
    s_CommandListSwapper->Bind();

    //-----------------------------
    nngxSetDisplayMode(nw::demo::UPPER_SCREEN_MODE_STEREO);

    //-----------------------------
    nw::gfx::CommandCacheManager::SetAllocator( &s_DeviceAllocator );

    //-----------------------------
    s_RenderContext = nw::gfx::RenderContext::Builder()
        .Create(&s_DeviceAllocator);

    //-----------------------------
    void* cameraMemory = s_DeviceAllocator.Alloc(sizeof(nn::ulcd::CTR::StereoCamera));
    s_StereoCamera = new(cameraMemory) nn::ulcd::CTR::StereoCamera();
    s_StereoCamera->Initialize();

    //-----------------------------
    s_MeshRenderer = nw::gfx::MeshRenderer::Create(&s_DeviceAllocator);
    s_MeshRenderer->SetRenderContext(s_RenderContext);

    //-----------------------------
    nw::gfx::RenderColorFormat renderColorFormat = nw::gfx::RENDER_COLOR_FORMAT_RGBA8;
    s_RenderTarget =
        nw::gfx::IRenderTarget::Builder()
        .BufferSize(upperScreenDescription.height, upperScreenDescription.width)
        .ColorFormat(renderColorFormat)
        .Create(&s_DeviceAllocator);
    NW_NULL_ASSERT(s_RenderTarget);

    //-----------------------------
    s_WorldMatrixUpdater = nw::gfx::WorldMatrixUpdater::Builder()
        .Create(&s_DeviceAllocator);

    //-----------------------------
    // スケルトンアップデータを生成します。
    s_SkeletonUpdater = nw::gfx::SkeletonUpdater::Builder()
        .Create(&s_DeviceAllocator);

    // スケルタルモデルの更新に必要なビルボードアップデータを生成します。
    s_BillboardUpdater = nw::gfx::BillboardUpdater::Create(&s_DeviceAllocator);

    //-----------------------------
    nngxStartLcdDisplay();

    NW_GL_ASSERT();
}
/*!--------------------------------------------------------------------------*
  @brief        グラフィックス関連の後始末をします。
*---------------------------------------------------------------------------*/
void
TerminateGraphics()
{
    s_StereoCamera->Finalize();
    s_DeviceAllocator.Free(s_StereoCamera);

    nw::gfx::SafeDestroy(s_SkeletonUpdater);
    nw::gfx::SafeDestroy(s_WorldMatrixUpdater);

    nw::gfx::SafeDestroy(s_RenderTarget);

    nw::gfx::SafeDestroy(s_MeshRenderer);
    nw::gfx::SafeDestroy(s_CommandListSwapper);
    nw::gfx::SafeDestroy(s_UpperSwapper);
    nw::gfx::SafeDestroy(s_ExtensionSwapper);
    nw::gfx::SafeDestroy(s_RenderContext);

    nw::gfx::SafeDestroy(s_BillboardUpdater);

    nngxFinalize();
    s_GraphicsMemoryAllocator.Finalize();

    NW_GL_ASSERT();
}

/*!--------------------------------------------------------------------------*
  @brief        グラフィックスリソースをロードします。

  @param[in]    resourcePath ファイルのパス名

  @return       ロードしたグラフィックス情報を返します。
 *---------------------------------------------------------------------------*/
ResourceSet*
LoadResources(const wchar_t* resourcePath)
{
    ResourceSet resourceSet;
    // 現在、デバイスメモリ上に読み込む方式にのみ対応しています。
    // テクスチャをロードするには128byteアライメントを行う必要があります。
    static const int resourceAlignment = 128;
    resourceSet.buffer = nw::demo::Utility::LoadFile(&s_DeviceAllocator , resourcePath, resourceAlignment);

    if (!resourceSet.buffer)
    {
        return NULL;
    }

    resourceSet.resource = nw::gfx::ResGraphicsFile(&(resourceSet.buffer.front()));

    bool isPushed = s_Resources.push_back(resourceSet);

    NW_ASSERT(isPushed);

    return &(s_Resources.back());
}

/*!--------------------------------------------------------------------------*
  @brief        シーンノードを生成します。

  @param[in]    resource シーンノードのリソースです。

  @return       生成したシーンノードです。。
 *---------------------------------------------------------------------------*/
nw::gfx::SceneNode*
CreateSceneNode(nw::gfx::ResSceneObject resource)
{
    nw::gfx::SceneObject* sceneObject = nw::gfx::SceneBuilder()
        .Resource(resource)
        .MaxChildren(0)
        .CreateObject(&s_DeviceAllocator, &s_DeviceAllocator);

    return nw::ut::DynamicCast<nw::gfx::SceneNode*>(sceneObject);
}

/*!--------------------------------------------------------------------------*
  @brief        リソース関連の構築をします。
*---------------------------------------------------------------------------*/
void
BuildResources(ResourceSet* resourceSet)
{
    resourceSet->resource.ForeachTexture(nw::gfx::LocationFlagSetter(NN_GX_MEM_VRAMA | GL_NO_COPY_FCRAM_DMP));
    resourceSet->resource.ForeachIndexStream(nw::gfx::LocationFlagSetter(NN_GX_MEM_VRAMB | GL_NO_COPY_FCRAM_DMP));
    resourceSet->resource.ForeachVertexStream(nw::gfx::LocationFlagSetter(NN_GX_MEM_VRAMB | GL_NO_COPY_FCRAM_DMP));

    nw::gfx::Result result = resourceSet->resource.Setup(&s_DeviceAllocator);
    if (result.IsFailure())
    {
        NW_FATAL_ERROR("Fail to set up model. A result code is 0x%x", result.GetCode());
    }

    nw::gfx::ResModelArray models = resourceSet->resource.GetModels();
    nw::gfx::ResModelArray::iterator modelsEnd = models.end();
    for (nw::gfx::ResModelArray::iterator modelResource = models.begin();
        modelResource != modelsEnd; ++modelResource)
    {
        nw::gfx::SceneNode* node = CreateSceneNode(*modelResource);
        NW_NULL_ASSERT(node);
        NW_ASSERT(nw::ut::IsTypeOf<nw::gfx::SkeletalModel>(node));

        s_SkeletalModels.push_back(static_cast<nw::gfx::SkeletalModel*>(node));
    }

    nw::gfx::ResLightArray lights = resourceSet->resource.GetLights();
    for (nw::gfx::ResLightArray::iterator lightResource = lights.begin();
        lightResource != lights.end(); ++lightResource)
    {
        nw::gfx::SceneNode* node = CreateSceneNode(*lightResource);
        NW_NULL_ASSERT(node);
        NW_ASSERT(nw::ut::IsTypeOf<nw::gfx::FragmentLight>(node));

        s_FragmentLights.push_back(static_cast<nw::gfx::FragmentLight*>(node));
    }
}

/*!--------------------------------------------------------------------------*
  @brief        カメラの構築をします。
*---------------------------------------------------------------------------*/
void
BuildCameras()
{
    nw::gfx::LookAtTargetViewUpdater* viewUpdater
        = nw::gfx::LookAtTargetViewUpdater::Create(&s_DeviceAllocator);

    nw::gfx::ResLookAtTargetViewUpdater resViewUpdater =
        nw::gfx::ResStaticCast<nw::gfx::ResLookAtTargetViewUpdater>(
            viewUpdater->GetResource());
    resViewUpdater.SetTargetPosition(0.0f,10.0f,0.0f);
    resViewUpdater.SetUpwardVector(0.0f,1.0f,0.0f);

    nw::gfx::PerspectiveProjectionUpdater* projectionUpdater
        = nw::gfx::PerspectiveProjectionUpdater::Create(&s_DeviceAllocator);

    nw::gfx::ResPerspectiveProjectionUpdater resProjectionUpdater =
        nw::gfx::ResStaticCast<nw::gfx::ResPerspectiveProjectionUpdater>(
            projectionUpdater->GetResource());
    resProjectionUpdater.SetNear(s_NearPlane);
    resProjectionUpdater.SetFar(1000.0f);
    resProjectionUpdater.SetFovy(NW_MATH_DEG_TO_RAD(37.8f));

    resProjectionUpdater.SetAspectRatio(
        static_cast<f32>(s_RenderTarget->GetDescription().height) /
            static_cast<f32>(s_RenderTarget->GetDescription().width));

    s_BaseCamera =
        nw::gfx::Camera::DynamicBuilder()
        .MaxChildren(0)
        .MaxCallbacks(0)
        .ViewUpdater(viewUpdater)
        .ProjectionUpdater(projectionUpdater)
        .Create(&s_DeviceAllocator);
    NW_POINTER_ASSERT(s_BaseCamera);
    s_BaseCamera->Transform().SetTranslate(nw::math::VEC3(20.0f, 15.0f, 20.0f));

    s_LeftCamera =
        nw::gfx::Camera::DynamicBuilder()
        .MaxChildren(0)
        .MaxCallbacks(0)
        .Create(&s_DeviceAllocator);
    NW_POINTER_ASSERT(s_LeftCamera);

    s_RightCamera =
        nw::gfx::Camera::DynamicBuilder()
        .MaxChildren(0)
        .MaxCallbacks(0)
        .Create(&s_DeviceAllocator);
    NW_POINTER_ASSERT(s_RightCamera);

    s_CameraController =
        nw::demo::CameraController::Builder()
        .MaxCameraCount(1)
        .Create(&s_DeviceAllocator);
    s_CameraController->Register(s_BaseCamera);
}

/*!--------------------------------------------------------------------------*
  @brief        アニメーション関連の構築をします。
 *---------------------------------------------------------------------------*/
void
BuildAnimations()
{
    s_AnimObject = nw::demo::Utility::BindAnimationByName(
        &s_DeviceAllocator,
        s_SkeletalModels,
        s_ResAnims,
        "Male",
        "Walk",
        nw::demo::Utility::SKELETAL_ANIMATION,
        false);
}

/*!--------------------------------------------------------------------------*
  @brief        シーンを初期化します。
*---------------------------------------------------------------------------*/
void
InitializeScenes()
{
    BuildCameras();

    NW_FOREACH(const wchar_t* name, MODEL_RESOURCE_FILES)
    {
        ResourceSet* resourceSet = LoadResources(name);
        BuildResources(resourceSet);
        s_ResAnims.push_back(resourceSet->resource);
    }

    NW_GL_ASSERT();

    BuildAnimations();

    s_FrameCount = 0;
}

/*!--------------------------------------------------------------------------*
  @brief        シーン関連の後始末をします。
*---------------------------------------------------------------------------*/
void
TerminateScenes()
{
    nw::gfx::SafeDestroyAll(s_FragmentLights);
    nw::gfx::SafeDestroyAll(s_SkeletalModels);
    nw::demo::SafeCleanupResources(s_Resources);
    nw::gfx::SafeDestroy(s_BaseCamera);
    nw::gfx::SafeDestroy(s_LeftCamera);
    nw::gfx::SafeDestroy(s_RightCamera);
    nw::gfx::SafeDestroy(s_CameraController);
    nw::gfx::SafeDestroy(s_AnimObject);

    NW_GL_ASSERT();

    s_Resources.clear();
    s_ResAnims.clear();
}

/*!--------------------------------------------------------------------------*
  @brief        ノードを更新します。
 *---------------------------------------------------------------------------*/
void
UpdateNode(nw::gfx::TransformNode* node)
{
    // 一度計算したら計算処理をスキップする。
    // ただし、ツリー構造は正しく解釈されない。
    if (node->Transform().IsEnabledFlags(nw::gfx::CalculatedTransform::FLAG_IS_DIRTY))
    {
        s_WorldMatrixUpdater->UpdateBasic(
            &node->WorldMatrix(),
            &node->WorldTransform(),
            node->Transform(),
            nw::gfx::CalculatedTransform::Identity(),
            nw::gfx::CalculatedTransform::Identity());

        node->Transform().DisableFlags(nw::gfx::CalculatedTransform::FLAG_IS_DIRTY);
    }
}

/*!--------------------------------------------------------------------------*
  @brief        カメラを更新します。
 *---------------------------------------------------------------------------*/
void UpdateCamera()
{
    s_CameraController->Update();
    UpdateNode(s_BaseCamera);
    s_BaseCamera->UpdateCameraMatrix();

    // ステレオカメラの計算
    NW_NULL_ASSERT(s_LeftCamera);
    NW_NULL_ASSERT(s_RightCamera);
    NW_NULL_ASSERT(s_BaseCamera);
    nn::math::MTX44& projOriginal = s_BaseCamera->ProjectionMatrix();
    nn::math::MTX34& viewOriginal = s_BaseCamera->ViewMatrix();
    nn::math::MTX44& projL = s_LeftCamera->ProjectionMatrix();
    nn::math::MTX34& viewL = s_LeftCamera->ViewMatrix();
    nn::math::MTX44& projR = s_RightCamera->ProjectionMatrix();
    nn::math::MTX34& viewR = s_RightCamera->ViewMatrix();

    // Ortho カメラでは別の処理を行う必要があります。
    // 例として demo::RenderSystem::CalcStereoCamera() を参照してください。
    const f32 DEPTH_LEVEL = 5.0f + s_NearPlane;
    const f32 DEPTH_RANGE = 1.0f;
    s_StereoCamera->CalculateMatrices(
        &projL,
        &viewL,
        &projR,
        &viewR,
        &projOriginal,
        &viewOriginal,
        DEPTH_LEVEL,
        DEPTH_RANGE,
        false);
}

/*!--------------------------------------------------------------------------*
  @brief        生成されたノードを更新します。
 *---------------------------------------------------------------------------*/
void UpdateNodes()
{
    // フラグメントライト更新
    FragmentLightArray::iterator lightEnd = s_FragmentLights.end();
    for (FragmentLightArray::iterator light = s_FragmentLights.begin(); light != lightEnd; ++light)
    {
        UpdateNode(*light);
    }


    // スケルタルモデル更新
    SkeletalModelArray::iterator skeletalModelEnd = s_SkeletalModels.end();
    for (SkeletalModelArray::iterator model = s_SkeletalModels.begin(); model != skeletalModelEnd; ++model)
    {
        UpdateNode(*model);

        // フルベイクアニメを使用する場合は処理をスキップします。
        if ((*model)->GetFullBakedAnimEnabled()) { continue; }

        // スケルトンが既に更新済みの場合は処理をスキップします。
        if ((*model)->GetSkeleton()->IsUpdated()) { continue; }

        // スケルトンを更新します。
        s_SkeletonUpdater->UpdateWorld((*model)->GetSkeleton(), *s_WorldMatrixUpdater);

        // スケルトンが更新済みであることを表すフラグを true にします。
        (*model)->GetSkeleton()->SetUpdated(true);
    }
}

/*!--------------------------------------------------------------------------*
  @brief        アニメーションを評価します。
 *---------------------------------------------------------------------------*/
void
EvaluateSkeletalAnim()
{
    SkeletalModelArray::iterator skeletalModelEnd = s_SkeletalModels.end();
    for (SkeletalModelArray::iterator model = s_SkeletalModels.begin(); model != skeletalModelEnd; ++model)
    {
        (*model)->GetAnimBinding()->Evaluate(nw::anim::ResGraphicsAnimGroup::EVALUATION_BEFORE_WORLD_UPDATE);
        (*model)->GetAnimBinding()->Evaluate(nw::anim::ResGraphicsAnimGroup::EVALUATION_AFTER_SCENE_CULLING);
    }
}

/*!--------------------------------------------------------------------------*
  @brief        アニメーションのフレームを更新します。
 *---------------------------------------------------------------------------*/
void
UpdateFrame()
{
    SkeletalModelArray::iterator skeletalModelEnd = s_SkeletalModels.end();
    for (SkeletalModelArray::iterator model = s_SkeletalModels.begin(); model != skeletalModelEnd; ++model)
    {
        (*model)->UpdateFrame();
    }
}

/*!--------------------------------------------------------------------------*
  @brief        シーンを更新します。
 *---------------------------------------------------------------------------*/
void
UpdateScene()
{
    EvaluateSkeletalAnim();

    UpdateNodes();

    UpdateFrame();

    UpdateCamera();

    ++s_FrameCount;
}

/*!--------------------------------------------------------------------------*
  @brief        カメラ、ライト、フォグなどのシーン環境を設定します。
 *---------------------------------------------------------------------------*/
void
SetEnvironment()
{
    nw::gfx::SceneEnvironment& sceneEnvironment = s_RenderContext->GetSceneEnvironment();
    sceneEnvironment.SetCamera(s_BaseCameraIndex, s_BaseCamera);

    //-----------------------------
    FragmentLightArray::iterator lightEnd = s_FragmentLights.end();
    for (FragmentLightArray::iterator light = s_FragmentLights.begin(); light != lightEnd; ++light)
    {
        sceneEnvironment.SetFragmentLight(*light);
    }
}

/*!--------------------------------------------------------------------------*
  @brief        ビューに関連する更新処理を行います。
 *---------------------------------------------------------------------------*/
void
SubmitView()
{
    SkeletalModelArray::iterator skeletalModelEnd = s_SkeletalModels.end();
    for (SkeletalModelArray::iterator model = s_SkeletalModels.begin(); model != skeletalModelEnd; ++model)
    {
        // スケルトンが更新済みであることを表すフラグを false に戻します。
        (*model)->GetSkeleton()->SetUpdated(false);
        if (!(*model)->IsVisible()) { continue; }

        s_SkeletonUpdater->UpdateView(
            (*model)->GetSkeleton(),
            *s_BillboardUpdater,
            *s_BaseCamera);

        nw::gfx::ResSkeleton resSkeleton = (*model)->GetSkeleton()->GetResSkeleton();
        bool isModelCoordinate =
            nw::ut::CheckFlag(resSkeleton.GetFlags(), nw::gfx::ResSkeletonData::FLAG_MODEL_COORDINATE);

        (*model)->UpdateModelViewMatrixAndNormalMatrix(s_BaseCamera->ViewMatrix(), isModelCoordinate);
    }
}

/*!--------------------------------------------------------------------------*
  @brief        シーンを描画します。
 *---------------------------------------------------------------------------*/
void
RenderScene()
{
    s_RenderContext->SetRenderTarget(s_RenderTarget);

    // 描画コマンドを生成します。
    s_CommandListSwapper->StartCommandSave();
    NW_GL_ASSERT();

    s_RenderContext->ClearBuffer(
        GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,
        nw::ut::FloatColor(0.5f, 0.5f, 0.5f, 1.0f),
        1.0f);

    SkeletalModelArray::iterator modelEnd = s_SkeletalModels.end();
    for (SkeletalModelArray::iterator model = s_SkeletalModels.begin(); model != modelEnd; ++model)
    {
        if ((*model)->IsVisible())
        {
            nw::gfx::ResMeshArray resMeshes = (*model)->GetResMeshes();

            nw::gfx::ResMeshArray::iterator meshEnd = resMeshes.end();
            for(nw::gfx::ResMeshArray::iterator mesh = resMeshes.begin();
                mesh != meshEnd;
                ++mesh)
            {
                if ((*model)->IsMeshVisible(*mesh))
                {
                    s_MeshRenderer->RenderMesh(*mesh, *model);
                }
            }
        }
    }
    NW_GL_ASSERT();

    s_CommandListSwapper->EndCommandSave();

    // 左目の描画を行います。
    s_RenderContext->SetCameraMatrix(s_LeftCamera);
    s_CommandListSwapper->ReuseCommand(false);
    s_UpperSwapper->MakeTransferBufferCommand(s_RenderTarget, false);

    // 右目の描画を行います。
    s_RenderContext->SetCameraMatrix(s_RightCamera);
    s_CommandListSwapper->ReuseCommand(false);
    s_ExtensionSwapper->MakeTransferBufferCommand(s_RenderTarget, false);

    s_CommandListSwapper->WaitDone();
    s_CommandListSwapper->RunAsync();
}

/*!--------------------------------------------------------------------------*
  @brief        ディスプレイバッファをスワップして表示します。
 *---------------------------------------------------------------------------*/
void
PresentBuffer()
{
    s_UpperSwapper->ActivateBuffer();
    s_ExtensionSwapper->ActivateBuffer();

    nngxSwapBuffers(NN_GX_DISPLAY0);

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    NW_GL_ASSERT();

    nngxWaitVSync(NN_GX_DISPLAY0);
}

/*!--------------------------------------------------------------------------*
  @brief        シーンをデモンストレーションします。
 *---------------------------------------------------------------------------*/
void
DemoScene()
{
    NW_NULL_ASSERT(s_RenderTarget);

    InitializeScenes();

    s_CommandListSwapper->RunAsync();

    nw::demo::DebugUtility::PostInitializeScenes();

    bool isContinuing = true;

    while ( isContinuing )
    {
        nw::demo::DebugUtility::AdvanceAutoTestFrame();

        nw::demo::PadFactory::GetPad()->Update();

        UpdateScene();

        SetEnvironment();

        s_RenderContext->SetActiveCamera(s_BaseCameraIndex);

        SubmitView();

        RenderScene();

        s_RenderContext->ResetState();

        PresentBuffer();

        if (nw::demo::Utility::IsTerminating())
        {
            isContinuing = false;
        }
    }

    nw::demo::DebugUtility::PreTerminateScenes();

    TerminateScenes();
}

} // namespace

/*!--------------------------------------------------------------------------*
  @brief        メイン関数です。
 *---------------------------------------------------------------------------*/
void
nnMain()
{
    InitializeGraphicsSystem();

    nw::demo::PadFactory::Initialize(&s_DeviceAllocator);

    NW_DEMO_TEST_LOOP(&s_DeviceAllocator, NULL, NULL)
    {
        InitializeGraphics();

        DemoScene();

        TerminateGraphics();
    }

    nw::demo::PadFactory::Finalize();

    FinalizeGraphicsSystem();
}