csgo/cstrike15_src/utils/hlfaceposer/expression.cpp

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include "hlfaceposer.h"
#include <mxtk/mx.h>
#include "expressions.h"
#include "StudioModel.h"
#include "filesystem.h"
#include "viewersettings.h"
#include "matsyswin.h"
#include "checksum_crc.h"
#include "expclass.h"
#include "ControlPanel.h"
#include "faceposer_models.h"
#include "mdlviewer.h"

static int g_counter = 0;

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExpression::CExpression( void )
{
	name[ 0 ] = 0;
	index = 0;
	description[ 0 ] = 0;
	memset( setting, 0, sizeof( setting ) );

	for ( int i = 0; i < MAX_FP_MODELS; i++ )
	{
		m_Bitmap[ i ].valid = false;
	}

	m_nUndoCurrent = 0;
	m_bModified = false;

	m_bSelected = false;

	m_bDirty = false;

	expressionclass[ 0 ] = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Copy constructor
// Input  : from - 
//-----------------------------------------------------------------------------
CExpression::CExpression( const CExpression& from )
{
	int i;

	strcpy( name, from.name );
	index = from.index;
	strcpy( description, from.description );
	
	for ( i = 0; i < MAX_FP_MODELS; i++ )
	{
		m_Bitmap[ i ] = from.m_Bitmap[ i ];
	}

	m_bModified = from.m_bModified;

	for ( i = 0 ; i < from.undo.Count(); i++ )
	{
		CExpUndoInfo *newUndo = new CExpUndoInfo();
		*newUndo = *from.undo[ i ];
		undo.AddToTail( newUndo );
	}

	m_nUndoCurrent = from.m_nUndoCurrent;

	m_bSelected = from.m_bSelected;

	m_bDirty = from.m_bDirty;

	strcpy( expressionclass, from.expressionclass );

	memcpy( setting, from.setting, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memcpy( weight, from.weight, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExpression::~CExpression( void )
{
	ResetUndo();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CExpression::GetDirty( void )
{
	return m_bDirty;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dirty - 
//-----------------------------------------------------------------------------
void CExpression::SetDirty( bool dirty )
{
	m_bDirty = dirty;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float *CExpression::GetSettings( void )
{
	return setting;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float *CExpression::GetWeights( void )
{
	return weight;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mod - 
//-----------------------------------------------------------------------------
void CExpression::SetModified( bool mod )
{
	m_bModified = mod;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CExpression::GetModified( void )
{
	return m_bModified;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : selected - 
//-----------------------------------------------------------------------------
void CExpression::SetSelected( bool selected )
{
	m_bSelected = selected;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CExpression::GetSelected( void )
{
	return m_bSelected;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpression::ResetUndo( void )
{
	CExpUndoInfo *u;
	for ( int i = 0; i < undo.Count(); i++ )
	{
		u = undo[ i ];
		delete u;
	}

	undo.RemoveAll();
	m_nUndoCurrent = 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CExpression::CanRedo( void )
{
	if ( !undo.Count() )
		return false;

	if ( m_nUndoCurrent == 0 )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CExpression::CanUndo( void )
{
	if ( !undo.Count() )
		return false;

	if ( m_nUndoCurrent >= undo.Count() )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CExpression::UndoLevels( void )
{
	return undo.Count();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int CExpression::UndoCurrent( void )
{
	return m_nUndoCurrent;
}

void ChecksumFlexControllers( bool bSpew, char const *name, CRC32_t &crc, const float *settings, const float *weights );

CRC32_t	CExpression::GetBitmapCRC()
{
	CRC32_t crc;

	float *s = setting;
	float *w = weight;

	// Note, we'll use the pristine values if this has changed
	if ( undo.Count() >= 1 )
	{
		s = undo[ undo.Count() - 1 ]->setting;
		w = undo[ undo.Count() - 1 ]->weight;
	}

	// This walks the global controllers sorted by name and only includes values with a setting or value which is != 0.0f

	ChecksumFlexControllers( false, name, crc, s, w );

	return crc;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : const char
//-----------------------------------------------------------------------------
const char *CExpression::GetBitmapCheckSum()
{
	CRC32_t crc = GetBitmapCRC();	

	// Create string name out of binary data
	static char hex[ 9 ];
	Q_binarytohex( (byte *)&crc, sizeof( crc ), hex, sizeof( hex ) );
	return hex;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : const char
//-----------------------------------------------------------------------------
const char *CExpression::GetBitmapFilename( int modelindex )
{
	static char filename[ 256 ] = { 0 };
	
	char const *classname = "error";
	CExpClass *cl = GetExpressionClass();
	if ( cl )
	{
		classname = cl->GetBaseName();
	}
	
	char modelName[512], modelNameTemp[512];
	Q_strncpy( modelNameTemp, models->GetModelName( modelindex ), sizeof( modelNameTemp ) );

	char const *in = modelNameTemp;
	char *out = modelName;

	while ( *in )
	{
		if ( V_isalnum( *in ) ||
			*in == '_' || 
			*in == '\\' || 
			*in == '/' ||
			*in == '.' ||
			*in == ':' )
		{
			*out++ = *in;
		}
		in++;
	}
	*out = 0;


	sprintf( filename, "expressions/%s/%s/%s.bmp", modelName, classname, GetBitmapCheckSum() );

	Q_FixSlashes( filename );
	strlwr( filename );

	CreatePath( filename );
	
	return filename;
}

void CExpression::CreateNewBitmap( int modelindex )
{
	MatSysWindow *pWnd = g_pMatSysWindow;
	if ( !pWnd ) 
		return;

	StudioModel *model = models->GetStudioModel( modelindex );
	if ( !model )
		return;

	CStudioHdr *hdr = models->GetStudioHeader( modelindex );
	if ( !hdr )
		return;

	char filename[ 256 ];
	strcpy( filename, GetBitmapFilename( modelindex ) );
	if ( !Q_strstr( filename, ".bmp" ) )
		return;

	models->CreateNewBitmap( modelindex, filename, 0, 128, true, this, &m_Bitmap[ modelindex ] );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *exp - 
//-----------------------------------------------------------------------------
void CExpression::PushUndoInformation( void )
{
	SetModified( true );

	// A real change to the data wipes out the redo counters
	WipeRedoInformation();

	CExpUndoInfo *newundo = new CExpUndoInfo;

	memcpy( newundo->setting, setting, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memset( newundo->redosetting, 0, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memcpy( newundo->weight, weight, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memset( newundo->redoweight, 0, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );

	newundo->counter = g_counter++;

	undo.AddToHead( newundo );

	Assert( m_nUndoCurrent == 0 );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *exp - 
//-----------------------------------------------------------------------------
void CExpression::PushRedoInformation( void )
{
	Assert( undo.Count() >= 1 );

	CExpUndoInfo *redo = undo[ 0 ];
	memcpy( redo->redosetting, setting, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memcpy( redo->redoweight, weight, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *exp - 
//-----------------------------------------------------------------------------
void CExpression::Undo( void )
{
	if ( !CanUndo() )
		return;

	Assert( m_nUndoCurrent < undo.Count() );

	CExpUndoInfo *u = undo[ m_nUndoCurrent++ ];
	Assert( u );
	
	memcpy( setting, u->setting, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memcpy( weight, u->weight, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *exp - 
//-----------------------------------------------------------------------------
void CExpression::Redo( void )
{
	if ( !CanRedo() )
		return;

	Assert( m_nUndoCurrent >= 1 );
	Assert( m_nUndoCurrent <= undo.Count() );

	CExpUndoInfo *u = undo[ --m_nUndoCurrent ];
	Assert( u );
	
	memcpy( setting, u->redosetting, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memcpy( weight, u->redoweight, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *exp - 
//-----------------------------------------------------------------------------
void CExpression::WipeRedoInformation( void )
{
	// Wipe out all stuff newer then m_nUndoCurrent
	int level = 0;
	while ( level < m_nUndoCurrent )
	{
		CExpUndoInfo *u = undo[ 0 ];
		undo.Remove( 0 );
		Assert( u );
		delete u;
		level++;
	}

	m_nUndoCurrent = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Revert to last saved state
//-----------------------------------------------------------------------------
void CExpression::Revert( void )
{
	SetDirty( false );

	if ( undo.Count() <= 0 )
		return;

	// Go back to original data
	CExpUndoInfo *u = undo[ undo.Count() - 1 ];
	Assert( u );

	memcpy( setting, u->setting, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );
	memcpy( weight, u->weight, GLOBAL_STUDIO_FLEX_CONTROL_COUNT * sizeof( float ) );

	ResetUndo();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : CExpClass
//-----------------------------------------------------------------------------
CExpClass *CExpression::GetExpressionClass( void )
{
	CExpClass *cl = expressions->FindClass( expressionclass, false );
	if ( !cl )
	{
		Assert( cl );
	}
	return cl;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *classname - 
//-----------------------------------------------------------------------------
void CExpression::SetExpressionClass( char const *classname )
{
	strcpy( expressionclass, classname );
}