gfx/res/gfx_ResMaterial.cpp

/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     gfx_ResMaterial.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/gfx/res/gfx_ResUtil.h>
#include <nw/gfx/res/gfx_ResMaterial.h>
#include <nw/gfx/res/gfx_ResGraphicsFile.h>

namespace nw {
namespace gfx {
namespace res {

static Result
SetupTextureCoordinators(ResMaterial resMaterial);

//----------------------------------------------------------------------------
Result
ResMaterial::Setup(os::IAllocator* allocator, ResGraphicsFile graphicsFile)
{
    NW_ASSERT( internal::ResCheckRevision( graphicsFile ) );
    NW_ASSERT( internal::ResCheckRevision( *this ) );

    NW_ASSERT( this->IsValid() );

    Result result = RESOURCE_RESULT_OK;

    // Texture をセットアップします。
    if (!ut::CheckFlag(this->GetFlags(), ResMaterialData::FLAG_HAS_BEEN_SETUP_TEXTURE))
    {
        result |= this->SetupTextures(allocator, *this, graphicsFile);
    }

    // Shader をセットアップします。
    if (!ut::CheckFlag(this->GetFlags(), ResMaterialData::FLAG_HAS_BEEN_SETUP_SHADER))
    {
        result |= this->SetupShader(allocator, this->GetShader(), graphicsFile);
    }

    if (!ut::CheckFlag(this->GetFlags(), ResMaterialData::FLAG_HAS_BEEN_SETUP_FRAGMENTSHADER))
    {
        // FragmentShader をセットアップします。
        ResFragmentShader resFragmentShader = this->GetFragmentShader();
        NW_ASSERT(resFragmentShader.GetFragmentLightingTable().IsValid());
        Result resultFragmentShader = resFragmentShader.Setup(allocator, graphicsFile);
        result |= resultFragmentShader;

        // 必ず参照解決が完了している状態で呼び出す必要があります。
        if (resultFragmentShader.IsSuccess())
        {
            this->EnableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP_FRAGMENTSHADER);

            // フラグメントライティングテーブルのハッシュを計算します。
            this->CalcFragmentLightingTableHash();
        }
    }

    if (result.IsSuccess())
    {
        this->EnableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP);
    }

    return result;
}

//----------------------------------------------------------------------------
void
ResMaterial::Cleanup()
{
    this->DisableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP);

    this->DisableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP_FRAGMENTSHADER);
    ut::SafeCleanup(this->GetFragmentShader());

    this->DisableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP_SHADER);

    // NOTE: ResBinaryShader がマテリアルに直に入っていることは無くなったので、
    //   ResReferenceShader 用の Cleanup 処理のみをおこなう。
    ResReferenceShader resShader = ResDynamicCast<ResReferenceShader>(this->GetShader());
    if (resShader.IsValid())
    {
        resShader.ref().toTargetShader.set_ptr(NULL);
    }

    this->DisableFlags((ResMaterialData::FLAG_HAS_BEEN_SETUP_TEXTURE));
    int textureMapperNum = this->GetTextureMappersCount();
    for ( int i = 0; i < textureMapperNum; ++i )
    {
        ResPixelBasedTextureMapper textureMapper = this->GetTextureMappers( i );
        if (textureMapper.IsValid())
        {
            textureMapper.Cleanup();
        }
    }

    if (this->GetProceduralTextureMapper().IsValid())
    {
        this->GetProceduralTextureMapper().Cleanup();
    }
}

