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

#include "ResourceManager.h"
#include "CameraManager.h"
#include "SceneManager.h"
#include "LightAgent.h"
#include "FogAgent.h"

#include "NifAnimationInfo.h"

#include "Application.h"

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

cStaticSceneNode::~cStaticSceneNode()
{
	ClearCollectInfo();

	SAFE_DELETE( mNifAniInfo );
}

void cStaticSceneNode::OnProcess( unsigned long deltaTime, unsigned long accumTime )
{
	ProcessVisibleLevel( deltaTime );

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

		cSceneNode::OnProcess( deltaTime, accumTime );

		mNifAniInfo->Update( deltaTime, accumTime );
	}
}

void cStaticSceneNode::ProcessVisibleLevel( unsigned long deltaTime )
{
	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 );
}

bool cStaticSceneNode::Init( const cStaticSceneNodeParam& param )
{
	/// ÆÄÀÏÀ» ·Îµù
	if( RESOURCEMAN->LoadMapNIF( param.mPathName.Cstr() ) == false )
	{
		assert( 0 && "failed to load nif file" );
		return false;
	}

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

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

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

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

	NiTransform world = n->GetWorldTransform();
	if( param.mTranslate != NiPoint3::ZERO || world.m_Translate != NiPoint3::ZERO )
		GetNiObj()->SetTranslate( param.mTranslate );
	if( param.mRotate != NiMatrix3::IDENTITY || world.m_Rotate != NiMatrix3::IDENTITY )
		GetNiObj()->SetRotate( param.mRotate );
	if( param.mScale != 1.0f || world.m_fScale != 1.0f )
		GetNiObj()->SetScale( param.mScale );

	/// °»½Å ¿©ºÎ¸¦ ¼³Á¤
	mNeedUpdateTransform = true;

	/// ÇÈÅ· ¹æ½ÄÀ» ¼³Á¤
	mPick.SetQueryType( param.mQueryType );
	mPick.SetSortType( param.mPickSort );
	mPick.SetIntersectType( param.mPickIntersect );
	mPick.SetCoordinateType( param.mPickCoordinate );
	mPick.SetFrontOnly( param.mPickFrontOnly );
	mPick.SetReturnTexture( param.mPickReturnTexture );
	mPick.SetReturnNormal( param.mPickReturnNormal );
	mPick.SetReturnSmoothNormal( false );
	mPick.SetReturnColor( param.mPickReturnColor );
	mPick.SetTarget( GetNiObj() );
	mPick.SetPickObjectPolicy(NiNew SimpleBoxPickObjectPolicy(false));

	/// ¾ËÆÄ ¼Ó¼ºÀ» ¼³Á¤
	NiAlphaProperty* alphaProp = (NiAlphaProperty*)n->GetProperty( NiProperty::ALPHA );
	if( alphaProp == 0 )
	{
		alphaProp = NiNew NiAlphaProperty;
		alphaProp->SetAlphaBlending( false );
		alphaProp->SetAlphaTesting( false );
		n->AttachProperty( alphaProp );
	}

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

	if( param.mNoAttachLight == false )
	{
		/// Á¶¸íÀ» ºÎÂø
		n->AttachEffect( LIGHTAGENT->GetSceneAmbientLight( 0 ) );
		n->AttachEffect( LIGHTAGENT->GetSceneDirLight( 0 ) );
	}

	/// ±âÇÏ ¿ÀºêÁ§Æ®µéÀ» ¼öÁý
	ClearCollectInfo();
	RecursiveNodeInfo( GetNiObj() );

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

	/// ¿£Áø ³ëµå¸¦ ¼³Á¤
	bool selectiveUpdate = true;
	bool rigid = false;
	n->SetSelectiveUpdateFlags( selectiveUpdate, true, rigid );

	n->UpdateProperties();
	n->UpdateEffects();

	/// ¿£Áø ³ëµå¸¦ ó¸®
	NiMeshUpdateProcess kUpdateProcess;
	kUpdateProcess.SetTime( THEAPP->GetWorldAccumTime()* 0.001f );
	n->Update( kUpdateProcess );
	NiMesh::CompleteSceneModifiers( GetNiObj() );
	n->UpdateNodeBound();

	mBoundSphere.Set( GetCenter(), GetRadius() );

	///// ¾Ö´Ï¸ÞÀÌ¼Ç ÄÁÆ®·Ñ·¯ Á¤º¸ ¼öÁý
	mNifAniInfo->CollectData( n );
	if( mNifAniInfo->GetNumberOfControllers() )
	{
		mNifAniInfo->SetAnimType( NiTimeController::APP_INIT );
		mNifAniInfo->SetLooping( true );

		mNifAniInfo->Start( THEAPP->GetWorldAccumTime() * 0.001f );
	}
	else
	{
		/// ¾Ö´Ï Á¤º¸°¡ ¾ø´Ù¸é ¸Þ¸ð¸® ÇØÁ¦
		SAFE_DELETE(mNifAniInfo);
	}

	if( mNifAniInfo && param.mDisableAnimation == true )
		mNifAniInfo->Stop();

	return true;
}

void cStaticSceneNode::SetMaterial( const cMaterialData& material )
{
	cMatPropList::cIterator i = mMatPropList.Begin();
	cMatPropList::cIterator end = mMatPropList.End();

	for( ; i != end; ++i )
	{
		NiMaterialProperty* matProp = (NiMaterialProperty*)*i;

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

	mMaterial = material;
}

bool cStaticSceneNode::UpdateCameraPickInfo()
{
	mPickedByCamera = true;

	if( mOccludeLevel == 2 )
		return true;
	else
		return false;
}

//////////////////////////////////////////////////////////////////////////

cManagedStaticSceneNode::cManagedStaticSceneNode( eType type )
: cStaticSceneNode( type )
{
	mIsMouseOver = false;
}

cManagedStaticSceneNode::~cManagedStaticSceneNode()
{

}