#include "stdafx.h"
#include "StaticSceneNode.h"

#include "SceneManager.h"
#include "ResourceManager.h"

#include "NifAnimationInfo.h"

cStaticSceneNode::cStaticSceneNode( eSceneNodeType type )
: cSceneNode( type )
, mNumVerts( 0 )
, mVisibleLevel( 0 )
, mOccludeLevel( 1 )
, mFogApplied( false )
, mMaterialApplied( false )
, mPickedByCamera( false )
{
	mNifAniInfo = new cNifAnimationInfo;
}

cStaticSceneNode::~cStaticSceneNode()
{
	if( mNifAniInfo )
	{
		delete mNifAniInfo;
		mNifAniInfo = 0;
	}
}

void cStaticSceneNode::Process( unsigned long deltaTime, unsigned long accumTime )
{
	ProcessVisibleLevel( deltaTime );
	if( mCheckFrustum == false )
		return;

	/// ¹Ýº¹ µ¿ÀÛÀ» °¡Áø °æ¿ì ¿£Áø ³ëµå¸¦ ó¸®
	if( mNifAniInfo )
	{
		mNeedUpdateTransform = true;
		mNifAniInfo->Update( deltaTime, accumTime );
	}

#ifdef REGEN_TOOL
	SetAlphaBlended( 0.4f );
#endif

	cSceneNode::Process( deltaTime, accumTime );
}

void cStaticSceneNode::ProcessVisibleLevel( unsigned long deltaTime )
{
	/// °¡½Ã ·¹º§À» ó¸®
#ifdef MAP_EDITOR
	if( mVisibleLevel < 3 )
	{
		/// Á¤ÇØÁø °Å¸®¸¸Å­ °Å¸£´Â üũ
		if( mVisibleLevel <  SCENEMAN->CalcVisibleLevel( this ) )
		{
			SetAlphaBlended( 0.0f );
			if( mAlpha == mTargetAlpha )
				/// no frustum check
				mCheckFrustum = false;
			else
				/// frustum check
				mCheckFrustum = true;
		}
		else
		{
			if( mOccludeLevel ==1 && mPickedByCamera )
			{
				mPickedByCamera = false;
				SetAlphaBlended( 0.4f );
			}
			else
			{
				SetAlphaBlended( 1.0f );
			}

			/// frustum check
			mCheckFrustum = true;
		}

		/// ¾ËÆĸ¦ ó¸®
		ProcessAlpha( deltaTime );
	}
#else
	ProcessAlpha( deltaTime );
#endif
}

bool cStaticSceneNode::Save( cFileSaver& saver )
{
	/// »óÀ§ Á¤º¸¸¦ ÀúÀå
	if( cSceneNode::Save( saver ) == false ) 
		return false;

	/// ¾È°³ Àû¿ë ¿©ºÎ¸¦ ÀúÀå
	saver.WriteUnsignedInt( mFogApplied ? 1 : 0 );

	/// ÀçÁú Àû¿ë ¿©ºÎ¸¦ ÀúÀå
	saver.WriteUnsignedInt( mMaterialApplied ? 1 : 0 );

	/// ÀçÁú ¼Ó¼ºÀ» ÀúÀå
	saver.Write( &mMaterial, sizeof(cMaterialData_Ver9) );

	/// ±âŸ ¼Ó¼ºÀ» ÀúÀå
	saver.WriteUnsignedInt( mVisibleLevel );
	saver.WriteUnsignedInt( mOccludeLevel );

	return true;
}