//----------------------------------------
Result
ResMaterial::SetupTextures(os::IAllocator* allocator, ResMaterial resMaterial, ResGraphicsFile graphicsFile)
{
    Result result = RESOURCE_RESULT_OK;

    // TextureCoordinator をセットアップします。
    result |= SetupTextureCoordinators(resMaterial);

    s32 textureMapperNum = resMaterial.GetTextureMappersCount();
    u32 textureSamplersHash = resMaterial.GetTextureSamplersHash();
    // TextureMapper をセットアップします。
    for ( int i = 0; i < textureMapperNum; ++i )
    {
        ResPixelBasedTextureMapper resTextureMapper = resMaterial.GetTextureMappers( i );
        if (!resTextureMapper.IsValid())
        {
            continue;
        }

        if (!resTextureMapper.GetTexture().IsValid())
        {
            continue;
        }

        result |= resTextureMapper.Setup(allocator, graphicsFile);

        // テクスチャコーディネータを参照してテクスチャサンプラーのコマンドを設定する
        enum
        {
            SAMPLER_TYPE_SHIFT = 28,
            SAMPLER_TYPE_MASK = 0x7 << SAMPLER_TYPE_SHIFT,
            SAMPLER_TYPE_2D = 0,
            SAMPLER_TYPE_CUBE_MAP = 1,
            SAMPLER_TYPE_SHADOW_2D = 2,
            SAMPLER_TYPE_PROJECTION = 3,
            SAMPLER_TYPE_SHADOW_CUBE = 4
        };
        u32* command = resTextureMapper.GetCommandCache();
        NW_NULL_ASSERT(command);

        command[5] &= ~(SAMPLER_TYPE_MASK); // sampler_type
        // テクスチャ０のみ複数のサンプラータイプが設定できる。
        if ( i == 0 )
        {
            switch (resMaterial.GetTextureCoordinators(0).GetMappingMethod())
            {
            case ResTextureCoordinator::MAPPINGMETHOD_UV_COORDINATE:
                {
                    command[5] |= SAMPLER_TYPE_2D << SAMPLER_TYPE_SHIFT;
                }
                break;
            case ResTextureCoordinator::MAPPINGMETHOD_PROJECTION:
                {
                    command[5] |= SAMPLER_TYPE_PROJECTION << SAMPLER_TYPE_SHIFT;
                }
                break;
            case ResTextureCoordinator::MAPPINGMETHOD_CAMERA_CUBE_ENV:
                {
                    command[5] |= SAMPLER_TYPE_CUBE_MAP << SAMPLER_TYPE_SHIFT;
                }
                break;
            case ResTextureCoordinator::MAPPINGMETHOD_CAMERA_SPHERE_ENV:
                {
                    command[5] |= SAMPLER_TYPE_2D << SAMPLER_TYPE_SHIFT;
                }
                break;
            case ResTextureCoordinator::MAPPINGMETHOD_SHADOW:
                {
                    command[5] |= SAMPLER_TYPE_SHADOW_2D << SAMPLER_TYPE_SHIFT;
                }
                break;
            case ResTextureCoordinator::MAPPINGMETHOD_SHADOW_CUBE:
                {
                    command[5] |= SAMPLER_TYPE_SHADOW_CUBE << SAMPLER_TYPE_SHIFT;
                }
                break;
            default:
                NW_FATAL_ERROR("Unsupported mapping method.");
                break;
            }
        }

        if (result.IsSuccess())
        {
            // カメラキューブ座標のマッピング方法でキューブテクスチャでなければ警告を出します。
            if (resMaterial.GetTextureCoordinators(0).GetMappingMethod() == ResTextureCoordinator::MAPPINGMETHOD_CAMERA_CUBE_ENV &&
                resTextureMapper.GetTexture().Dereference().GetTypeInfo() != ResCubeTexture::TYPE_INFO)
            {
                result |= RESOURCE_RESULT_IRRELEVANT_TEXTURE_MAPPING_METHOD;
            }

            ResTexture resImageTexture = resTextureMapper.GetTexture().Dereference();
            u32 hash = 0;
            if (i == 0)
            {
                hash = (u32)resImageTexture.ptr();
            }
            else
            {
                hash = ((u32)resImageTexture.ptr() << i * 8) | ((u32)resImageTexture.ptr() >> (32 - i * 8));
            }

            textureSamplersHash ^= hash;
        }
    }

    resMaterial.SetTextureMappersHash(textureSamplersHash);

    if (resMaterial.GetProceduralTextureMapper().IsValid())
    {
        result |= resMaterial.GetProceduralTextureMapper().Setup(allocator, graphicsFile);
    }

    if (result.IsSuccess())
    {
        this->EnableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP_TEXTURE);
    }

    return result;
}

