// ******************************************************
//
// Purpose:
//		-	Handles model rendering requests from the
//			shader editor library
// 
// ******************************************************

#include "cbase.h"
#include "ShaderEditor/SEdit_ModelRender.h"
#include "model_types.h"

#include "view_shared.h"
#include "iviewrender.h"
#include "viewpostprocess.h"
#include "view.h"
#include "input.h"

#include "beamdraw.h"
#include "vgui_controls/controls.h"
#include "vgui/iinput.h"

extern void ScreenToWorld( int mousex, int mousey, float fov,
					const Vector& vecRenderOrigin,
					const QAngle& vecRenderAngles,
					Vector& vecPickingRay );

SEditModelRender __g_ShaderEditorMReder( "ShEditMRender" );
SEditModelRender *sEditMRender = &__g_ShaderEditorMReder;

SEditModelRender::SEditModelRender( char const *name ) : CAutoGameSystemPerFrame( name )
{
	pModelInstance = NULL;
	m_iNumPoseParams = 0;
	DestroyModel();
}
SEditModelRender::~SEditModelRender()
{
	DestroyModel();
}

bool SEditModelRender::Init()
{
	return true;
}
void SEditModelRender::Shutdown()
{
}
void SEditModelRender::Update( float frametime )
{
	if ( !IsModelReady() )
		return;

	pModelInstance->StudioFrameAdvance();
	if ( pModelInstance->GetCycle() >= 1.0f )
		pModelInstance->SetCycle( 0 );
}
void SEditModelRender::LevelInitPostEntity()
{
	ResetModel();
}
void SEditModelRender::LevelShutdownPostEntity()
{
	ResetModel();
}
void SEditModelRender::ResetModel()
{
	if ( !IsModelReady() )
		return;
	pModelInstance->m_flAnimTime = gpGlobals->curtime;
	pModelInstance->m_flOldAnimTime = gpGlobals->curtime;
}
bool SEditModelRender::IsModelReady()
{
	if ( !pModelInstance )
		return false;

	bool bValid = !!pModelInstance->GetModel();

	if ( bValid && Q_strlen( m_szModelPath ) )
	{
		const model_t *pMdl = modelinfo ? modelinfo->FindOrLoadModel( m_szModelPath ) : NULL;
		if ( pMdl )
			pModelInstance->SetModelPointer( pMdl );
		bValid = !!pMdl;
	}

	if ( !bValid )
		DestroyModel();

	return bValid;
}
bool SEditModelRender::LoadModel( const char *localPath )
{
	DestroyModel();

	const model_t *mdl = modelinfo->FindOrLoadModel( localPath );
	if ( !mdl )
		return false;

	Q_strcpy( m_szModelPath, localPath );

	C_BaseFlex *pEnt = new C_BaseFlex();
	pEnt->InitializeAsClientEntity( NULL,
#if SWARM_DLL
		false
#else
		RENDER_GROUP_OPAQUE_ENTITY
#endif
		);
	MDLCACHE_CRITICAL_SECTION();
	pEnt->SetModelPointer( mdl );
	pEnt->Spawn();

	pEnt->SetAbsAngles( vec3_angle );
	pEnt->SetAbsOrigin( vec3_origin );
	
	pEnt->AddEffects( EF_NODRAW | EF_NOINTERP );
	pEnt->m_EntClientFlags |= ENTCLIENTFLAG_DONTUSEIK;

	// leave it alone.
	pEnt->RemoveFromLeafSystem();
	cl_entitylist->RemoveEntity( pEnt->GetRefEHandle() );
	pEnt->CollisionProp()->DestroyPartitionHandle();

	CStudioHdr *pHdr = pEnt->GetModelPtr();
	m_iNumPoseParams = pHdr ? pHdr->GetNumPoseParameters() : 0;

	pModelInstance = pEnt;
	return true;
}
void SEditModelRender::DestroyModel()
{
	if ( pModelInstance )
		pModelInstance->Remove();

	pModelInstance = NULL;
	m_szModelPath[0] = '\0';
	m_iNumPoseParams = 0;
}
void SEditModelRender::GetModelCenter( float *pFl3_ViewOffset )
{
	Q_memset( pFl3_ViewOffset, 0, sizeof(float) * 3 );
	if ( IsModelReady() )
	{
		MDLCACHE_CRITICAL_SECTION();
		if ( pModelInstance->GetModelPtr() )
		{
			const Vector &vecMin = pModelInstance->GetModelPtr()->hull_min();
			const Vector &vecMax = pModelInstance->GetModelPtr()->hull_max();
			Vector vecPos = ( vecMin + ( vecMax - vecMin ) * 0.5f );
			if ( pFl3_ViewOffset )
				Q_memcpy( pFl3_ViewOffset, vecPos.Base(), sizeof(float) * 3 );
		}
	}
}
void SEditModelRender::DestroyCharPtrList( char ***szList )
{
	Assert( szList );
	if ( *szList )
	{
		delete [] (**szList);
		delete [] (*szList);
		*szList = NULL;
	}
}

