#include "stdafx.h"
#include "krenderobject.h"
#include "K3DCamera.h"
#include "KRenderDeviceDX.h"
#include "KDeviceManager.h"
#include "KResourceManager.h"
#include "KResource.h"
#include "KViewport.h"

void AxisCalculation( const K3DMatrix & mat, K3DVector & vVectorX, K3DVector & vVectorY, K3DVector & vVectorZ, float fLen /*= 0.5f*/ )
{
	K3DMatrix Mat1 = mat;
	K3DVector& vector = Mat1.GetPosVector();

	vVectorX = Mat1.GetXVector();
	vVectorX.Normalize(); 	vVectorX = vector + vVectorX * fLen;
	vVectorY = Mat1.GetYVector();
	vVectorY.Normalize();	vVectorY = vector + vVectorY * fLen;
	vVectorZ = Mat1.GetZVector();
	vVectorZ.Normalize();	vVectorZ = vector + vVectorZ * fLen;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KRenderObject Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

KRenderObject::KRenderObject(void)
{
	m_fMasterVisibility = 1.0f;
	m_bIsClip = true;
	m_SkinDiffuse.r = 0;
	m_SkinDiffuse.g = 0;
	m_SkinDiffuse.b = 0;
	m_SkinDiffuse.a = 0;
}

KRenderObject::~KRenderObject(void)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KSeqObject Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

KSeqObject::KSeqObject()
{
	m_dwTime = 0;
	m_dwRealizedTime = 0xffffffff;
	m_pMatParent = NULL;
	m_pMatAttach = NULL;

	m_bRenderFlag = TRUE;
	m_bRotationLock = FALSE;
}
KSeqObject::~KSeqObject()
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KSequencer Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////


KSequencer::KSequencer( bool bCreateByManager )
{
	m_bCreateByMgr = bCreateByManager;
}

KSequencer::~KSequencer()
{
//	m_vecSeqObjects.clear();
	SAFE_DELETE_VECTOR(m_vecSeqObjects);
	if ( m_bCreateByMgr )
	{
		KNX3Manager::GetManager()->ReleaseRes( m_strResName.c_str() );
	}
}

int KSequencer::GetSeqObjectCount()
{
	return static_cast<int>(m_vecSeqObjects.size());
}

KSeqObject* KSequencer::GetSeqObject( int index )
{
	return m_vecSeqObjects[index];
}

void KSequencer::SetName( const char *resname )
{
	m_strResName.assign(resname);
}

const char* KSequencer::GetName()
{
	return m_strResName.c_str();
}

void KSequencer::AddSeqObject( KSeqObject *obj )
{
	m_vecSeqObjects.push_back( obj );
	obj->SetParentTransform( m_pMatParent );
	m_interval.Expand( obj->GetInterval() );
}

void *KSequencer::Perform( KID id, KArg& msg )
{
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetTime( m_dwTime );
		m_vecSeqObjects[i]->Perform( id, msg );
	}
	return (void*)1;
}

void KSequencer::SetColor( DWORD c1, DWORD c2 /* = 0 */, DWORD c3 /* = 0 */, DWORD c4 /* = 0  */, short nMode /*= 0*/ )
{
	for ( unsigned int i=0 ; i< m_vecSeqObjects.size() ; ++i )
	{
		// Fraun texture change 
		//m_vecSeqObjects[i]->SetColor( c1, c2, c3, c4, nMode );
		//if (!c1) c1 = 0;
		//if (!c2) c2 = 0;
		//if (!c3) c3 = 0;
		//if (!c4) c4 = 0;
		//if (!nMode) nMode = 0;

		m_vecSeqObjects[i]->SetColor( c1, c2, c3, c4, nMode );
	}
}

void KSequencer::SetDeform( KSeqObject * pMeshSeq )
{
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetDeform( pMeshSeq );
	}
}

void KSequencer::SetAttach( int nAttachIndex, KSeqObject * pMeshSeq )
{
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetAttach( nAttachIndex, pMeshSeq );
	}
}

void KSequencer::SetAttachEffectPos( int nEffectPosIndex, KSeqObject * pMeshSeq )
{
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetAttachEffectPos( nEffectPosIndex, pMeshSeq );
	}
}

void KSequencer::SetAttachEffectBone( int nBoneIndex, KSeqObject * pMeshSeq )
{
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetAttachEffectBone( nBoneIndex, pMeshSeq );
	}
}

void KSequencer::Process( DWORD time )
{
	m_dwTime = time;

	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetTime( m_dwTime );
//		m_vecSeqObjects[i]->Process( m_dwTime );
	}

}

void KSequencer::ClipTest( const K3DVector* pFrustrum)
{
	int nSize = (int)m_vecSeqObjects.size();
	bool bIsClip = true;

	for ( int i=0 ; i < nSize ; ++i )
	{
		m_vecSeqObjects[i]->SetTime( m_dwTime );
		m_vecSeqObjects[i]->SetVisibility(m_fMasterVisibility);
		m_vecSeqObjects[i]->ClipTest( pFrustrum );

		bIsClip = m_vecSeqObjects[i]->GetIsClip();
		if( !bIsClip ) return; //보여 지는 것이 있으므로 도중에 중단
	}
}

bool KSequencer::GetIsClip()
{
	bool bIsClip = true;
	int nSize = (int)m_vecSeqObjects.size();

	for ( int i=0 ; i < nSize ; ++i )
	{
		//한개 라도 false 이면 보여야 된다.
		bIsClip = m_vecSeqObjects[i]->GetIsClip();
		if( !bIsClip ) return bIsClip; //보여야 되는 것임.
	}

	return bIsClip; //안 보여 지는 것임
}