static Result SetupTextureCoordinators(ResMaterial resMaterial)
{
    Result result = RESOURCE_RESULT_OK;

    // TextureMapper と TextureCoordinator の組み合わせを確認します。
    s32 textureCoordinatorNum = resMaterial.GetTextureCoordinatorsCount();
    ResMaterial::TextureCoordinateConfig config = resMaterial.GetTextureCoordinateConfig();
    bool isProceduralTextureEnabled = resMaterial.GetProceduralTextureMapper().IsValid();
    for ( int i = 0; i < textureCoordinatorNum; ++i )
    {
        ResTextureCoordinator resTextureCoordinator = resMaterial.GetTextureCoordinators(i);
        bool isTextureMapperEnabled = resMaterial.GetTextureMappers(i).IsValid();
        bool isTextureCoordinatorEnabled = false;

        switch(i)
        {
        case 0:
            {
                if (isTextureMapperEnabled)
                {
                    isTextureCoordinatorEnabled = true;
                }
                else if (config == ResMaterial::CONFIG_0120 || config == ResMaterial::CONFIG_0110)
                {
                    if (isProceduralTextureEnabled)
                    {
                        isTextureCoordinatorEnabled = true;
                    }
                }
            }
            break;
        case 1:
            {
                if (isTextureMapperEnabled)
                {
                    isTextureCoordinatorEnabled = true;
                }
                else
                {
                    if (config == ResMaterial::CONFIG_0111)
                    {
                        if (resMaterial.GetTextureMappers(2).IsValid() || isProceduralTextureEnabled)
                        {
                            isTextureCoordinatorEnabled = true;
                        }
                    }
                    else if (config == ResMaterial::CONFIG_0110 || config == ResMaterial::CONFIG_0112)
                    {
                        if (resMaterial.GetTextureMappers(2).IsValid())
                        {
                            isTextureCoordinatorEnabled = true;
                        }
                    }
                    else if (config == ResMaterial::CONFIG_0121)
                    {
                        if (isProceduralTextureEnabled)
                        {
                            isTextureCoordinatorEnabled = true;
                        }
                    }
                }
            }
            break;
        case 2:
            {
                if (config == ResMaterial::CONFIG_0122)
                {
                    if (isTextureMapperEnabled || isProceduralTextureEnabled)
                    {
                        isTextureCoordinatorEnabled = true;
                    }
                }
                else if (config == ResMaterial::CONFIG_0120 || config == ResMaterial::CONFIG_0121)
                {
                    if (isTextureMapperEnabled)
                    {
                        isTextureCoordinatorEnabled = true;
                    }
                }
                else if (config == ResMaterial::CONFIG_0112)
                {
                    if (isProceduralTextureEnabled)
                    {
                        isTextureCoordinatorEnabled = true;
                    }
                }
            }
            break;
        default:
            {
                NW_FATAL_ERROR("Invalid coordinator number.");
            }
        }

        resTextureCoordinator.SetEnabled(isTextureCoordinatorEnabled);
    }
    return result;
}

//----------------------------------------
Result
ResMaterial::SetupShader(
    os::IAllocator* allocator,
    ResShader resShader,
    ResGraphicsFile graphicsFile
)
{
    Result result = RESOURCE_RESULT_OK;
    ResShader setupShader;

    if (resShader.IsValid())
    {
        bool existShader = false;
        ResReferenceShader refer = ResDynamicCast<ResReferenceShader>(resShader);
        if (refer.IsValid())
        {
            if (refer.GetTargetShader().IsValid())
            {
                setupShader = refer.GetTargetShader();
                existShader = true;
            }
            else
            {
                ::std::pair<ResShader, bool> referenceResult;
                referenceResult = GetReferenceShaderTarget(refer, graphicsFile);
                if (referenceResult.second)
                {
                    setupShader = referenceResult.first;
                    existShader = true;
                }
                else
                {
                    result |= Result::MASK_FAIL_BIT;
                    result |= RESOURCE_RESULT_NOT_FOUND_SHADER;
                }
            }
        }
        else
        {
            setupShader = resShader;
            existShader = true;
        }

        if (existShader)
        {
            result |= setupShader.Setup(allocator, graphicsFile);
        }
    }

    bool isSetup = resShader.IsValid() && result.IsSuccess();
    if (isSetup)
    {
        this->EnableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP_SHADER);

        // ユーザーシェーダーユニフォームのインデックス番号をキャッシュします。
        ResBinaryShader resBinaryShader = resShader.Dereference();
        NW_MINMAXLT_ASSERT(this->GetShaderProgramDescriptionIndex(), 0, resBinaryShader.GetDescriptionsCount());

        ResShaderProgramDescription description =
            resBinaryShader.GetDescriptions(this->GetShaderProgramDescriptionIndex());
        this->CacheUserUniformIndex(description.GetSymbols());
    }

    return result;
}