bool cStaticSceneNode::Init( cStaticSceneNodeParam& param )
{
	/// ÆÄÀÏÀ» ·Îµù
	if( RESOURCEMAN->LoadNIF( param.mPathName ) == false )
		return false;

	/// ¸®¼Ò½º °ü¸®ÀڷκÎÅÍ ¿£Áø ³ëµå¸¦ º¹Á¦
	NiNode* n = RESOURCEMAN->CloneObjectByName( param.mPathName.Cstr() );
	if( n == 0 )
	{
		assert( 0 && "failed to clone node from resource manager" );
		return false;
	}

	NiTransform world = n->GetWorldTransform();
	if( param.mTranslate == NiPoint3::ZERO && world.m_Translate == NiPoint3::ZERO )
		param.mTranslate = n->GetTranslate();
	if( param.mRotate == NiMatrix3::IDENTITY && world.m_Rotate == NiMatrix3::IDENTITY )
		param.mRotate = n->GetRotate();
	if( param.mScale == 1.0f && world.m_fScale == 1.0f )
		param.mScale = n->GetScale();

	/// »óÀ§ ÃʱâÈ­
	mSceneNiNode = n;

	/// °¡½Ã ·¹º§À» ¼³Á¤
	mVisibleLevel = param.mVisibleLevel;

	/// Â÷Æó ·¹º§À» ¼³Á¤
	mOccludeLevel = param.mOccludeLevel;

	/// ¾ËÆÄ ¼Ó¼ºÀ» ¼³Á¤
	NiAlphaProperty* alphaProp = (NiAlphaProperty*)n->GetProperty( NiProperty::ALPHA );

	if( alphaProp == 0 )
	{
#ifdef MAP_EDITOR

		mWireProp = NiNew NiWireframeProperty;
		mWireProp->SetWireframe( false );

		n->AttachProperty( mWireProp );
#endif

		/// ¾ËÆÄ ¼Ó¼ºÀ» »ý¼º
		alphaProp = NiNew NiAlphaProperty;
		alphaProp->SetAlphaBlending( false );
		alphaProp->SetAlphaTesting( false );
		n->AttachProperty( alphaProp );
	}

	if( cSceneNode::Init( param ) == false )
	{
		return false;
	}

	/// ÀçÁúÀ» ¼³Á¤
	mMaterialApplied = param.mMaterialApplied;
	if( mMaterialApplied )
		SetMaterial( param.mMaterial );

	/// ¾È°³ ¼Ó¼ºÀ» ºÎÂø
	mFogApplied = param.mFogApplied;
	if( mFogApplied )
	{
		n->AttachProperty( SCENEMAN->GetFogProperty() );
	}

	/// Á¶¸íÀ» ºÎÂø
	n->AttachEffect( SCENEMAN->GetAmbientLight( 0 ) );
	n->AttachEffect( SCENEMAN->GetDirLight( 0 ) );

	/// ¾Ö´Ï¸ÞÀÌ¼Ç ÄÁÆ®·Ñ·¯ Á¤º¸ ¼öÁý
	mNifAniInfo->CollectData( n );

	if( mNifAniInfo->GetNumberOfControllers() )
	{
		mNifAniInfo->SetAnimType( NiTimeController::APP_INIT );
		mNifAniInfo->SetLooping( true );

		NiTimeController::StartAnimations(n, 0.0f);
	}
	else
	{
		/// ¾Ö´Ï Á¤º¸°¡ ¾ø´Ù¸é ÇØÁ¦
		delete mNifAniInfo;
		mNifAniInfo = 0;
	}

	/// °»½Å
	bool selectiveUpdate = true;
	bool rigid = false;
	n->SetSelectiveUpdateFlags( selectiveUpdate, true, rigid );

	/// ¿£Áø ³ëµå¸¦ ó¸®
	n->UpdateProperties();
	n->UpdateEffects();
	n->Update( 0.0f );
	n->UpdateNodeBound();

	/// »ï°¢Çü ¼ö¸¦ °è»ê
	cRenderObjList::cIterator i = mRenderObjList.Begin();
	cRenderObjList::cIterator iend = mRenderObjList.End();

	for( ; i != iend; ++i )
	{
		NiMesh* mesh = NiDynamicCast( NiMesh, i->mFirst );
		if( mesh )
		{
			for( unsigned int ct = 0; ct< mesh->GetSubmeshCount(); ct++ )
				mNumVerts += mesh->GetCount( ct, NiCommonSemantics::POSITION() );
		}
	}
	return true;
}

void cStaticSceneNode::SetMaterial( const cMaterialData& material )
{
	mMaterial = material;

	if( mMaterialApplied )
	{
		cMaterialDataList::cIterator i = mMatDataList.Begin();
		cMaterialDataList::cIterator iend = mMatDataList.End();

		for( ; i != iend; ++i )
		{
			cMaterialData* data = (cMaterialData*)*i;
			NiMaterialProperty* matProp = data->mProp;

			matProp->SetAmbientColor( material.mAmbient );
			matProp->SetDiffuseColor( material.mDiffuse );
			matProp->SetSpecularColor( material.mSpecular );
			matProp->SetEmittance( material.mEmissive );
			matProp->SetShineness( material.mShininess );
			matProp->SetAlpha( material.mAlpha );
		}
	}
}