void KSequencer::Reset()
{
	m_dwTime = 0;

	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->Reset();
	}
}

void KSequencer::Render( KViewportObject *viewport, DWORD flag, const K3DMatrix * pAttachMat )
{
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetTime( m_dwTime );
		m_vecSeqObjects[i]->SetVisibility(m_fMasterVisibility);
		m_vecSeqObjects[i]->SetSkinDiffuse( m_SkinDiffuse );
		m_vecSeqObjects[i]->Render( viewport, flag, pAttachMat );
	}
}

void KSequencer::SetAlterMaterial( K3DMaterial *mat )
{
	KSeqObject::SetAlterMaterial( mat );
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetAlterMaterial( mat );
	}
}

void KSequencer::SetParentTransform( const K3DMatrix *pMatParent, const K3DMatrix *pMatAttach, BOOL bRotationLock )
{
	KSeqObject::SetParentTransform( pMatParent, pMatAttach );
	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetParentTransform( pMatParent, pMatAttach, bRotationLock );
	}
}

void KSequencer::realizeTime()
{
	if ( m_dwRealizedTime == m_dwTime ) return;
	m_dwRealizedTime = m_dwTime;

	for ( unsigned int i=0 ; i<m_vecSeqObjects.size() ; ++i )
	{
		m_vecSeqObjects[i]->SetTime( m_dwTime );
		m_vecSeqObjects[i]->realizeTime();
	}
}

KSequencer* KSequencer::CloneSequence()
{
	return static_cast<KSequencer*>(Clone());
}

KSeqObject* KSequencer::Clone()
{
	KSequencer *obj = new KSequencer;
	for ( int i=0 ; i<GetSeqObjectCount() ; ++i )
		obj->AddSeqObject( GetSeqObject(i)->Clone() );
	return obj;
}

void EatWhiteSpace( std::string& str )
{
	int nLen = ( int ) str.size();
	for( int i = 0; i < nLen; )
	{
		if( str[ i ] == '\r' || str[ i ] == '\n' || str[ i ] == '\t' || str[ i ] == ' ' )
		{
			str.erase( i );
			nLen--;
		}
		else
		{
			break;
		}
	}

	for( int i = nLen - 1; i >= 0; )
	{
		if( str[ i ] == '\r' || str[ i ] == '\n' || str[ i ] == '\t' || str[ i ] == ' ' )
		{
			str.erase( i );
			i--;
		}
		else
		{
			break;
		}
	}
}

void KSequencer::LoadProp( const char* szProperty )
{
	int nLen = strlen( szProperty );
	if( nLen == 0 )
		return;

	while( CreateNewProp( szProperty ) );
}

bool KSequencer::CreateNewProp( const char*& pPropStr )
{
	int nLen = strlen( pPropStr );
	bool bOpened = false;
	std::string strPropName;
	int i = 0;
	KSeqProp prop;

	for( ; i < nLen; i++ )
	{
		if( pPropStr[ i ] == '[' )
		{
			bOpened = true;
			continue;
		}

		if( bOpened && pPropStr[ i ] == ']' )
		{
			bOpened = false;
			continue;
		}

		if( !bOpened && !strPropName.empty() )
			break;

		if( bOpened )
			strPropName.push_back( pPropStr[ i ] );
	}

	pPropStr += i;

	if( bOpened )
		strPropName.clear();

	if( strPropName.empty() )
		goto END;

	EatWhiteSpace( strPropName );

	prop.strName = strPropName;
	while( LoadPropAttrib( prop, pPropStr ) );
	m_vProps.push_back( prop );

END:
	if( strlen( pPropStr ) > 0 )
		return true;
	else
		return false;
}

bool KSequencer::LoadPropAttrib( KSeqProp& rProp, const char*& pPropStr )
{
	int nLen = strlen( pPropStr );
	std::string strName, strValue;
	bool bMoveToValue = false;
	int i = 0;
	KSeqPropAttrib attrib;

	for( ; i < nLen; i++ )
	{
		if( pPropStr[ i ] == '=' )
		{
			bMoveToValue = true;
			continue;
		}

		if( pPropStr[ i ] == '\n' )
		{
			i++;
			break;
		}

		if( !bMoveToValue )
			strName.push_back( pPropStr[ i ] );
		else
			strValue.push_back( pPropStr[ i ] );
	}

	pPropStr += i;

	if( strName.empty() || strValue.empty() )
		goto END;

	EatWhiteSpace( strName );
	EatWhiteSpace( strValue );

	attrib.strName = strName;
	attrib.strValue = strValue;

	rProp.vAttribs.push_back( attrib );

END:
	if( strlen( pPropStr ) > 0 )
		return true;
	else
		return false;
}

const char* KSequencer::GetAttribValue( const char* szPropName, const char* szAttribName)
{
	int numProps = ( int ) m_vProps.size();
	for( int i = 0; i < numProps; i++ )
	{
		if( strcmp( szPropName, m_vProps[ i ].strName.c_str() ) == 0 )
		{
			int numAttribs = ( int ) m_vProps[ i ].vAttribs.size();
			for( int j = 0; j < numAttribs; j++ )
			{
				if( strcmp( szAttribName, m_vProps[ i ].vAttribs[ j ].strName.c_str() ) == 0 )
					return m_vProps[ i ].vAttribs[ j ].strValue.c_str();
			}
		}
	}

	return NULL;
}