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

#include "precompiled.h"
#include <nw/gfx/gfx_ActivateCommand.h>
#include <nw/gfx/gfx_ParticleMaterialActivator.h>
#include <nw/gfx/gfx_MaterialState.h>
#include <nw/gfx/gfx_Model.h>
#include <nn/gx.h>
#include <nw/dev.h>


namespace nw
{
namespace gfx
{

NW_UT_RUNTIME_TYPEINFO_DEFINITION(ParticleMaterialActivator, IMaterialActivator);

//----------------------------------------
IMaterialActivator*
ParticleMaterialActivator::Create(os::IAllocator* allocator)
{
    void* memory = allocator->Alloc(sizeof(ParticleMaterialActivator));
    
    if (memory == NULL)
    {
        return NULL;
    }
    else
    {
        return new(memory) ParticleMaterialActivator(allocator);
    }
}

//----------------------------------------
void
ParticleMaterialActivator::Activate(RenderContext* renderContext, const Material* material)
{
    #define _NO_USE_MATERIAL_BUFFER (1)

    NW_NULL_ASSERT(renderContext);

    const SceneEnvironment& sceneEnvironment = renderContext->GetSceneEnvironment();

    // ParticleMaterialActivator の場合はリソースの比較を行います。
    // 直前に設定したマテリアルがバッファを使っている場合はスキップできません。
    const Material* cacheMaterial = renderContext->GetMaterialCache();
    if ( ( cacheMaterial != NULL) && 
         ( cacheMaterial->GetOriginal() == material->GetOriginal() ) )
    {
        return;
    }

    const ShaderProgram* shaderProgram = renderContext->GetShaderProgram();
    NW_NULL_ASSERT(shaderProgram);

    ResMaterial original = material->GetOriginal();
    const Model* owner = material->GetOwnerModel();
    NW_NULL_ASSERT(owner);

    RenderContext::MaterialHash materialHash = renderContext->GetMaterialHash();

    // シェーダパラメータは使用しない(ActivateShaderParameter)

    ResMaterial resShadingParametersMaterial = original;
    
    // シェーディングパラメータは使用しない(ActivateShadingParameters)   
    // フォグ
    internal::MaterialState::ActivateFogParameters(sceneEnvironment, resShadingParametersMaterial);

    // ラスタライズ/ポリゴンオフセット等の設定
    ResRasterization resRasterization = original.GetRasterization();
    u32 rasterizationHash = original.GetRasterizationHash();
    bool isRasterizationEnabled = (rasterizationHash == 0x0) || (rasterizationHash != materialHash.rasterization);
    if (isRasterizationEnabled)
    {
        internal::MaterialState::ActivateRasterization(resRasterization);
        materialHash.rasterization = rasterizationHash;
    }

    // テクスチャコーディネイター
    ResMaterial resTextureCoordinatorsMaterial = original;
    u32 textureCoordinatorHash = resTextureCoordinatorsMaterial.GetTextureCoordinatorsHash();
    if (textureCoordinatorHash != materialHash.textureCoordinator)
    {
        // パーティクル専用のテクスチャコーディネータを使用します。
        internal::MaterialState::ActivateParticleTextureCoordinators(renderContext, shaderProgram, resTextureCoordinatorsMaterial);
        materialHash.textureCoordinator = textureCoordinatorHash;
    }

    // テクスチャマッパー
    ResMaterial resTextureMappersMaterial = original;
    u32 textureMappersHash = resTextureMappersMaterial.GetTextureMappersHash();
    bool isTextureMappersEnabled = (textureMappersHash == 0x0) || (textureMappersHash != materialHash.textureMapper);
    if (isTextureMappersEnabled)
    {
        internal::MaterialState::ActivateParticleTextureMappers(resTextureMappersMaterial);
        materialHash.textureMapper = textureMappersHash;
    }

    // ライトは使用しない(ActivateFragmentLighting/ActivateFragmentLightingTable)
    
    // マテリアルカラーは使用しない(ActivateMaterialColor)
    ResMaterialColor resMaterialColor =  original.GetMaterialColor();

    // コンスタントカラー使用判別用
    u32 materialColorHash = original.GetMaterialColorHash();
    bool isMaterialColorEnabled = (materialColorHash == 0x0) || (materialColorHash != materialHash.materialColor);

    // テクスチャコンバイナ
    ResFragmentShader resTextureCombinerFragmentShader = original.GetFragmentShader();
    u32 textureCombinersHash = original.GetTextureCombinersHash();
    bool isTextureCombinersEnabled = (textureCombinersHash == 0x0) || (textureCombinersHash != materialHash.textureCombiner);
    if (isTextureCombinersEnabled || isMaterialColorEnabled)
    {
        internal::MaterialState::ActivateTextureCombiners(resTextureCombinerFragmentShader, resMaterialColor);
        materialHash.textureCombiner = textureCombinersHash;
    }

    // アルファテスト
    ResAlphaTest resAlphaTest = original.GetFragmentShader().GetAlphaTest();
    internal::MaterialState::ActivateAlphaTest(resAlphaTest);

    // ブレンド/デプス/ステンシル設定
    ResFragmentOperation resFragmentOperation = original.GetFragmentOperation();
    u32 fragmentOperationHash = original.GetFragmentOperationHash();
    bool isFragmentOperationEnabled = (fragmentOperationHash == 0x0) || (fragmentOperationHash != materialHash.fragmentOperation);
    if (isFragmentOperationEnabled)
    {
        internal::MaterialState::ActivateFragmentOperation(resFragmentOperation);
        materialHash.fragmentOperation = fragmentOperationHash;
    }
    renderContext->SetMaterialHash(materialHash);
}

//----------------------------------------
ParticleMaterialActivator::ParticleMaterialActivator(os::IAllocator* allocator)
    : IMaterialActivator(allocator)
{
}

//----------------------------------------
ParticleMaterialActivator::~ParticleMaterialActivator()
{
}

} // namespace gfx
} // namespace nw