int SequenceSort( mstudioseqdesc_t *const *seq1, mstudioseqdesc_t *const *seq2 )
{
	return Q_stricmp( ( *seq1 )->pszLabel(), ( *seq2 )->pszLabel() );
}
int SEditModelRender::QuerySequences( char ***list )
{
	if ( !IsModelReady() )
		return 0;

	MDLCACHE_CRITICAL_SECTION();
	CStudioHdr *pHdr = pModelInstance->GetModelPtr();
	if ( !pHdr )
		return 0;

	CUtlVector< mstudioseqdesc_t* >hSeqs;
	for ( int i = 0; i < pHdr->GetNumSeq(); i++ )
		if ( !( pHdr->pSeqdesc( i ).flags & STUDIO_HIDDEN ) )
			hSeqs.AddToTail( &pHdr->pSeqdesc( i ) );

	int numSequences = hSeqs.Count();

	if ( !numSequences )
		return 0;

	hSeqs.Sort( SequenceSort );

	CUtlVector< const char* >hNameList;
	for ( int i = 0; i < numSequences; i++ )
	{
		const char *seqName = NULL;
		const mstudioseqdesc_t &seqPtr = *hSeqs[ i ];
		if ( seqPtr.pszLabel() )
			seqName = seqPtr.pszLabel();
		else
			seqName = "Unknown Sequence";

		hNameList.AddToTail( seqName );
	}

	*list = new char*[numSequences];

	int iTotalLength = 0;
	for ( int i = 0; i < numSequences; i++ )
		iTotalLength += Q_strlen( hNameList[i] ) + 1;

	**list = new char[ iTotalLength ];

	int curpos = 0;
	for ( int i = 0; i < numSequences; i++ )
	{
		int curLength = Q_strlen( hNameList[i] ) + 1;
		(*list)[ i ] = **list + curpos;
		Q_strcpy( (*list)[ i ], hNameList[i] );
		curpos += curLength;
	}

	hNameList.Purge();
	hSeqs.Purge();
	return numSequences;
}
void SEditModelRender::SetSequence( const char *name )
{
	if ( !IsModelReady() )
		return;

	MDLCACHE_CRITICAL_SECTION();
	pModelInstance->ResetSequence( pModelInstance->LookupSequence( name ) );
}
void SEditModelRender::ExecRender()
{
	if ( !IsModelReady() )
		return;

	MDLCACHE_CRITICAL_SECTION();
	for ( int i = 0; i < m_iNumPoseParams; i++ )
		pModelInstance->SetPoseParameter( i, 0 );

#if SWARM_DLL
	RenderableInstance_t instance;
	instance.m_nAlpha = 255;
#endif
	pModelInstance->DrawModel( STUDIO_RENDER
#if SWARM_DLL
		, instance
#endif
		);
}
void SEditModelRender::DoPostProc( int x, int y, int w, int h )
{
	if ( view && view->GetPlayerViewSetup()->m_bDoBloomAndToneMapping )
		DoEnginePostProcessing( x, y, w, h, false, false );
}
int SEditModelRender::MaterialPicker( char ***szMat )
{
	int mx, my;
	vgui::input()->GetCursorPosition( mx, my );

	Vector ray;
	const CViewSetup *pViewSetup = view->GetPlayerViewSetup();
	float ratio =engine->GetScreenAspectRatio(
#if SWARM_DLL
		pViewSetup->width, pViewSetup->height
#endif
		);

	ratio = ( 1.0f / ratio ) * (4.0f/3.0f);
	float flFov = ScaleFOVByWidthRatio( pViewSetup->fov, ratio );
	ScreenToWorld( mx, my, flFov, pViewSetup->origin, pViewSetup->angles, ray );

	Vector start = pViewSetup->origin;
	Vector end = start + ray * MAX_TRACE_LENGTH;
	trace_t tr;
	C_BaseEntity *pIgnore = input->CAM_IsThirdPerson() ? NULL : C_BasePlayer::GetLocalPlayer();
	UTIL_TraceLine( start, end, MASK_SOLID, pIgnore, COLLISION_GROUP_NONE, &tr );

	if ( !tr.DidHit() )
		return 0;

	int numMaterials = 0;
	IMaterial **MatList = NULL;
	studiohdr_t *pSHdr = NULL;

	if ( tr.DidHitWorld() )
	{
		if ( tr.hitbox == 0 )
		{
			Vector dummy;
			IMaterial *pMat = engine->TraceLineMaterialAndLighting( start, end, dummy, dummy );
			if ( pMat )
			{
				numMaterials = 1;
				MatList = new IMaterial*[1];
				MatList[0] = pMat;
			}
		}
		else
		{
			ICollideable *prop = staticpropmgr->GetStaticPropByIndex( tr.hitbox - 1 );
			if ( prop )
			{
				IClientRenderable *pRenderProp = prop->GetIClientUnknown()->GetClientRenderable();
				if ( pRenderProp )
				{
					const model_t *pModel = pRenderProp->GetModel();
					if ( pModel )
						pSHdr = modelinfo->GetStudiomodel( pModel );
				}
			}
		}
	}
	else if ( tr.m_pEnt )
	{
		const model_t *pModel = tr.m_pEnt->GetModel();
		if ( pModel )
			pSHdr = modelinfo->GetStudiomodel( pModel );
	}

	if ( pSHdr )
	{
		Assert( !numMaterials && !MatList );
		numMaterials = pSHdr->numtextures;
		const int numPaths = pSHdr->numcdtextures;

		if ( numMaterials )
		{
			CUtlVector< IMaterial* >hValidMaterials;
			for ( int i = 0; i < numMaterials; i++ )
			{
				mstudiotexture_t *pStudioTex = pSHdr->pTexture( i );
				const char *matName = pStudioTex->pszName();

				for ( int p = 0; p < numPaths; p++ )
				{
					char tmpPath[MAX_PATH];
					Q_snprintf( tmpPath, MAX_PATH, "%s%s\0", pSHdr->pCdtexture( p ), matName );
					Q_FixSlashes( tmpPath );
					IMaterial *pTempMat = materials->FindMaterial( tmpPath, TEXTURE_GROUP_MODEL );
					if ( !IsErrorMaterial( pTempMat ) )
					{
						hValidMaterials.AddToTail( pTempMat );
						break;
					}
				}
			}

			numMaterials = hValidMaterials.Count();
			if ( numMaterials )
			{
				MatList = new IMaterial*[ numMaterials ];
				for ( int i = 0; i < numMaterials; i++ )
					MatList[i] = hValidMaterials[i];
			}

			hValidMaterials.Purge();
		}
	}

	*szMat = new char*[ numMaterials ];

	int iTotalLength = 0;
	for ( int i = 0; i < numMaterials; i++ )
		iTotalLength += Q_strlen( MatList[i]->GetName() ) + 1;

	**szMat = new char[ iTotalLength ];

	int curpos = 0;
	for ( int i = 0; i < numMaterials; i++ )
	{
		const char *pszName = MatList[i]->GetName();

		int curLength = Q_strlen( pszName ) + 1;
		(*szMat)[ i ] = **szMat + curpos;
		Q_strcpy( (*szMat)[ i ], pszName );
		curpos += curLength;
	}

	if ( MatList )
		delete [] MatList;

	return numMaterials;
}