gfx/res/gfx_ResShape.cpp

/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     gfx_ResShape.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 "../precompiled.h"

#include <nw/ut/ut_ResUtil.h>
#include <nw/ut/ut_ResDictionary.h>
#include <nw/gfx/gfx_SceneObject.h>
#include <nw/gfx/res/gfx_ResShape.h>
#include <nw/gfx/res/gfx_ResParticleShape.h>
#include <nw/gfx/res/gfx_ResTexture.h>
#include <nw/gfx/gfx_Common.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <nw/gfx/gfx_CommandUtil.h>

#include <nn/gx.h>

namespace nw {
namespace gfx {
namespace res {

typedef void (*SetupFunc)(nw::os::IAllocator* allocator, ResShape resShape);
typedef void (*CleanupFunc)(ResShape resShape);

static void ResShape_Setup(nw::os::IAllocator* allocator, ResShape resShape);
static void ResSeparateDataShape_Setup(nw::os::IAllocator* allocator, ResShape resShape);
static void ResParticleShape_Setup(nw::os::IAllocator* allocator, ResShape resShape);

static void ResShape_Cleanup(ResShape resShape);
static void ResSeparateDataShape_Cleanup(ResShape resShape);
static void ResParticleShape_Cleanup(ResShape resShape);

static SetupFunc sShape_SetupTable[] =
{
    ResSeparateDataShape_Setup,
    ResParticleShape_Setup
};

static CleanupFunc sShape_CleanupTable[] =
{
    ResSeparateDataShape_Cleanup,
    ResParticleShape_Cleanup
};


//---------------------------------------------------------------------------
//! @brief        必要であれば頂点バッファのコピー用のメモリを確保し、転送をおこないます。
//!
//! @param[in]    bufferID     メモリ確保用の頂点バッファIDです。
//! @param[in]    resStream    頂点ストリームリソースです。
//! @param[in]    loadFlag     頂点バッファの配置メモリフラグです。
//---------------------------------------------------------------------------
static void
BufferData( u32 bufferID, ResIndexStream resStream, u32 loadFlag )
{
    u32 size = resStream.GetStreamCount();
    GLenum transtype = loadFlag & 0xFFFF0000;
    void* address = NULL;
    const u32 NN_GX_MEM_MASK = 0x00030000;

    switch (transtype)
    {
    case (NN_GX_MEM_FCRAM | GL_NO_COPY_FCRAM_DMP):
        nngxUpdateBuffer( resStream.GetStream(), size );
        break;

    case (NN_GX_MEM_VRAMA | GL_NO_COPY_FCRAM_DMP):
    case (NN_GX_MEM_VRAMB | GL_NO_COPY_FCRAM_DMP):
        {
            GLuint area = (transtype & NN_GX_MEM_MASK);
            address = __dmpgl_allocator(area, NN_GX_MEM_VERTEXBUFFER, bufferID, size);
            nngxAddVramDmaCommand( resStream.GetStream(), address, size );

            resStream.SetLocationAddress( address );
            resStream.ref().m_MemoryArea = area;
        }
        break;

    case (NN_GX_MEM_FCRAM | GL_COPY_FCRAM_DMP):
        {
            address = __dmpgl_allocator(NN_GX_MEM_FCRAM, NN_GX_MEM_VERTEXBUFFER, bufferID, size);
            nw::os::MemCpy( address, resStream.GetStream(), size );
            nngxUpdateBuffer( address, size );

            resStream.SetLocationAddress( address );
            resStream.ref().m_MemoryArea = NN_GX_MEM_FCRAM;
        }
        break;

    case (NN_GX_MEM_VRAMA | GL_COPY_FCRAM_DMP):
    case (NN_GX_MEM_VRAMB | GL_COPY_FCRAM_DMP):
        NW_FATAL_ERROR("GL_COPY_DMA is not supported!");
        break;

    default:
        break;
    }
}

//---------------------------------------------------------------------------
//! @brief        コピーした頂点情報を開放します。
//!
//! @param[in]    bufferID  バッファオブジェクトIDです。
//! @param[in]    resStream
//---------------------------------------------------------------------------
static void
DeleteBuffer( u32 bufferID, ResIndexStream resStream )
{
    GLuint area = resStream.ref().m_MemoryArea;

    if (area != ResIndexStreamData::AREA_NO_MALLOC)
    {
        void* address = reinterpret_cast<void*>( resStream.GetLocationAddress() );
        __dmpgl_deallocator( area, NN_GX_MEM_VERTEXBUFFER, bufferID, address );
        resStream.SetLocationAddress( static_cast<u32>(NULL) );
    }
}


//----------------------------------------
Result
ResShape::Setup(nw::os::IAllocator* allocator)
{
    Result result = RESOURCE_RESULT_OK;
    switch ( this->ref().typeInfo )
    {
    case ResSeparateDataShape::TYPE_INFO:
        {
            sShape_SetupTable[0]( allocator, *this );
            this->SetFlags(ut::EnableFlag(this->GetFlags(), ResShape::FLAG_HAS_BEEN_SETUP));
        }
        break;
    case ResParticleShape::TYPE_INFO:
        {
            sShape_SetupTable[1]( allocator, *this );
            this->SetFlags(ut::EnableFlag(this->GetFlags(), ResShape::FLAG_HAS_BEEN_SETUP));
        }
        break;
    default:
        {
        }
    }
    return result;
}


/*!--------------------------------------------------------------------------*
  Name:         ResShape_Setup

  @brief        シェイプのリソース初期化をおこないます。

  @param[in]    resShape シェイプリソースです。

  @return       なし。
 *---------------------------------------------------------------------------*/
static void
ResShape_Setup(nw::os::IAllocator* allocator, ResShape resShape)
{
    s32 primSetNum = resShape.GetPrimitiveSetsCount();

    for ( s32 i = 0; i < primSetNum; ++i )
    {
        resShape.GetPrimitiveSets( i ).Setup(allocator);
    }
}


/*!--------------------------------------------------------------------------*
  Name:         ResSeparateDataShape_Setup

  @brief        複数属性シェイプのリソース初期化をおこないます。

  @param[in]    resShape シェイプリソースです。

  @return       なし。
 *---------------------------------------------------------------------------*/
static void
ResSeparateDataShape_Setup(nw::os::IAllocator* allocator, ResShape resShape)
{
    ResShape_Setup( allocator, resShape );

    ResSeparateDataShape resSeparateShape = ResStaticCast<ResSeparateDataShape>( resShape );

    s32 vtxAttrNum = resSeparateShape.GetVertexAttributesCount();
    for ( s32 i = 0; i < vtxAttrNum; ++ i )
    {
        resSeparateShape.GetVertexAttributes( i ).Setup();
    }
}


/*!--------------------------------------------------------------------------*
  Name:         ResParticleShape_Setup

  @brief        パーティクルシェイプのリソース初期化をおこないます。

  @param[in]    resShape シェイプリソースです。

  @return       なし。
 *---------------------------------------------------------------------------*/
static void
ResParticleShape_Setup(nw::os::IAllocator* allocator, ResShape resShape)
{
    NW_UNUSED_VARIABLE(resShape);
    NW_UNUSED_VARIABLE(allocator);
}


/*!--------------------------------------------------------------------------*
  Name:         ResPrimitiveSet::Setup

  @brief        リソースの初期化をおこないます。

  @return       なし。
 *---------------------------------------------------------------------------*/
void
ResPrimitiveSet::Setup(nw::os::IAllocator* allocator)
{
    NW_ASSERT( this->IsValid() );

    ResPrimitiveArray primitiveArray = this->GetPrimitives();

    for (ResPrimitiveArray::iterator it = primitiveArray.begin(); it != primitiveArray.end(); ++it)
    {
        (*it).Setup(allocator);
    }
}


/*!--------------------------------------------------------------------------*
  Name:         ResPrimitive::Setup

  @brief        リソースの初期化をおこないます。

  @return       なし。
 *---------------------------------------------------------------------------*/
void
ResPrimitive::Setup(nw::os::IAllocator* allocator)
{
    NW_ASSERT( this->IsValid() );

    if (allocator == NULL) { allocator = CommandCacheManager::GetAllocator(); }

    this->ref().m_CommandAllocator = allocator;
    u32 streamNum = this->GetIndexStreamsCount();

    GLuint* bufferObjects = reinterpret_cast<GLuint*>( this->GetBufferObjects() );

    for ( uint i = 0; i < streamNum; ++i )
    {
        ResIndexStream resStream = this->GetIndexStreams( u32(i) );
        bufferObjects[ i ] = reinterpret_cast<u32>(resStream.ptr());

        s32 commandSize = internal::CalcSetupDrawIndexStreamCommand( resStream );
        resStream.ref().m_CommandCache = allocator->Alloc(commandSize, 4);
        resStream.ref().m_CommandCacheSize = commandSize;

        if (resStream.GetLocationAddress() != NULL)
        {
            resStream.ref().m_MemoryArea = ResIndexStreamData::AREA_NO_MALLOC;
            continue;
        }

        u32   size = resStream.GetStreamCount();
        void* buf  = resStream.GetStream();

        // 頂点インデックスバッファのメモリへの読み込み指定
        int loadFlag = resStream.GetLocationFlag();

        // デフォルトは、FCRAM から NO_COPY。
        if (loadFlag == 0)
        {
            loadFlag = NN_GX_MEM_FCRAM | GL_NO_COPY_FCRAM_DMP;
        }

        BufferData( bufferObjects[ i ], resStream, loadFlag );
    }
}

//----------------------------------------
void
ResPrimitive::SetupDrawCommand(bool hasGeometryShader)
{
    ResIndexStreamArray indexStreams = this->GetIndexStreams();

    ResIndexStreamArray::iterator end = indexStreams.end();
    for (ResIndexStreamArray::iterator stream = indexStreams.begin(); stream != end; ++stream)
    {
        ResIndexStream indexStream = *stream;
        NW_NULL_ASSERT( indexStream.ref().m_CommandCache );

        internal::CommandBufferInfo bufferInfo(
            indexStream.ref().m_CommandCache,
            indexStream.ref().m_CommandCacheSize );

        s32 resultSize = internal::SetupDrawIndexStreamCommand(bufferInfo, indexStream, hasGeometryShader);
        NW_ASSERT( resultSize == indexStream.ref().m_CommandCacheSize );
    }

    ref().m_Flags |= ResPrimitive::FLAG_COMMAND_HAS_BEEN_SETUP;
}

//----------------------------------------
void
ResShape::Cleanup()
{
    switch ( this->ref().typeInfo )
    {
    case ResSeparateDataShape::TYPE_INFO:
        {
            sShape_CleanupTable[0]( *this );
            this->SetFlags(ut::DisableFlag(this->GetFlags(), ResShape::FLAG_HAS_BEEN_SETUP));
        }
        break;
    case ResParticleShape::TYPE_INFO:
        {
            sShape_CleanupTable[1]( *this );
            this->SetFlags(ut::DisableFlag(this->GetFlags(), ResShape::FLAG_HAS_BEEN_SETUP));
        }
        break;
    default:
        {
        }
    }
}

//----------------------------------------
static void
ResShape_Cleanup(ResShape resShape)
{
    s32 primSetNum = resShape.GetPrimitiveSetsCount();

    for ( s32 i = 0; i < primSetNum; ++i )
    {
        resShape.GetPrimitiveSets( i ).Cleanup();
    }
}

//----------------------------------------
static void
ResSeparateDataShape_Cleanup(ResShape resShape)
{
    ResSeparateDataShape resSeparateShape = ResStaticCast<ResSeparateDataShape>( resShape );

    s32 vtxAttrNum = resSeparateShape.GetVertexAttributesCount();

    for ( s32 i = 0; i < vtxAttrNum; ++ i )
    {
        resSeparateShape.GetVertexAttributes( i ).Cleanup();
    }

    ResShape_Cleanup( resShape );
}

//----------------------------------------
static void
ResParticleShape_Cleanup(ResShape resShape)
{
    ResParticleShape resParticleShape = ResStaticCast<ResParticleShape>( resShape );
}


//------------------------------------------------------------------------------
void
ResPrimitiveSet::Cleanup()
{
    NW_ASSERT( this->IsValid() );

    ResPrimitiveArray primitiveArray = this->GetPrimitives();

    for (ResPrimitiveArray::iterator it = primitiveArray.begin(); it != primitiveArray.end(); ++it)
    {
        (*it).Cleanup();
    }
}


//------------------------------------------------------------------------------
void
ResPrimitive::Cleanup()
{
    NW_ASSERT( this->IsValid() );

    u32 streamNum = this->GetIndexStreamsCount();

    GLuint* bufferObjects = reinterpret_cast<GLuint*>( this->GetBufferObjects() );

    for ( uint i = 0; i < streamNum; ++i )
    {
        ResIndexStream resStream = this->GetIndexStreams( u32(i) );
        if (resStream.IsValid() && resStream.ref().m_CommandCache)
        {
            this->ref().m_CommandAllocator->Free(resStream.ref().m_CommandCache);
            resStream.ref().m_CommandCache = NULL;
            resStream.ref().m_CommandCacheSize = 0;
        }

        DeleteBuffer( bufferObjects[ i ], resStream );
    }

    std::memset( bufferObjects, 0, sizeof(GLuint) * streamNum );

    ref().m_CommandAllocator = NULL;
    ref().m_Flags &= ~FLAG_COMMAND_HAS_BEEN_SETUP;
}


//----------------------------------------------------------
u32
ResSeparateDataShape::GetVertexCount()
{
    int attributesCount = this->GetVertexAttributesCount();
    for (int i = 0 ; i < attributesCount ; ++i)
    {
        u32 vertexCount = this->GetVertexAttributes(i).GetVertexCount();

        // 最初に見つかった頂点数を返します。
        if (vertexCount)
        {
            return vertexCount;
        }
    }

    NW_FATAL_ERROR("Vertex stream not found\n");

    return 0;
}

} /* namespace res */
} /* namespace gfx */
} /* namespace nw */