//----------------------------------------
void
ResMaterial::SetShader(ResShader resShader)
{
    NW_ASSERT(resShader.IsValid());
    ResReferenceShader referenceShader = ResStaticCast<ResReferenceShader>(this->GetShader());
    referenceShader.ref().toTargetShader.set_ptr(resShader.Dereference().ptr());
}

//----------------------------------------
void
ResMaterial::CacheUserUniformIndex(ResShaderSymbolArray symbols)
{
    for (int parameterIndex = 0; parameterIndex < this->GetShaderParametersCount(); ++parameterIndex)
    {
        ResShaderParameter parameter = this->GetShaderParameters(parameterIndex);
        if (parameter.IsValid())
        {
            const char* name = parameter.GetName();

            if (name == NULL) { continue; }

            for (int symbolIndex = 0; symbolIndex < symbols.size(); ++symbolIndex)
            {
                ResShaderSymbol shaderSymbol = symbols[symbolIndex];
                if (::std::strcmp(name, shaderSymbol.GetName()) == 0)
                {
                    // ユーザーユニフォームのインデックスをキャッシュします。
                    parameter.SetSymbolIndex(symbolIndex);
                    break;
                }
            }
        }
    }
}

//----------------------------------------
void
ResMaterial::CalcFragmentLightingTableHash()
{
    enum
    {
        D0_SHIFT = 0,
        D1_SHIFT = 4,
        RR_SHIFT = 8,
        RG_SHIFT = 12,
        RB_SHIFT = 16,
        FR_SHIFT = 20,
        MAX_BITS = 32
    };

    ResFragmentShader resFragmentShader = this->GetFragmentShader();
    ResFragmentLightingTable resFragmentLightingTable = resFragmentShader.GetFragmentLightingTable();
    NW_ASSERT(resFragmentLightingTable.IsValid());

    // FragmentLightingTableのハッシュ値を再計算します。
    u32 fragmentLightingTableParametersHash = this->GetFragmentLightingTableParametersHash();

    if (resFragmentLightingTable.GetDistribution0Sampler().IsValid())
    {
        ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetDistribution0Sampler().GetSampler());
        if (refLut.IsValid())
        {
            ResImageLookupTable imageLut = refLut.Dereference();
            fragmentLightingTableParametersHash ^= ((u32)imageLut.ptr()) << D0_SHIFT;
        }
    }

    if (resFragmentLightingTable.GetDistribution1Sampler().IsValid())
    {
        ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetDistribution1Sampler().GetSampler());
        if (refLut.IsValid())
        {
            ResImageLookupTable imageLut = refLut.Dereference();
            fragmentLightingTableParametersHash ^=
                ((u32)imageLut.ptr() << D1_SHIFT) | ((u32)imageLut.ptr() >> (MAX_BITS - D1_SHIFT));
        }
    }

    if (resFragmentLightingTable.GetReflectanceRSampler().IsValid())
    {
        ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetReflectanceRSampler().GetSampler());
        if (refLut.IsValid())
        {
            ResImageLookupTable imageLut = refLut.Dereference();
            fragmentLightingTableParametersHash ^=
                ((u32)imageLut.ptr() << RR_SHIFT) | ((u32)imageLut.ptr() >> (MAX_BITS - RR_SHIFT));
        }
    }

    if (resFragmentLightingTable.GetReflectanceGSampler().IsValid())
    {
        ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetReflectanceGSampler().GetSampler());
        if (refLut.IsValid())
        {
            ResImageLookupTable imageLut = refLut.Dereference();
            fragmentLightingTableParametersHash ^=
                ((u32)imageLut.ptr() << RG_SHIFT) |
                ((u32)imageLut.ptr() >> (MAX_BITS - RG_SHIFT));
        }
    }

    if (resFragmentLightingTable.GetReflectanceBSampler().IsValid())
    {
        ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetReflectanceBSampler().GetSampler());
        if (refLut.IsValid())
        {
            ResImageLookupTable imageLut = refLut.Dereference();
            fragmentLightingTableParametersHash ^=
                ((u32)imageLut.ptr() << RB_SHIFT) |
                ((u32)imageLut.ptr() >> (MAX_BITS - RB_SHIFT));
        }
    }

    if (resFragmentLightingTable.GetFresnelSampler().IsValid())
    {
        ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetFresnelSampler().GetSampler());
        if (refLut.IsValid())
        {
            ResImageLookupTable imageLut = refLut.Dereference();
            fragmentLightingTableParametersHash ^=
                ((u32)imageLut.ptr() << FR_SHIFT) |
                ((u32)imageLut.ptr() >> (MAX_BITS - FR_SHIFT));
        }
    }

    this->SetFragmentLightingTableHash(fragmentLightingTableParametersHash);
}