void cStaticSceneNode::SetAmbient( const NiColor& color )
{
	mMaterial.mAmbient = color;

	if( mMaterialApplied )
	{
		cMaterialDataList::cIterator i = mMatDataList.Begin();
		cMaterialDataList::cIterator iend = mMatDataList.End();

		for( ; i != iend; ++i )
		{
			cMaterialData* data = (cMaterialData*)*i;
			NiMaterialProperty* matProp = data->mProp;
			matProp->SetAmbientColor( color );
		}
	}
}

void cStaticSceneNode::SetDiffuse( const NiColor& color )
{
	mMaterial.mDiffuse = color;

	if( mMaterialApplied )
	{
		cMaterialDataList::cIterator i = mMatDataList.Begin();
		cMaterialDataList::cIterator iend = mMatDataList.End();

		for( ; i != iend; ++i )
		{
			cMaterialData* data = (cMaterialData*)*i;
			NiMaterialProperty* matProp = data->mProp;
			matProp->SetDiffuseColor( color );
		}
	}
}

void cStaticSceneNode::SetEmissive( const NiColor& color )
{
	mMaterial.mEmissive = color;

	if( mMaterialApplied )
	{
		cMaterialDataList::cIterator i = mMatDataList.Begin();
		cMaterialDataList::cIterator iend = mMatDataList.End();

		for( ; i != iend; ++i )
		{
			cMaterialData* data = (cMaterialData*)*i;
			NiMaterialProperty* matProp = data->mProp;
			matProp->SetEmittance( color );
		}
	}
}

void cStaticSceneNode::SetMaterialApplied( bool matApplied )
{
//	if( mMaterialApplied == matApplied )
//	{
//		NiMessageBox( _T("Bug Check!!"), _T("Error") );
//	}

	mMaterialApplied = matApplied;

	if( mMaterialApplied )
		SetMaterial( mMaterial );
	else
		RestoreMaterial();
}

void cStaticSceneNode::SetVisibleLevel( unsigned int level )
{
	mVisibleLevel = level;
}

void cStaticSceneNode::SetOccludeLevel( unsigned int level )
{
	mOccludeLevel = level;
}

void cStaticSceneNode::SetFogApplied( bool fogApplied )
{
	if( mFogApplied == fogApplied )
		return;

	if( fogApplied )
	{
		mFogApplied = true;
		GetNiNode()->AttachProperty( SCENEMAN->GetFogProperty() );
	}
	else
	{
		mFogApplied = false;
		GetNiNode()->DetachProperty( SCENEMAN->GetFogProperty() );
	}
	GetNiNode()->UpdateProperties();
}

void cStaticSceneNode::RestoreMaterial()
{
	cMaterialDataList::cIterator i = mMatDataList.Begin();
	cMaterialDataList::cIterator iend = mMatDataList.End();

	for( ; i != iend; ++i )	
	{
		cMaterialData* data = (cMaterialData*)*i;
		NiMaterialProperty* matProp = data->mProp;
		if( matProp )
		{
			matProp->SetAmbientColor( data->mAmbient );
			matProp->SetDiffuseColor( data->mDiffuse );
			matProp->SetSpecularColor( data->mSpecular );
			matProp->SetEmittance( data->mEmissive );
			matProp->SetShineness( data->mShininess );
			matProp->SetAlpha( data->mAlpha );
		}
	}
}

bool cStaticSceneNode::IsAnimated() const
{
	if( mNifAniInfo )
		return mNifAniInfo->GetNumberOfControllers() > 0;

	return false;
}

/*
unsigned int cStaticSceneNode::CalcVisibleLevel()
{
	float sqrDist = (mHeroPos - GetCenter()).SqrLength();

	if( sqrDist > mSqaredLevelDistance2 )
		return 3;
	if( sqrDist > mSqaredLevelDistance1 )
		return 2;
	if( sqrDist > mSqaredLevelDistance0 )
		return 1;
	return 0;
}
*/