//----------------------------------------
void
ResMaterial::ForceSetupTexture(const char* targetName, ResTexture texture)
{
    NW_NULL_ASSERT(targetName);
    const int textureMapperNum = GetTextureMappersCount();
    u32 textureSamplersHash = GetTextureSamplersHash();

    for (int idx = 0; idx < textureMapperNum; ++idx)
    {
        ResPixelBasedTextureMapper texMap = GetTextureMappers(idx);
        if (texMap.IsValid())
        {
            ResReferenceTexture target = ResDynamicCast<ResReferenceTexture>(texMap.GetTexture());

            if (target.IsValid())
            {
                const char* name = target.GetPath();
                if (std::strcmp(name, targetName) == 0)
                {
                    texMap.ForceSetupTexture(texture);
                }
            }

            ResTexture imageTexture = texMap.GetTexture().Dereference();
            u32 hash = 0;
            if (idx == 0)
            {
                hash = (u32)imageTexture.ptr();
            }
            else
            {
                hash = ((u32)imageTexture.ptr() << idx * 8) | ((u32)imageTexture.ptr() >> (32 - idx * 8));
            }

            textureSamplersHash ^= hash;
        }
    }

    SetTextureMappersHash(textureSamplersHash);
}

//----------------------------------------
void
ResMaterial::ForceSetupShader(const char* targetName, ResShader shader)
{
    NW_ASSERT(shader.IsValid());
    NW_NULL_ASSERT(targetName);

    ResReferenceShader referenceShader = ResDynamicCast<ResReferenceShader>(this->GetShader());
    if (referenceShader.IsValid())
    {
        if (std::strcmp(referenceShader.GetPath(), targetName) == 0)
        {
            this->SetShader(shader);
            this->EnableFlags(ResMaterialData::FLAG_HAS_BEEN_SETUP_SHADER);

            // ユーザーシェーダーユニフォームのインデックス番号をキャッシュします。
            ResBinaryShader resBinaryShader = shader.Dereference();
            NW_MINMAXLT_ASSERT(this->GetShaderProgramDescriptionIndex(), 0, resBinaryShader.GetDescriptionsCount());

            ResShaderProgramDescription description =
                resBinaryShader.GetDescriptions(this->GetShaderProgramDescriptionIndex());

            this->CacheUserUniformIndex(description.GetSymbols());
        }
    }
}

//----------------------------------------
void
ResMaterial::ForceSetupLookupTable(const char* targetName, ResLookupTable lut)
{
    NW_ASSERT(lut.IsValid());
    NW_NULL_ASSERT(targetName);

    ResFragmentShader fragmentShader = this->GetFragmentShader();
    if (fragmentShader.IsValid())
    {
        fragmentShader.ForceSetupLightingLut(targetName, lut);

        // フラグメントライティングテーブルのハッシュを計算します。
        this->CalcFragmentLightingTableHash();
    }
}

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