d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
source-engine/utils/studiomdl/studiomdl.cpp

10448 lines
246 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
//
// studiomdl.c: generates a studio .mdl file from a .qc script
// models/<scriptname>.mdl.
//
#pragma warning( disable : 4244 )
#pragma warning( disable : 4237 )
#pragma warning( disable : 4305 )
#include <windows.h>
#undef GetCurrentDirectory
#include <Shlwapi.h> // PathCanonicalize
#pragma comment( lib, "shlwapi" )
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <math.h>
#include <direct.h>
#include "istudiorender.h"
#include "filesystem_tools.h"
#include "tier2/fileutils.h"
#include "cmdlib.h"
#include "scriplib.h"
#include "mathlib/mathlib.h"
#define EXTERN
#include "studio.h"
#include "studiomdl.h"
#include "collisionmodel.h"
#include "optimize.h"
#include "byteswap.h"
#include "studiobyteswap.h"
#include "tier1/strtools.h"
#include "bspflags.h"
#include "tier0/icommandline.h"
#include "utldict.h"
#include "tier1/utlsortvector.h"
#include "bitvec.h"
#include "appframework/appframework.h"
#include "datamodel/idatamodel.h"
#include "materialsystem/materialsystem_config.h"
#include "vstdlib/cvar.h"
#include "tier1/tier1.h"
#include "tier2/tier2.h"
#include "tier3/tier3.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "mdlobjects/dmeboneflexdriver.h"
#include "movieobjects/dmeanimationset.h"
#include "movieobjects/dmemdlmakefile.h"
#include "movieobjects/dmevertexdata.h"
#include "movieobjects/dmecombinationoperator.h"
#include "dmserializers/idmserializers.h"
#include "tier2/p4helpers.h"
#include "p4lib/ip4.h"
#include "mdllib/mdllib.h"
#include "perfstats.h"
#include "worldsize.h"
bool g_collapse_bones = false;
bool g_collapse_bones_aggressive = false;
bool g_quiet = false;
bool g_badCollide = false;
bool g_IHVTest = false;
bool g_bCheckLengths = false;
bool g_bPrintBones = false;
bool g_bPerf = false;
bool g_bDumpGraph = false;
bool g_bMultistageGraph = false;
bool g_verbose = false;
bool g_bCreateMakefile = false;
bool g_bHasModelName = false;
bool g_bZBrush = false;
bool g_bVerifyOnly = false;
bool g_bUseBoneInBBox = true;
bool g_bLockBoneLengths = false;
bool g_bOverridePreDefinedBones = false;
int g_minLod = 0;
int g_numAllowedRootLODs = 0;
bool g_bNoWarnings = false;
int g_maxWarnings = -1;
bool g_bX360 = false;
bool g_bBuildPreview = false;
bool g_bCenterBonesOnVerts = false;
bool g_bDumpMaterials = false;
bool g_bStripLods = false;
bool g_bMakeVsi = false;
float g_flDefaultMotionRollback = 0.3f;
int g_minSectionFrameLimit = 120;
int g_sectionFrames = 30;
bool g_bNoAnimblockStall = false;
char g_path[MAX_PATH];
Vector g_vecMinWorldspace = Vector( MIN_COORD_INTEGER, MIN_COORD_INTEGER, MIN_COORD_INTEGER );
Vector g_vecMaxWorldspace = Vector( MAX_COORD_INTEGER, MAX_COORD_INTEGER, MAX_COORD_INTEGER );
DmElementHandle_t g_hDmeBoneFlexDriverList = DMELEMENT_HANDLE_INVALID;
enum RunMode
{
RUN_MODE_BUILD,
RUN_MODE_STRIP_MODEL,
RUN_MODE_STRIP_VHV
} g_eRunMode = RUN_MODE_BUILD;
bool g_bNoP4 = false;
CUtlVector< s_hitboxset > g_hitboxsets;
CUtlVector< char > g_KeyValueText;
CUtlVector<s_flexcontrollerremap_t> g_FlexControllerRemap;
CCheckUVCmd g_StudioMdlCheckUVCmd;
//-----------------------------------------------------------------------------
// Parsed data from a .qc or .dmx file
//-----------------------------------------------------------------------------
struct IKLock_t
{
CUtlString m_Name;
float m_flPosWeight;
float m_flLocalQWeight;
};
struct SequenceOption_t
{
bool m_bSnap : 1;
bool m_bIsDelta : 1;
bool m_bIsWorldSpace : 1;
bool m_bIsPost : 1;
bool m_bIsPreDelta : 1;
bool m_bIsAutoplay : 1;
bool m_bIsRealTime : 1;
bool m_bIsHidden : 1;
float m_flFadeInTime;
float m_flFadeOutTime;
int m_nBlendWidth;
CUtlVector< CUtlString > m_AutoLayers;
CUtlVector< IKLock_t > m_IKLocks;
};
struct CmdSequence_t
{
CUtlString m_Name;
CUtlString m_FileName;
SequenceOption_t m_Options;
};
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
void AddBodyFlexData( s_source_t *pSource, int imodel );
void AddBodyAttachments( s_source_t *pSource );
void AddBodyFlexRules( s_source_t *pSource );
//-----------------------------------------------------------------------------
// Stuff for writing a makefile to build models incrementally.
//-----------------------------------------------------------------------------
CUtlVector<CUtlSymbol> m_CreateMakefileDependencies;
void CreateMakefile_AddDependency( const char *pFileName )
{
EnsureDependencyFileCheckedIn( pFileName );
if( !g_bCreateMakefile )
{
return;
}
CUtlSymbol sym( pFileName );
int i;
for( i = 0; i < m_CreateMakefileDependencies.Count(); i++ )
{
if( m_CreateMakefileDependencies[i] == sym )
{
return;
}
}
m_CreateMakefileDependencies.AddToTail( sym );
}
void EnsureDependencyFileCheckedIn( const char *pFileName )
{
// Early out: if no p4
if ( g_bNoP4 )
return;
char pFullPath[MAX_PATH];
if ( !GetGlobalFilePath( pFileName, pFullPath, sizeof(pFullPath) ) )
{
MdlWarning( "Model dependency file '%s' is missing.\n", pFileName );
return;
}
Q_FixSlashes( pFullPath );
char bufCanonicalPath[ MAX_PATH ] = {0};
PathCanonicalize( bufCanonicalPath, pFullPath );
CP4AutoAddFile p4_add_dep_file( bufCanonicalPath );
}
void StudioMdl_ScriptLoadedCallback( char const *pFilenameLoaded, char const *pIncludedFromFileName, int nIncludeLineNumber )
{
EnsureDependencyFileCheckedIn( pFilenameLoaded );
}
void CreateMakefile_OutputMakefile( void )
{
if( !g_bHasModelName )
{
MdlError( "Can't write makefile since a target mdl hasn't been specified!" );
}
FILE *fp = fopen( "makefile.tmp", "a" );
if( !fp )
{
MdlError( "can't open makefile.tmp!\n" );
}
char mdlname[MAX_PATH];
V_strcpy_safe( mdlname, gamedir );
// if( *g_pPlatformName )
// {
// V_strcat_safe( mdlname, "platform_" );
// V_strcat_safe( mdlname, g_pPlatformName );
// V_strcat_safe( mdlname, "/" );
// }
V_strcat_safe( mdlname, "models/" );
V_strcat_safe( mdlname, outname );
Q_StripExtension( mdlname, mdlname, sizeof( mdlname ) );
V_strcat_safe( mdlname, ".mdl" );
Q_FixSlashes( mdlname );
fprintf( fp, "%s:", mdlname );
int i;
for( i = 0; i < m_CreateMakefileDependencies.Count(); i++ )
{
fprintf( fp, " %s", m_CreateMakefileDependencies[i].String() );
}
fprintf( fp, "\n" );
char mkdirpath[MAX_PATH];
V_strcpy_safe( mkdirpath, mdlname );
Q_StripFilename( mkdirpath );
fprintf( fp, "\tmkdir \"%s\"\n", mkdirpath );
fprintf( fp, "\t%s -quiet %s\n\n", CommandLine()->GetParm( 0 ), fullpath );
fclose( fp );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool g_bFirstWarning = true;
void TokenError( const char *fmt, ... )
{
static char output[1024];
va_list args;
char *pFilename;
int iLineNumber;
if (GetTokenizerStatus( &pFilename, &iLineNumber ))
{
va_start( args, fmt );
vsprintf( output, fmt, args );
MdlError( "%s(%d): - %s", pFilename, iLineNumber, output );
}
else
{
va_start( args, fmt );
vsprintf( output, fmt, args );
MdlError( "%s", output );
}
}
void MdlError( const char *fmt, ... )
{
static char output[1024];
static char *knownExtensions[] = {".mdl", ".ani", ".phy", ".sw.vtx", ".dx80.vtx", ".dx90.vtx", ".vvd"};
char fileName[MAX_PATH];
char baseName[MAX_PATH];
va_list args;
Assert( 0 );
if (g_quiet)
{
if (g_bFirstWarning)
{
printf("%s :\n", fullpath );
g_bFirstWarning = false;
}
printf("\t");
}
printf("ERROR: ");
va_start( args, fmt );
vprintf( fmt, args );
// delete premature files
// unforunately, content is built without verification
// ensuring that targets are not available, prevents check-in
if (g_bHasModelName)
{
// undescriptive errors in batch processes could be anonymous
printf("ERROR: Aborted Processing on '%s'\n", outname);
V_strcpy_safe( fileName, gamedir );
V_strcat_safe( fileName, "models/" );
V_strcat_safe( fileName, outname );
Q_FixSlashes( fileName );
Q_StripExtension( fileName, baseName, sizeof( baseName ) );
for (int i=0; i<ARRAYSIZE(knownExtensions); i++)
{
V_strcpy_safe( fileName, baseName);
V_strcat_safe( fileName, knownExtensions[i] );
// really need filesystem concept here
// g_pFileSystem->RemoveFile( fileName );
unlink( fileName );
}
}
exit( -1 );
}
void MdlWarning( const char *fmt, ... )
{
va_list args;
static char output[1024];
if (g_bNoWarnings || g_maxWarnings == 0)
return;
WORD old = SetConsoleTextColor( 1, 1, 0, 1 );
if (g_quiet)
{
if (g_bFirstWarning)
{
printf("%s :\n", fullpath );
g_bFirstWarning = false;
}
printf("\t");
}
Assert( 0 );
printf("WARNING: ");
va_start( args, fmt );
vprintf( fmt, args );
if (g_maxWarnings > 0)
g_maxWarnings--;
if (g_maxWarnings == 0)
{
if (g_quiet)
{
printf("\t");
}
printf("suppressing further warnings...\n");
}
RestoreConsoleTextColor( old );
}
SpewRetval_t MdlSpewOutputFunc( SpewType_t type, char const *pMsg )
{
if ((( type == SPEW_MESSAGE ) || (type == SPEW_LOG )) && g_quiet)
{
// suppress
}
else if (type == SPEW_WARNING)
{
MdlWarning( "%s", pMsg );
}
else
{
return CmdLib_SpewOutputFunc( type, pMsg );
}
return SPEW_CONTINUE;
}
#ifndef _DEBUG
void MdlHandleCrash( const char *pMessage, bool bAssert )
{
static LONG crashHandlerCount = 0;
if ( InterlockedIncrement( &crashHandlerCount ) == 1 )
{
MdlError( "'%s' (assert: %d)\n", pMessage, bAssert );
}
InterlockedDecrement( &crashHandlerCount );
}
// This is called if we crash inside our crash handler. It just terminates the process immediately.
LONG __stdcall MdlSecondExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo )
{
TerminateProcess( GetCurrentProcess(), 2 );
return EXCEPTION_EXECUTE_HANDLER; // (never gets here anyway)
}
void MdlExceptionFilter( unsigned long code )
{
// This is called if we crash inside our crash handler. It just terminates the process immediately.
SetUnhandledExceptionFilter( MdlSecondExceptionFilter );
//DWORD code = ExceptionInfo->ExceptionRecord->ExceptionCode;
#define ERR_RECORD( name ) { name, #name }
struct
{
int code;
char *pReason;
} errors[] =
{
ERR_RECORD( EXCEPTION_ACCESS_VIOLATION ),
ERR_RECORD( EXCEPTION_ARRAY_BOUNDS_EXCEEDED ),
ERR_RECORD( EXCEPTION_BREAKPOINT ),
ERR_RECORD( EXCEPTION_DATATYPE_MISALIGNMENT ),
ERR_RECORD( EXCEPTION_FLT_DENORMAL_OPERAND ),
ERR_RECORD( EXCEPTION_FLT_DIVIDE_BY_ZERO ),
ERR_RECORD( EXCEPTION_FLT_INEXACT_RESULT ),
ERR_RECORD( EXCEPTION_FLT_INVALID_OPERATION ),
ERR_RECORD( EXCEPTION_FLT_OVERFLOW ),
ERR_RECORD( EXCEPTION_FLT_STACK_CHECK ),
ERR_RECORD( EXCEPTION_FLT_UNDERFLOW ),
ERR_RECORD( EXCEPTION_ILLEGAL_INSTRUCTION ),
ERR_RECORD( EXCEPTION_IN_PAGE_ERROR ),
ERR_RECORD( EXCEPTION_INT_DIVIDE_BY_ZERO ),
ERR_RECORD( EXCEPTION_INT_OVERFLOW ),
ERR_RECORD( EXCEPTION_INVALID_DISPOSITION ),
ERR_RECORD( EXCEPTION_NONCONTINUABLE_EXCEPTION ),
ERR_RECORD( EXCEPTION_PRIV_INSTRUCTION ),
ERR_RECORD( EXCEPTION_SINGLE_STEP ),
ERR_RECORD( EXCEPTION_STACK_OVERFLOW ),
ERR_RECORD( EXCEPTION_ACCESS_VIOLATION ),
};
int nErrors = sizeof( errors ) / sizeof( errors[0] );
{
int i;
for ( i=0; i < nErrors; i++ )
{
if ( errors[i].code == code )
MdlHandleCrash( errors[i].pReason, true );
}
if ( i == nErrors )
{
MdlHandleCrash( "Unknown reason", true );
}
}
TerminateProcess( GetCurrentProcess(), 1 );
}
#endif
/*
=================
=================
*/
int k_memtotal;
void *kalloc( int num, int size )
{
// printf( "calloc( %d, %d )\n", num, size );
// printf( "%d ", num * size );
int nMemSize = num * size;
k_memtotal += nMemSize;
// ensure memory alignment on maximum of ALIGN
nMemSize += 511;
void *ptr = malloc( nMemSize );
memset( ptr, 0, nMemSize );
ptr = (byte *)((int)((byte *)ptr + 511) & ~511);
return ptr;
}
void kmemset( void *ptr, int value, int size )
{
// printf( "kmemset( %x, %d, %d )\n", ptr, value, size );
memset( ptr, value, size );
return;
}
int verify_atoi( const char *token )
{
if (token[0] != '-' && (token[0] < '0' || token[0] > '9'))
{
TokenError( "expecting number, got \"%s\"\n", token );
}
return atoi( token );
}
float verify_atof( const char *token )
{
if (token[0] != '-' && token[0] != '.' && (token[0] < '0' || token[0] > '9'))
{
TokenError( "expecting number, got \"%s\"\n", token );
}
return atof( token );
}
float verify_atof_with_null( const char *token )
{
if (strcmp( token, ".." ) == 0)
return -1;
if (token[0] != '-' && token[0] != '.' && (token[0] < '0' || token[0] > '9'))
{
TokenError( "expecting number, got \"%s\"\n", token );
}
return atof( token );
}
//-----------------------------------------------------------------------------
// Key value block
//-----------------------------------------------------------------------------
static void AppendKeyValueText( CUtlVector< char > *pKeyValue, const char *pString )
{
int nLen = strlen(pString);
int nFirst = pKeyValue->AddMultipleToTail( nLen );
memcpy( pKeyValue->Base() + nFirst, pString, nLen );
}
int KeyValueTextSize( CUtlVector< char > *pKeyValue )
{
return pKeyValue->Count();
}
const char *KeyValueText( CUtlVector< char > *pKeyValue )
{
return pKeyValue->Base();
}
void Option_KeyValues( CUtlVector< char > *pKeyValue );
//-----------------------------------------------------------------------------
// Read global input into common string
//-----------------------------------------------------------------------------
bool GetLineInput( void )
{
while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL)
{
g_iLinecount++;
// skip comments
if (g_szLine[0] == '/' && g_szLine[1] == '/')
continue;
return true;
}
return false;
}
/*
=================
=================
*/
int lookupControl( char *string )
{
if (stricmp(string,"X")==0) return STUDIO_X;
if (stricmp(string,"Y")==0) return STUDIO_Y;
if (stricmp(string,"Z")==0) return STUDIO_Z;
if (stricmp(string,"XR")==0) return STUDIO_XR;
if (stricmp(string,"YR")==0) return STUDIO_YR;
if (stricmp(string,"ZR")==0) return STUDIO_ZR;
if (stricmp(string,"LX")==0) return STUDIO_LX;
if (stricmp(string,"LY")==0) return STUDIO_LY;
if (stricmp(string,"LZ")==0) return STUDIO_LZ;
if (stricmp(string,"LXR")==0) return STUDIO_LXR;
if (stricmp(string,"LYR")==0) return STUDIO_LYR;
if (stricmp(string,"LZR")==0) return STUDIO_LZR;
if (stricmp(string,"LM")==0) return STUDIO_LINEAR;
if (stricmp(string,"LQ")==0) return STUDIO_QUADRATIC_MOTION;
return -1;
}
/*
=================
=================
*/
int LookupPoseParameter( char *name )
{
int i;
for ( i = 0; i < g_numposeparameters; i++)
{
if (!stricmp( name, g_pose[i].name))
{
return i;
}
}
V_strcpy_safe( g_pose[i].name, name );
g_numposeparameters = i + 1;
if (g_numposeparameters > MAXSTUDIOPOSEPARAM)
{
TokenError( "too many pose parameters (max %d)\n", MAXSTUDIOPOSEPARAM );
}
return i;
}
//-----------------------------------------------------------------------------
// Stuff for writing a makefile to build models incrementally.
//-----------------------------------------------------------------------------
s_sourceanim_t *FindSourceAnim( s_source_t *pSource, const char *pAnimName )
{
int nCount = pSource->m_Animations.Count();
for ( int i = 0; i < nCount; ++i )
{
s_sourceanim_t *pAnim = &pSource->m_Animations[i];
if ( !Q_stricmp( pAnimName, pAnim->animationname ) )
return pAnim;
}
return NULL;
}
const s_sourceanim_t *FindSourceAnim( const s_source_t *pSource, const char *pAnimName )
{
if ( !pAnimName[0] )
return NULL;
int nCount = pSource->m_Animations.Count();
for ( int i = 0; i < nCount; ++i )
{
const s_sourceanim_t *pAnim = &pSource->m_Animations[i];
if ( !Q_stricmp( pAnimName, pAnim->animationname ) )
return pAnim;
}
return NULL;
}
s_sourceanim_t *FindOrAddSourceAnim( s_source_t *pSource, const char *pAnimName )
{
if ( !pAnimName[0] )
return NULL;
int nCount = pSource->m_Animations.Count();
for ( int i = 0; i < nCount; ++i )
{
s_sourceanim_t *pAnim = &pSource->m_Animations[i];
if ( !Q_stricmp( pAnimName, pAnim->animationname ) )
return pAnim;
}
int nIndex = pSource->m_Animations.AddToTail();
s_sourceanim_t *pAnim = &pSource->m_Animations[nIndex];
memset( pAnim, 0, sizeof(s_sourceanim_t) );
Q_strncpy( pAnim->animationname, pAnimName, sizeof(pAnim->animationname) );
return pAnim;
}
//-----------------------------------------------------------------------------
// Purpose: Handle the $boneflexdriver command
// QC: $boneflexdriver <bone name> <tx|ty|tz> <flex controller name> <min> <max>
//-----------------------------------------------------------------------------
void Cmd_BoneFlexDriver()
{
CDisableUndoScopeGuard undoDisable; // Turn of Dme undo
// Find or create the DmeBoneFlexDriverList
CDmeBoneFlexDriverList *pDmeBoneFlexDriverList = GetElement< CDmeBoneFlexDriverList >( g_hDmeBoneFlexDriverList );
if ( !pDmeBoneFlexDriverList )
{
pDmeBoneFlexDriverList = CreateElement< CDmeBoneFlexDriverList >( "boneDriverFlexList", DMFILEID_INVALID );
if ( pDmeBoneFlexDriverList )
{
g_hDmeBoneFlexDriverList = pDmeBoneFlexDriverList->GetHandle();
}
}
if ( !pDmeBoneFlexDriverList )
{
MdlError( "%s: Couldn't find or create DmeBoneDriverFlexList\n", "$boneflexdriver" );
return;
}
// <bone name>
GetToken( false );
CDmeBoneFlexDriver *pDmeBoneFlexDriver = pDmeBoneFlexDriverList->FindOrCreateBoneFlexDriver( token );
if ( !pDmeBoneFlexDriver )
{
MdlError( "%s: Couldn't find or create DmeBoneFlexDriver for bone \"%s\"\n", "$boneflexdriver", token );
return;
}
// <tx|ty|tz|rx|ry|rz>
GetToken( false );
const char *ppszComponentTypeList[] = { "tx", "ty", "tz" };
int nBoneComponent = -1;
for ( int i = 0; i < ARRAYSIZE( ppszComponentTypeList ); ++i )
{
if ( StringHasPrefix( token, ppszComponentTypeList[i] ) )
{
nBoneComponent = i;
break;
}
}
if ( nBoneComponent < STUDIO_BONE_FLEX_TX || nBoneComponent > STUDIO_BONE_FLEX_TZ )
{
TokenError( "%s: Invalid bone component, must be one of <tx|ty|tz>\n", "$boneflexdriver" );
return;
}
// <flex controller name>
GetToken( false );
CDmeBoneFlexDriverControl *pDmeBoneFlexDriverControl = pDmeBoneFlexDriver->FindOrCreateControl( token );
if ( !pDmeBoneFlexDriverControl )
{
MdlError( "%s: Couldn't find or create DmeBoneFlexDriverControl for bone \"%s\"\n", "$boneflexdriver", token );
return;
}
pDmeBoneFlexDriverControl->m_nBoneComponent = nBoneComponent;
// <min>
GetToken( false );
pDmeBoneFlexDriverControl->m_flMin = verify_atof( token );
// <max>
GetToken( false );
pDmeBoneFlexDriverControl->m_flMax = verify_atof( token );
}
//-----------------------------------------------------------------------------
// Purpose: Handle the $checkuv command
// QC: $checkuv [0to1] [overlap] [inverse] [gutter <res> <min>]
//-----------------------------------------------------------------------------
void Cmd_CheckUV()
{
g_StudioMdlCheckUVCmd.ClearCheck( CCheckUVCmd::CHECK_UV_ALL_FLAGS );
while ( TokenAvailable() && GetToken( false ) )
{
if ( !V_stricmp( token, "0to1" ) )
{
g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_NORMALIZED );
}
else if ( !V_stricmp( token, "overlap" ) )
{
g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_OVERLAP );
}
else if ( !V_stricmp( token, "inverse" ) )
{
g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_INVERSE );
}
else if ( !V_stricmp( token, "gutter" ) )
{
g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_GUTTER );
if ( TokenAvailable() && GetToken( false ) )
{
if ( V_isdigit( *token ) )
{
const int nOptRes = V_atoi( token );
if ( nOptRes <= 0 )
{
MdlError( "$checkuv: Invalid resolution, \"%s\", for gutter check specified, must be > 0\n", token );
return;
}
g_StudioMdlCheckUVCmd.m_nOptGutterTexWidth = nOptRes;
g_StudioMdlCheckUVCmd.m_nOptGutterTexHeight = nOptRes;
if ( TokenAvailable() && GetToken( false ) )
{
if ( V_isdigit( *token ) )
{
const int nOptMin = V_atoi( token );
if ( nOptMin <= 0 )
{
MdlError( "$checkuv: Invalid minimum, \"%s\", for gutter check specified, must be > 0\n", token );
return;
}
g_StudioMdlCheckUVCmd.m_nOptGutterMin = nOptMin;
}
else
{
UnGetToken();
}
}
}
else
{
UnGetToken();
}
}
}
else
{
MdlError( "$checkuv: Unknown argument \"%s\", expected one of [ 0to1, overlap, inverse, gutter ]\n", token );
return;
}
}
if ( !g_StudioMdlCheckUVCmd.DoAnyCheck() )
{
g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_ALL_FLAGS );
}
}
void Cmd_PoseParameter( )
{
if ( g_numposeparameters >= MAXSTUDIOPOSEPARAM )
{
TokenError( "too many pose parameters (max %d)\n", MAXSTUDIOPOSEPARAM );
}
int i = LookupPoseParameter( token );
// name
GetToken (false);
V_strcpy_safe( g_pose[i].name, token );
if ( TokenAvailable() )
{
// min
GetToken (false);
g_pose[i].min = verify_atof (token);
}
if ( TokenAvailable() )
{
// max
GetToken (false);
g_pose[i].max = verify_atof (token);
}
while ( TokenAvailable() )
{
GetToken (false);
if ( !Q_stricmp( token, "wrap" ) )
{
g_pose[i].flags |= STUDIO_LOOPING;
g_pose[i].loop = g_pose[i].max - g_pose[i].min;
}
else if ( !Q_stricmp( token, "loop" ) )
{
g_pose[i].flags |= STUDIO_LOOPING;
GetToken (false);
g_pose[i].loop = verify_atof( token );
}
}
}
/*
=================
=================
*/
int LookupTexture( const char *pTextureName, bool bRelativePath )
{
char pTextureNoExt[MAX_PATH];
char pTextureBase[MAX_PATH];
char pTextureBase2[MAX_PATH];
Q_StripExtension( pTextureName, pTextureNoExt, sizeof(pTextureNoExt) );
Q_FileBase( pTextureName, pTextureBase, sizeof(pTextureBase) );
int nFlags = bRelativePath ? RELATIVE_TEXTURE_PATH_SPECIFIED : 0;
int i;
for ( i = 0; i < g_numtextures; i++ )
{
if ( g_texture[i].flags == nFlags )
{
if ( !Q_stricmp( pTextureNoExt, g_texture[i].name ) )
return i;
continue;
}
// Comparing relative vs non-relative
if ( bRelativePath )
{
if ( !Q_stricmp( pTextureBase, g_texture[i].name ) )
return i;
continue;
}
// Comparing non-relative vs relative
Q_FileBase( g_texture[i].name, pTextureBase2, sizeof(pTextureBase2) );
if ( !Q_stricmp( pTextureNoExt, pTextureBase2 ) )
return i;
}
if ( i >= MAXSTUDIOSKINS )
{
MdlError("Too many materials used, max %d\n", ( int )MAXSTUDIOSKINS );
}
Q_strncpy( g_texture[i].name, pTextureNoExt, sizeof(g_texture[i].name) );
g_texture[i].material = -1;
g_texture[i].flags = nFlags;
g_numtextures++;
return i;
}
void Cmd_RenameMaterial( void )
{
char from[256];
char to[256];
GetToken( false );
V_strcpy_safe( from, token );
GetToken( false );
V_strcpy_safe( to, token );
int i;
for (i = 0; i < g_numtextures; i++)
{
if (stricmp( g_texture[i].name, from ) == 0)
{
V_strcpy_safe( g_texture[i].name, to );
return;
}
}
MdlError( "unknown material \"%s\" in rename\n", from );
}
int UseTextureAsMaterial( int textureindex )
{
if ( g_texture[textureindex].material == -1 )
{
if (g_bDumpMaterials)
{
printf("material %d %d %s\n", textureindex, g_nummaterials, g_texture[textureindex].name );
}
g_material[g_nummaterials] = textureindex;
g_texture[textureindex].material = g_nummaterials++;
}
return g_texture[textureindex].material;
}
int MaterialToTexture( int material )
{
int i;
for (i = 0; i < g_numtextures; i++)
{
if (g_texture[i].material == material)
{
return i;
}
}
return -1;
}
//Wrong name for the use of it.
void scale_vertex( Vector &org )
{
org[0] = org[0] * g_currentscale;
org[1] = org[1] * g_currentscale;
org[2] = org[2] * g_currentscale;
}
void SetSkinValues( )
{
int i, j;
int index;
// Check all textures to see if we have relative paths specified
for (i = 0; i < g_numtextures; i++)
{
if ( g_texture[i].flags & RELATIVE_TEXTURE_PATH_SPECIFIED )
{
// Add an empty path to prepend if anything specifies a relative path
cdtextures[numcdtextures] = 0;
++numcdtextures;
break;
}
}
if ( numcdtextures == 0 )
{
char szName[MAX_PATH];
// strip down till it finds "models"
V_strcpy_safe( szName, fullpath );
while (szName[0] != '\0' && strnicmp( "models", szName, 6 ) != 0)
{
strcpy( &szName[0], &szName[1] );
}
if (szName[0] != '\0')
{
Q_StripFilename( szName );
V_strcat_safe( szName, "/" );
}
else
{
// if( *g_pPlatformName )
// {
// V_strcat_safe( szName, "platform_" );
// V_strcat_safe( szName, g_pPlatformName );
// V_strcat_safe( szName, "/" );
// }
V_strcpy_safe( szName, "models/" );
V_strcat_safe( szName, outname );
Q_StripExtension( szName, szName, sizeof( szName ) );
V_strcat_safe( szName, "/" );
}
cdtextures[0] = strdup( szName );
numcdtextures = 1;
}
for (i = 0; i < g_numtextures; i++)
{
char szName[256];
Q_StripExtension( g_texture[i].name, szName, sizeof( szName ) );
Q_strncpy( g_texture[i].name, szName, sizeof( g_texture[i].name ) );
}
// build texture groups
for (i = 0; i < MAXSTUDIOSKINS; i++)
{
for (j = 0; j < MAXSTUDIOSKINS; j++)
{
g_skinref[i][j] = j;
}
}
index = 0;
for (i = 0; i < g_numtexturelayers[0]; i++)
{
for (j = 0; j < g_numtexturereps[0]; j++)
{
g_skinref[i][g_texturegroup[0][0][j]] = g_texturegroup[0][i][j];
}
}
if (i != 0)
{
g_numskinfamilies = i;
}
else
{
g_numskinfamilies = 1;
}
g_numskinref = g_numtextures;
// printf ("width: %i height: %i\n",width, height);
/*
printf ("adjusted width: %i height: %i top : %i left: %i\n",
pmesh->skinwidth, pmesh->skinheight, pmesh->skintop, pmesh->skinleft );
*/
}
/*
=================
=================
*/
int LookupXNode( char *name )
{
int i;
for ( i = 1; i <= g_numxnodes; i++)
{
if (stricmp( name, g_xnodename[i] ) == 0)
{
return i;
}
}
g_xnodename[i] = strdup( name );
g_numxnodes = i;
return i;
}
/*
=================
=================
*/
char g_szFilename[1024];
FILE *g_fpInput;
char g_szLine[4096];
int g_iLinecount;
void Build_Reference( s_source_t *pSource, const char *pAnimName )
{
int i, parent;
Vector angle;
s_sourceanim_t *pReferenceAnim = FindSourceAnim( pSource, pAnimName );
for (i = 0; i < pSource->numbones; i++)
{
matrix3x4_t m;
if ( pReferenceAnim )
{
AngleMatrix( pReferenceAnim->rawanim[0][i].rot, m );
m[0][3] = pReferenceAnim->rawanim[0][i].pos[0];
m[1][3] = pReferenceAnim->rawanim[0][i].pos[1];
m[2][3] = pReferenceAnim->rawanim[0][i].pos[2];
}
else
{
SetIdentityMatrix( m );
}
parent = pSource->localBone[i].parent;
if (parent == -1)
{
// scale the done pos.
// calc rotational matrices
MatrixCopy( m, pSource->boneToPose[i] );
}
else
{
// calc compound rotational matrices
// FIXME : Hey, it's orthogical so inv(A) == transpose(A)
Assert( parent < i );
ConcatTransforms( pSource->boneToPose[parent], m, pSource->boneToPose[i] );
}
// printf("%3d %f %f %f\n", i, psource->bonefixup[i].worldorg[0], psource->bonefixup[i].worldorg[1], psource->bonefixup[i].worldorg[2] );
/*
AngleMatrix( angle, m );
printf("%8.4f %8.4f %8.4f\n", m[0][0], m[1][0], m[2][0] );
printf("%8.4f %8.4f %8.4f\n", m[0][1], m[1][1], m[2][1] );
printf("%8.4f %8.4f %8.4f\n", m[0][2], m[1][2], m[2][2] );
*/
}
}
int Grab_Nodes( s_node_t *pnodes )
{
int index;
char name[1024];
int parent;
int numbones = 0;
for (index = 0; index < MAXSTUDIOSRCBONES; index++)
{
pnodes[index].parent = -1;
}
while (GetLineInput())
{
if (sscanf( g_szLine, "%d \"%[^\"]\" %d", &index, name, &parent ) == 3)
{
// check for duplicated bones
/*
if (strlen(pnodes[index].name) != 0)
{
MdlError( "bone \"%s\" exists more than once\n", name );
}
*/
V_strcpy_safe( pnodes[index].name, name );
pnodes[index].parent = parent;
if (index > numbones)
{
numbones = index;
}
}
else
{
return numbones + 1;
}
}
MdlError( "Unexpected EOF at line %d\n", g_iLinecount );
return 0;
}
void clip_rotations( RadianEuler& rot )
{
int j;
// clip everything to : -M_PI <= x < M_PI
for (j = 0; j < 3; j++) {
while (rot[j] >= M_PI)
rot[j] -= M_PI*2;
while (rot[j] < -M_PI)
rot[j] += M_PI*2;
}
}
void clip_rotations( Vector& rot )
{
int j;
// clip everything to : -180 <= x < 180
for (j = 0; j < 3; j++) {
while (rot[j] >= 180)
rot[j] -= 180*2;
while (rot[j] < -180)
rot[j] += 180*2;
}
}
/*
=================
Cmd_Eyeposition
=================
*/
void Cmd_Eyeposition (void)
{
// rotate points into frame of reference so g_model points down the positive x
// axis
// FIXME: these coords are bogus
GetToken (false);
eyeposition[1] = verify_atof (token);
GetToken (false);
eyeposition[0] = -verify_atof (token);
GetToken (false);
eyeposition[2] = verify_atof (token);
}
//-----------------------------------------------------------------------------
// Cmd_MaxEyeDeflection
//-----------------------------------------------------------------------------
void Cmd_MaxEyeDeflection()
{
GetToken( false );
g_flMaxEyeDeflection = cosf( verify_atof( token ) * M_PI / 180.0f );
}
//-----------------------------------------------------------------------------
// Cmd_Illumposition
//-----------------------------------------------------------------------------
void Cmd_Illumposition( void )
{
GetToken( false );
illumposition[0] = verify_atof( token );
GetToken( false );
illumposition[1] = verify_atof( token );
GetToken( false );
illumposition[2] = verify_atof( token );
if ( TokenAvailable() )
{
GetToken( false );
Q_strncpy( g_attachment[g_numattachments].name, "__illumPosition", sizeof(g_attachment[g_numattachments].name) );
Q_strncpy( g_attachment[g_numattachments].bonename, token, sizeof(g_attachment[g_numattachments].bonename) );
AngleMatrix( QAngle( 0, 0, 0 ), illumposition, g_attachment[g_numattachments].local );
g_attachment[g_numattachments].type |= IS_RIGID;
g_illumpositionattachment = g_numattachments + 1;
++g_numattachments;
}
else
{
g_illumpositionattachment = 0;
// rotate points into frame of reference so
// g_model points down the positive x axis
// FIXME: these coords are bogus
float flTemp = illumposition[0];
illumposition[0] = -illumposition[1];
illumposition[1] = flTemp;
}
illumpositionset = true;
}
//-----------------------------------------------------------------------------
// Process Cmd_Modelname
//-----------------------------------------------------------------------------
void ProcessModelName( const char *pModelName )
{
// Abort early if modelname is too big
// - actually that's okay, it's just an identifier and can be truncated
g_bHasModelName = true;
Q_strncpy( outname, pModelName, sizeof( outname ) );
}
//-----------------------------------------------------------------------------
// Parse Cmd_Modelname
//-----------------------------------------------------------------------------
void Cmd_Modelname (void)
{
GetToken (false);
if ( token[0] == '/' || token[0] == '\\' )
{
MdlWarning( "$modelname key has slash as first character. Removing.\n" );
ProcessModelName( &token[1] );
}
else
{
ProcessModelName( token );
}
}
void Cmd_Autocenter()
{
g_centerstaticprop = true;
}
/*
===============
===============
*/
//-----------------------------------------------------------------------------
// Parse the body command from a .qc file
//-----------------------------------------------------------------------------
void ProcessOptionStudio( s_model_t *pmodel, const char *pFullPath, CDmeSourceSkin *pSkin )
{
Q_strncpy( pmodel->filename, pFullPath, sizeof(pmodel->filename) );
if ( pSkin->m_flScale != 0.0f )
{
pmodel->scale = g_currentscale = pSkin->m_flScale;
}
else
{
pmodel->scale = g_currentscale = g_defaultscale;
}
// load source
pmodel->source = Load_Source( pmodel->filename, "", pSkin->m_bFlipTriangles, true );
// Reset currentscale to whatever global we currently have set
// g_defaultscale gets set in Cmd_ScaleUp everytime the $scale command is used.
g_currentscale = g_defaultscale;
}
//-----------------------------------------------------------------------------
// Parse the studio options from a .qc file
//-----------------------------------------------------------------------------
bool ParseOptionStudio( CDmeSourceSkin *pSkin )
{
if ( !GetToken( false ) )
return false;
pSkin->SetRelativeFileName( token );
while ( TokenAvailable() )
{
GetToken(false);
if ( !Q_stricmp( "reverse", token ) )
{
pSkin->m_bFlipTriangles = true;
continue;
}
if ( !Q_stricmp( "scale", token ) )
{
GetToken(false);
pSkin->m_flScale = verify_atof( token );
continue;
}
if ( !Q_stricmp( "faces", token ) )
{
GetToken( false );
GetToken( false );
continue;
}
if ( !Q_stricmp( "bias", token ) )
{
GetToken( false );
continue;
}
if ( !Q_stricmp( "{", token ) )
{
UnGetToken( );
break;
}
MdlError("unknown command \"%s\"\n", token );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Parse + process the studio options from a .qc file
//-----------------------------------------------------------------------------
void Option_Studio( s_model_t *pmodel )
{
CDmeSourceSkin *pSourceSkin = CreateElement< CDmeSourceSkin >( "" );
// Set defaults
pSourceSkin->m_flScale = g_defaultscale;
if ( ParseOptionStudio( pSourceSkin ) )
{
ProcessOptionStudio( pmodel, pSourceSkin->GetRelativeFileName(), pSourceSkin );
}
DestroyElement( pSourceSkin );
}
int Option_Blank( )
{
g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
g_source[g_numsources] = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
g_model[g_nummodels]->source = g_source[g_numsources];
g_numsources++;
g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
V_strcpy_safe( g_model[g_nummodels]->name, "blank" );
g_bodypart[g_numbodyparts].nummodels++;
g_nummodels++;
return 0;
}
void Cmd_Bodygroup( )
{
int is_started = 0;
if ( !GetToken( false ) )
return;
if (g_numbodyparts == 0)
{
g_bodypart[g_numbodyparts].base = 1;
}
else
{
g_bodypart[g_numbodyparts].base = g_bodypart[g_numbodyparts-1].base * g_bodypart[g_numbodyparts-1].nummodels;
}
V_strcpy_safe( g_bodypart[g_numbodyparts].name, token );
do
{
GetToken (true);
if (endofscript)
return;
else if (token[0] == '{')
{
is_started = 1;
}
else if (token[0] == '}')
{
break;
}
else if (stricmp("studio", token ) == 0)
{
g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
g_bodypart[g_numbodyparts].nummodels++;
Option_Studio( g_model[g_nummodels] );
// Body command should add any flex commands in the source loaded
if ( g_model[g_nummodels]->source )
{
AddBodyFlexData( g_model[g_nummodels]->source, g_nummodels );
AddBodyAttachments( g_model[g_nummodels]->source );
}
g_nummodels++;
}
else if (stricmp("blank", token ) == 0)
{
Option_Blank( );
}
else
{
MdlError("unknown bodygroup option: \"%s\"\n", token );
}
} while (1);
g_numbodyparts++;
return;
}
//-----------------------------------------------------------------------------
// Add A Body Flex Rule
//-----------------------------------------------------------------------------
void AddBodyFlexFetchRule(
s_source_t *pSource,
s_flexrule_t *pRule,
int rawIndex,
const CUtlVector< int > &pRawIndexToRemapSourceIndex,
const CUtlVector< int > &pRawIndexToRemapLocalIndex,
const CUtlVector< int > &pRemapSourceIndexToGlobalFlexControllerIndex )
{
// Lookup the various indices of the requested input to fetch
// Relative to the remapped controls in the current s_source_t
const int remapSourceIndex = pRawIndexToRemapSourceIndex[ rawIndex ];
// Relative to the specific remapped control
const int remapLocalIndex = pRawIndexToRemapLocalIndex[ rawIndex ];
// The global flex controller index that the user ultimately twiddles
const int globalFlexControllerIndex = pRemapSourceIndexToGlobalFlexControllerIndex[ remapSourceIndex ];
// Get the Remap record
s_flexcontrollerremap_t &remap = pSource->m_FlexControllerRemaps[ remapSourceIndex ];
switch ( remap.m_RemapType )
{
case FLEXCONTROLLER_REMAP_PASSTHRU:
// Easy As!
pRule->op[ pRule->numops ].op = STUDIO_FETCH1;
pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
pRule->numops++;
break;
case FLEXCONTROLLER_REMAP_EYELID:
if ( remapLocalIndex == 0 )
{
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = remap.m_EyesUpDownFlexController >= 0 ? remap.m_EyesUpDownFlexController : -1;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = remap.m_BlinkController >= 0 ? remap.m_BlinkController : -1;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = globalFlexControllerIndex; // CloseLid
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_DME_LOWER_EYELID;
pRule->op[ pRule->numops ].d.index = remap.m_MultiIndex; // CloseLidV
pRule->numops++;
}
else
{
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = remap.m_EyesUpDownFlexController >= 0 ? remap.m_EyesUpDownFlexController : -1;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = remap.m_BlinkController >= 0 ? remap.m_BlinkController : -1;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = globalFlexControllerIndex; // CloseLid
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_DME_UPPER_EYELID;
pRule->op[ pRule->numops ].d.index = remap.m_MultiIndex; // CloseLidV
pRule->numops++;
}
break;
case FLEXCONTROLLER_REMAP_2WAY:
// A little trickier... local index 0 is on the left, local index 1 is on the right
// Left Equivalent RemapVal( -1.0, 0.0, 0.0, 1.0 )
// Right Equivalent RemapVal( 0.0, 1.0, 0.0, 1.0 )
if ( remapLocalIndex == 0 )
{
pRule->op[ pRule->numops ].op = STUDIO_2WAY_0;
pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
pRule->numops++;
}
else
{
pRule->op[ pRule->numops ].op = STUDIO_2WAY_1;
pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
pRule->numops++;
}
break;
case FLEXCONTROLLER_REMAP_NWAY:
{
int nRemapCount = remap.m_RawControls.Count();
float flStep = ( nRemapCount > 2 ) ? 2.0f / ( nRemapCount - 1 ) : 0.0f;
if ( remapLocalIndex == 0 )
{
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = -11.0f;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = -10.0f;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = -1.0f;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = -1.0f + flStep;
pRule->numops++;
}
else if ( remapLocalIndex == nRemapCount - 1 )
{
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = 1.0f - flStep;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = 1.0f;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = 10.0f;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = 11.0f;
pRule->numops++;
}
else
{
float flPeak = remapLocalIndex * flStep - 1.0f;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = flPeak - flStep;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = flPeak;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = flPeak;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = flPeak + flStep;
pRule->numops++;
}
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = remap.m_MultiIndex;
pRule->numops++;
pRule->op[ pRule->numops ].op = STUDIO_NWAY;
pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
pRule->numops++;
}
break;
default:
Assert( 0 );
// This is an error condition
pRule->op[ pRule->numops ].op = STUDIO_CONST;
pRule->op[ pRule->numops ].d.value = 1.0f;
pRule->numops++;
break;
}
}
//-----------------------------------------------------------------------------
// Add A Body Flex Rule
//-----------------------------------------------------------------------------
void AddBodyFlexRule(
s_source_t *pSource,
s_combinationrule_t &rule,
int nFlexDesc,
const CUtlVector< int > &pRawIndexToRemapSourceIndex,
const CUtlVector< int > &pRawIndexToRemapLocalIndex,
const CUtlVector< int > &pRemapSourceIndexToGlobalFlexControllerIndex )
{
if ( g_numflexrules >= MAXSTUDIOFLEXRULES )
MdlError( "Line %d: Too many flex rules, max %d",
g_iLinecount, MAXSTUDIOFLEXRULES );
s_flexrule_t *pRule = &g_flexrule[g_numflexrules++];
pRule->flex = nFlexDesc;
// This will multiply the combination together
const int nCombinationCount = rule.m_Combination.Count();
if ( nCombinationCount )
{
for ( int j = 0; j < nCombinationCount; ++j )
{
// Handle any controller remapping
AddBodyFlexFetchRule( pSource, pRule, rule.m_Combination[ j ],
pRawIndexToRemapSourceIndex, pRawIndexToRemapLocalIndex,
pRemapSourceIndexToGlobalFlexControllerIndex );
}
if ( nCombinationCount > 1 )
{
pRule->op[ pRule->numops ].op = STUDIO_COMBO;
pRule->op[ pRule->numops ].d.index = nCombinationCount;
pRule->numops++;
}
}
// This will multiply in the suppressors
int nDominators = rule.m_Dominators.Count();
for ( int j = 0; j < nDominators; ++j )
{
const int nFactorCount = rule.m_Dominators[j].Count();
if ( nFactorCount )
{
for ( int k = 0; k < nFactorCount; ++k )
{
AddBodyFlexFetchRule( pSource, pRule, rule.m_Dominators[ j ][ k ],
pRawIndexToRemapSourceIndex, pRawIndexToRemapLocalIndex,
pRemapSourceIndexToGlobalFlexControllerIndex );
}
pRule->op[ pRule->numops ].op = STUDIO_DOMINATE;
pRule->op[ pRule->numops ].d.index = nFactorCount;
pRule->numops++;
}
}
}
//-----------------------------------------------------------------------------
// Adds flex controller data to a particular source
//-----------------------------------------------------------------------------
void AddFlexControllers(
s_source_t *pSource )
{
CUtlVector< int > &r2s = pSource->m_rawIndexToRemapSourceIndex;
CUtlVector< int > &r2l = pSource->m_rawIndexToRemapLocalIndex;
CUtlVector< int > &l2i = pSource->m_leftRemapIndexToGlobalFlexControllIndex;
CUtlVector< int > &r2i = pSource->m_rightRemapIndexToGlobalFlexControllIndex;
// Number of Raw controls in this source
const int nRawControlCount = pSource->m_CombinationControls.Count();
// Initialize rawToRemapIndices
r2s.SetSize( nRawControlCount );
r2l.SetSize( nRawControlCount );
for ( int i = 0; i < nRawControlCount; ++i )
{
r2s[ i ] = -1;
r2l[ i ] = -1;
}
// Number of Remapped Controls in this source
const int nRemappedControlCount = pSource->m_FlexControllerRemaps.Count();
l2i.SetSize( nRemappedControlCount );
r2i.SetSize( nRemappedControlCount );
for ( int i = 0; i < nRemappedControlCount; ++i )
{
s_flexcontrollerremap_t &remapControl = pSource->m_FlexControllerRemaps[ i ];
// Number of Raw Controls In This Remapped Control
const int nRemappedRawControlCount = remapControl.m_RawControls.Count();
// Figure out the mapping from raw to remapped
for ( int j = 0; j < nRemappedRawControlCount; ++j )
{
for ( int k = 0; k < nRawControlCount; ++k )
{
if ( remapControl.m_RawControls[ j ] == pSource->m_CombinationControls[ k ].name )
{
Assert( r2s[ k ] == -1 );
Assert( r2l[ k ] == -1 );
r2s[ k ] = i; // The index of the remapped control
r2l[ k ] = j; // The index of which control this is in the remap
break;
}
}
}
if ( remapControl.m_bIsStereo )
{
// The controls have to be named 'right_' and 'left_' and right has to be first for
// hlfaceposer to recognize them
// See if we can add two more flex controllers
if ( ( g_numflexcontrollers + 1 ) >= MAXSTUDIOFLEXCTRL)
MdlError( "Line %d: Too many flex controllers, max %d, cannot add split control %s from source %s",
g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
s_flexcontroller_t *pController;
int nLen = remapControl.m_Name.Length();
char *pTemp = (char*)_alloca( nLen + 7 ); // 'left_' && 'right_'
memcpy( pTemp + 6, remapControl.m_Name.Get(), nLen + 1 );
memcpy( pTemp, "right_", 6 );
pTemp[nLen + 6] = '\0';
remapControl.m_RightIndex = g_numflexcontrollers;
r2i[ i ] = g_numflexcontrollers;
pController = &g_flexcontroller[g_numflexcontrollers++];
Q_strncpy( pController->name, pTemp, sizeof( pController->name ) );
Q_strncpy( pController->type, pTemp, sizeof( pController->type ) );
if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_2WAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
{
pController->min = -1.0f;
pController->max = 1.0f;
}
else
{
pController->min = 0.0f;
pController->max = 1.0f;
}
memcpy( pTemp + 5, remapControl.m_Name.Get(), nLen + 1 );
memcpy( pTemp, "left_", 5 );
pTemp[nLen + 5] = '\0';
remapControl.m_LeftIndex = g_numflexcontrollers;
l2i[ i ] = g_numflexcontrollers;
pController = &g_flexcontroller[g_numflexcontrollers++];
Q_strncpy( pController->name, pTemp, sizeof( pController->name ) );
Q_strncpy( pController->type, pTemp, sizeof( pController->type ) );
if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_2WAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
{
pController->min = -1.0f;
pController->max = 1.0f;
}
else
{
pController->min = 0.0f;
pController->max = 1.0f;
}
}
else
{
// See if we can add one more flex controller
if ( g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
MdlError( "Line %d: Too many flex controllers, max %d, cannot add control %s from source %s",
g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
remapControl.m_Index = g_numflexcontrollers;
r2i[ i ] = g_numflexcontrollers;
l2i[ i ] = g_numflexcontrollers;
s_flexcontroller_t *pController = &g_flexcontroller[g_numflexcontrollers++];
Q_strncpy( pController->name, remapControl.m_Name.Get(), sizeof( pController->name ) );
Q_strncpy( pController->type, remapControl.m_Name.Get(), sizeof( pController->type ) );
if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_2WAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
{
pController->min = -1.0f;
pController->max = 1.0f;
}
else
{
pController->min = 0.0f;
pController->max = 1.0f;
}
}
if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_NWAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
{
if ( g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
MdlError( "Line %d: Too many flex controllers, max %d, cannot add value control for nWay %s from source %s",
g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
remapControl.m_MultiIndex = g_numflexcontrollers;
s_flexcontroller_t *pController = &g_flexcontroller[g_numflexcontrollers++];
const int nLen = remapControl.m_Name.Length();
char *pTemp = ( char * )_alloca( nLen + 6 + 1 ); // 'multi_' + 1 for the NULL
memcpy( pTemp, "multi_", 6 );
memcpy( pTemp + 6, remapControl.m_Name.Get(), nLen + 1 );
pTemp[nLen+6] = '\0';
Q_strncpy( pController->name, pTemp, sizeof( pController->name ) );
Q_strncpy( pController->type, pTemp, sizeof( pController->type ) );
pController->min = -1.0f;
pController->max = 1.0f;
}
if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
{
// Make a blink controller
if ( g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
MdlError( "Line %d: Too many flex controllers, max %d, cannot add value control for nWay %s from source %s",
g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
remapControl.m_BlinkController = g_numflexcontrollers;
s_flexcontroller_t *pController = &g_flexcontroller[g_numflexcontrollers++];
Q_strncpy( pController->name, "blink", sizeof( pController->name ) );
Q_strncpy( pController->type, "blink", sizeof( pController->type ) );
pController->min = 0.0f;
pController->max = 1.0f;
}
}
#ifdef _DEBUG
for ( int j = 0; j != nRawControlCount; ++j )
{
Assert( r2s[ j ] != -1 );
Assert( r2l[ j ] != -1 );
}
#endif // def _DEBUG
}
//-----------------------------------------------------------------------------
// Adds flex controller remappers
//-----------------------------------------------------------------------------
void AddBodyFlexRemaps( s_source_t *pSource )
{
int nCount = pSource->m_FlexControllerRemaps.Count();
for( int i = 0; i < nCount; ++i )
{
int k = g_FlexControllerRemap.AddToTail();
s_flexcontrollerremap_t &remap = g_FlexControllerRemap[k];
remap = pSource->m_FlexControllerRemaps[i];
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void AddBodyFlexRules( s_source_t *pSource )
{
const int nRemapCount = pSource->m_FlexControllerRemaps.Count();
for ( int i = 0; i < nRemapCount; ++i )
{
s_flexcontrollerremap_t &remap = pSource->m_FlexControllerRemaps[ i ];
if ( remap.m_RemapType == FLEXCONTROLLER_REMAP_EYELID && !remap.m_EyesUpDownFlexName.IsEmpty() )
{
for ( int j = 0; j < g_numflexcontrollers; ++j )
{
if ( !Q_strcmp( g_flexcontroller[ j ].name, remap.m_EyesUpDownFlexName.Get() ) )
{
Assert( remap.m_EyesUpDownFlexController == -1 );
remap.m_EyesUpDownFlexController = j;
break;
}
}
}
}
const int nCount = pSource->m_CombinationRules.Count();
for ( int i = 0; i < nCount; ++i )
{
s_combinationrule_t &rule = pSource->m_CombinationRules[i];
s_flexkey_t &flexKey = g_flexkey[ pSource->m_nKeyStartIndex + rule.m_nFlex ];
AddBodyFlexRule( pSource, rule, flexKey.flexdesc,
pSource->m_rawIndexToRemapSourceIndex, pSource->m_rawIndexToRemapLocalIndex, pSource->m_leftRemapIndexToGlobalFlexControllIndex );
if ( flexKey.flexpair != 0 )
{
AddBodyFlexRule( pSource, rule, flexKey.flexpair,
pSource->m_rawIndexToRemapSourceIndex, pSource->m_rawIndexToRemapLocalIndex, pSource->m_rightRemapIndexToGlobalFlexControllIndex );
}
}
}
//-----------------------------------------------------------------------------
// Process a body command
//-----------------------------------------------------------------------------
void AddBodyFlexData( s_source_t *pSource, int imodel )
{
pSource->m_nKeyStartIndex = g_numflexkeys;
// Add flex keys
int nCount = pSource->m_FlexKeys.Count();
for ( int i = 0; i < nCount; ++i )
{
s_flexkey_t &key = pSource->m_FlexKeys[i];
if ( g_numflexkeys >= MAXSTUDIOFLEXKEYS )
MdlError( "Line %d: Too many flex keys, max %d, cannot add flexKey %s from source %s",
g_iLinecount, MAXSTUDIOFLEXKEYS, key.animationname, pSource->filename );
memcpy( &g_flexkey[g_numflexkeys], &key, sizeof(s_flexkey_t) );
g_flexkey[g_numflexkeys].imodel = imodel;
// flexpair was set up in AddFlexKey
if ( key.flexpair )
{
char mod[512];
Q_snprintf( mod, sizeof(mod), "%sL", key.animationname );
g_flexkey[g_numflexkeys].flexdesc = Add_Flexdesc( mod );
Q_snprintf( mod, sizeof(mod), "%sR", key.animationname );
g_flexkey[g_numflexkeys].flexpair = Add_Flexdesc( mod );
}
else
{
g_flexkey[g_numflexkeys].flexdesc = Add_Flexdesc( key.animationname );
g_flexkey[g_numflexkeys].flexpair = 0;
}
++g_numflexkeys;
}
AddFlexControllers( pSource );
AddBodyFlexRemaps( pSource );
}
//-----------------------------------------------------------------------------
// Comparison operator for s_attachment_t
//-----------------------------------------------------------------------------
bool s_attachment_t::operator==( const s_attachment_t &rhs ) const
{
if ( Q_strcmp( name, rhs.name ) )
return false;
if ( Q_stricmp( bonename, rhs.bonename ) ||
bone != rhs.bone ||
type != rhs.type ||
flags != rhs.flags ||
Q_memcmp( local.Base(), rhs.local.Base(), sizeof( local ) ) )
{
RadianEuler iEuler, jEuler;
Vector iPos, jPos;
MatrixAngles( local, iEuler, iPos );
MatrixAngles( rhs.local, jEuler, jPos );
MdlWarning(
"Attachments with the same name but different parameters found\n"
" %s: ParentBone: %s Type: %d Flags: 0x%08x P: %6.2f %6.2f %6.2f R: %6.2f %6.2f %6.2f\n"
" %s: ParentBone: %s Type: %d Flags: 0x%08x P: %6.2f %6.2f %6.2f R: %6.2f %6.2f %6.2f\n",
name, bonename, type, flags,
iPos.x, iPos.y, iPos.z, RAD2DEG( iEuler.x ), RAD2DEG( iEuler.y ), RAD2DEG( iEuler.z ),
rhs.name, rhs.bonename, rhs.type, rhs.flags,
jPos.x, jPos.y, jPos.z, RAD2DEG( jEuler.x ), RAD2DEG( jEuler.y ), RAD2DEG( jEuler.z ) );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Add attachments from the s_source_t that aren't already present in the
// global attachment list. At this point, the attachments aren't linked
// to the bone, but since that is done by string matching on the bone name
// the test for an attachment being a duplicate is still valid this early.
//-----------------------------------------------------------------------------
void AddBodyAttachments( s_source_t *pSource )
{
for ( int i = 0; i < pSource->m_Attachments.Count(); ++i )
{
const s_attachment_t &sourceAtt = pSource->m_Attachments[i];
bool bDuplicate = false;
for ( int j = 0; j < g_numattachments; ++j )
{
if ( sourceAtt == g_attachment[j] )
{
bDuplicate = true;
break;
}
}
if ( bDuplicate )
continue;
if ( g_numattachments >= ARRAYSIZE( g_attachment ) )
{
MdlWarning( "Too Many Attachments (Max %d), Ignoring Attachment %s:%s\n",
ARRAYSIZE( g_attachment ), pSource->filename, pSource->m_Attachments[i].name );
continue;;
}
memcpy( &g_attachment[g_numattachments], &( pSource->m_Attachments[i] ), sizeof( s_attachment_t ) );
++g_numattachments;
}
}
//-----------------------------------------------------------------------------
// Process a body command
//-----------------------------------------------------------------------------
void ProcessCmdBody( const char *pFullPath, CDmeSourceSkin *pSkin )
{
if ( g_numbodyparts == 0 )
{
g_bodypart[g_numbodyparts].base = 1;
}
else
{
g_bodypart[g_numbodyparts].base = g_bodypart[g_numbodyparts-1].base * g_bodypart[g_numbodyparts-1].nummodels;
}
Q_strncpy( g_bodypart[g_numbodyparts].name, pSkin->m_SkinName.Get(), sizeof(g_bodypart[g_numbodyparts].name) );
g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
g_bodypart[g_numbodyparts].nummodels = 1;
ProcessOptionStudio( g_model[g_nummodels], pFullPath, pSkin );
// Body command should add any flex commands in the source loaded
if ( g_model[g_nummodels]->source )
{
AddBodyFlexData( g_model[g_nummodels]->source, g_nummodels );
AddBodyAttachments( g_model[g_nummodels]->source );
AddBodyFlexRules( g_model[ g_nummodels ]->source );
}
g_nummodels++;
g_numbodyparts++;
}
//-----------------------------------------------------------------------------
// Parse the body command from a .qc file
//-----------------------------------------------------------------------------
void Cmd_Body( )
{
if ( !GetToken(false) )
return;
CDmeSourceSkin *pSourceSkin = CreateElement< CDmeSourceSkin >( "" );
// Set defaults
pSourceSkin->m_flScale = g_defaultscale;
pSourceSkin->m_SkinName = token;
if ( ParseOptionStudio( pSourceSkin ) )
{
ProcessCmdBody( pSourceSkin->GetRelativeFileName(), pSourceSkin );
}
DestroyElement( pSourceSkin );
}
/*
===============
===============
*/
void Grab_Animation( s_source_t *pSource, const char *pAnimName )
{
Vector pos;
RadianEuler rot;
char cmd[1024];
int index;
int t = -99999999;
int size;
s_sourceanim_t *pAnim = FindOrAddSourceAnim( pSource, pAnimName );
pAnim->startframe = -1;
size = pSource->numbones * sizeof( s_bone_t );
while ( GetLineInput() )
{
if ( sscanf( g_szLine, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &rot[0], &rot[1], &rot[2] ) == 7 )
{
if ( pAnim->startframe < 0 )
{
MdlError( "Missing frame start(%d) : %s", g_iLinecount, g_szLine );
}
scale_vertex( pos );
VectorCopy( pos, pAnim->rawanim[t][index].pos );
VectorCopy( rot, pAnim->rawanim[t][index].rot );
clip_rotations( rot ); // !!!
continue;
}
if ( sscanf( g_szLine, "%1023s %d", cmd, &index ) == 0 )
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
continue;
}
if ( !Q_stricmp( cmd, "time" ) )
{
t = index;
if ( pAnim->startframe == -1 )
{
pAnim->startframe = t;
}
if ( t < pAnim->startframe )
{
MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
}
if ( t > pAnim->endframe )
{
pAnim->endframe = t;
}
t -= pAnim->startframe;
if ( t >= pAnim->rawanim.Count())
{
s_bone_t *ptr = NULL;
pAnim->rawanim.AddMultipleToTail( t - pAnim->rawanim.Count() + 1, &ptr );
}
if ( pAnim->rawanim[t] != NULL )
{
continue;
}
pAnim->rawanim[t] = (s_bone_t *)kalloc( 1, size );
// duplicate previous frames keys
if ( t > 0 && pAnim->rawanim[t-1] )
{
for ( int j = 0; j < pSource->numbones; j++ )
{
VectorCopy( pAnim->rawanim[t-1][j].pos, pAnim->rawanim[t][j].pos );
VectorCopy( pAnim->rawanim[t-1][j].rot, pAnim->rawanim[t][j].rot );
}
}
continue;
}
if ( !Q_stricmp( cmd, "end" ) )
{
pAnim->numframes = pAnim->endframe - pAnim->startframe + 1;
for ( t = 0; t < pAnim->numframes; t++ )
{
if ( pAnim->rawanim[t] == NULL)
{
MdlError( "%s is missing frame %d\n", pSource->filename, t + pAnim->startframe );
}
}
Build_Reference( pSource, pAnimName );
return;
}
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
MdlError( "unexpected EOF: %s\n", pSource->filename );
}
int Option_Activity( s_sequence_t *psequence )
{
qboolean found;
found = false;
GetToken(false);
V_strcpy_safe( psequence->activityname, token );
GetToken(false);
psequence->actweight = verify_atoi(token);
if ( psequence->actweight == 0 )
{
TokenError( "Activity %s has a zero weight (weights must be integers > 0)\n", psequence->activityname );
}
return 0;
}
int Option_ActivityModifier( s_sequence_t *psequence )
{
GetToken(false);
V_strcpy_safe( psequence->activitymodifier[ psequence->numactivitymodifiers++ ].name, token );
return 0;
}
/*
===============
===============
*/
int Option_Event ( s_sequence_t *psequence )
{
if (psequence->numevents + 1 >= MAXSTUDIOEVENTS)
{
TokenError("too many events\n");
}
GetToken (false);
V_strcpy_safe( psequence->event[psequence->numevents].eventname, token );
GetToken( false );
psequence->event[psequence->numevents].frame = verify_atoi( token );
psequence->numevents++;
// option token
if (TokenAvailable())
{
GetToken( false );
if (token[0] == '}') // opps, hit the end
return 1;
// found an option
V_strcpy_safe( psequence->event[psequence->numevents-1].options, token );
}
return 0;
}
void Option_IKRule( s_ikrule_t *pRule )
{
// chain
GetToken( false );
int i;
for ( i = 0; i < g_numikchains; i++)
{
if (stricmp( token, g_ikchain[i].name ) == 0)
{
break;
}
}
if (i >= g_numikchains)
{
TokenError( "unknown chain \"%s\" in ikrule\n", token );
}
pRule->chain = i;
// default slot
pRule->slot = i;
// type
GetToken( false );
if (stricmp( token, "touch" ) == 0)
{
pRule->type = IK_SELF;
// bone
GetToken( false );
V_strcpy_safe( pRule->bonename, token );
}
else if (stricmp( token, "footstep" ) == 0)
{
pRule->type = IK_GROUND;
pRule->height = g_ikchain[pRule->chain].height;
pRule->floor = g_ikchain[pRule->chain].floor;
pRule->radius = g_ikchain[pRule->chain].radius;
}
else if (stricmp( token, "attachment" ) == 0)
{
pRule->type = IK_ATTACHMENT;
// name of attachment
GetToken( false );
V_strcpy_safe( pRule->attachment, token );
}
else if (stricmp( token, "release" ) == 0)
{
pRule->type = IK_RELEASE;
}
else if (stricmp( token, "unlatch" ) == 0)
{
pRule->type = IK_UNLATCH;
}
pRule->contact = -1;
while (TokenAvailable())
{
GetToken( false );
if (stricmp( token, "height" ) == 0)
{
GetToken( false );
pRule->height = verify_atof( token );
}
else if (stricmp( token, "target" ) == 0)
{
// slot
GetToken( false );
pRule->slot = verify_atoi( token );
}
else if (stricmp( token, "range" ) == 0)
{
// ramp
GetToken( false );
if (token[0] == '.')
pRule->start = -1;
else
pRule->start = verify_atoi( token );
GetToken( false );
if (token[0] == '.')
pRule->peak = -1;
else
pRule->peak = verify_atoi( token );
GetToken( false );
if (token[0] == '.')
pRule->tail = -1;
else
pRule->tail = verify_atoi( token );
GetToken( false );
if (token[0] == '.')
pRule->end = -1;
else
pRule->end = verify_atoi( token );
}
else if (stricmp( token, "floor" ) == 0)
{
GetToken( false );
pRule->floor = verify_atof( token );
}
else if (stricmp( token, "pad" ) == 0)
{
GetToken( false );
pRule->radius = verify_atof( token ) / 2.0f;
}
else if (stricmp( token, "radius" ) == 0)
{
GetToken( false );
pRule->radius = verify_atof( token );
}
else if (stricmp( token, "contact" ) == 0)
{
GetToken( false );
pRule->contact = verify_atoi( token );
}
else if (stricmp( token, "usesequence" ) == 0)
{
pRule->usesequence = true;
pRule->usesource = false;
}
else if (stricmp( token, "usesource" ) == 0)
{
pRule->usesequence = false;
pRule->usesource = true;
}
else if (stricmp( token, "fakeorigin" ) == 0)
{
GetToken( false );
pRule->pos.x = verify_atof( token );
GetToken( false );
pRule->pos.y = verify_atof( token );
GetToken( false );
pRule->pos.z = verify_atof( token );
pRule->bone = -1;
}
else if (stricmp( token, "fakerotate" ) == 0)
{
QAngle ang;
GetToken( false );
ang.x = verify_atof( token );
GetToken( false );
ang.y = verify_atof( token );
GetToken( false );
ang.z = verify_atof( token );
AngleQuaternion( ang, pRule->q );
pRule->bone = -1;
}
else if (stricmp( token, "bone" ) == 0)
{
V_strcpy_safe( pRule->bonename, token );
}
else
{
UnGetToken();
return;
}
}
}
/*
=================
Cmd_Origin
=================
*/
void Cmd_Origin (void)
{
GetToken (false);
g_defaultadjust.x = verify_atof (token);
GetToken (false);
g_defaultadjust.y = verify_atof (token);
GetToken (false);
g_defaultadjust.z = verify_atof (token);
if (TokenAvailable())
{
GetToken (false);
g_defaultrotation.z = DEG2RAD( verify_atof( token ) + 90);
}
}
//-----------------------------------------------------------------------------
// Purpose: Set the default root rotation so that the Y axis is up instead of the Z axis (for Maya)
//-----------------------------------------------------------------------------
void ProcessUpAxis( const RadianEuler &angles )
{
g_defaultrotation = angles;
}
//-----------------------------------------------------------------------------
// Purpose: Set the default root rotation so that the Y axis is up instead of the Z axis (for Maya)
//-----------------------------------------------------------------------------
void Cmd_UpAxis( void )
{
// We want to create a rotation that rotates from the art space
// (specified by the up direction) to a z up space
// Note: x, -x, -y are untested
RadianEuler angles( 0.0f, 0.0f, M_PI / 2.0f );
GetToken (false);
if (!Q_stricmp( token, "x" ))
{
// rotate 90 degrees around y to move x into z
angles.x = 0.0f;
angles.y = M_PI / 2.0f;
}
else if (!Q_stricmp( token, "-x" ))
{
// untested
angles.x = 0.0f;
angles.y = -M_PI / 2.0f;
}
else if (!Q_stricmp( token, "y" ))
{
// rotate 90 degrees around x to move y into z
angles.x = M_PI / 2.0f;
angles.y = 0.0f;
}
else if (!Q_stricmp( token, "-y" ))
{
// untested
angles.x = -M_PI / 2.0f;
angles.y = 0.0f;
}
else if (!Q_stricmp( token, "z" ))
{
// there's still a built in 90 degree Z rotation :(
angles.x = 0.0f;
angles.y = 0.0f;
}
else if (!Q_stricmp( token, "-z" ))
{
// there's still a built in 90 degree Z rotation :(
angles.x = 0.0f;
angles.y = 0.0f;
}
else
{
TokenError( "unknown $upaxis option: \"%s\"\n", token );
return;
}
ProcessUpAxis( angles );
}
/*
=================
=================
*/
void Cmd_ScaleUp (void)
{
GetToken (false);
g_defaultscale = verify_atof (token);
g_currentscale = g_defaultscale;
}
//-----------------------------------------------------------------------------
// Purpose: Sets how what size chunks to cut the animations into
//-----------------------------------------------------------------------------
void Cmd_AnimBlockSize( void )
{
GetToken( false );
g_animblocksize = verify_atoi( token );
if (g_animblocksize < 1024)
{
g_animblocksize *= 1024;
}
while (TokenAvailable())
{
GetToken( false );
if (!Q_stricmp( token, "nostall" ))
{
g_bNoAnimblockStall = true;
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void FlipFacing( s_source_t *pSrc )
{
unsigned short tmp;
int i, j;
for( i = 0; i < pSrc->nummeshes; i++ )
{
s_mesh_t *pMesh = &pSrc->mesh[i];
for( j = 0; j < pMesh->numfaces; j++ )
{
s_face_t &f = pSrc->face[pMesh->faceoffset + j];
tmp = f.b; f.b = f.c; f.c = tmp;
}
}
}
// Processes source comment line and extracts information about the data file
void ProcessSourceComment( s_source_t *psource, const char *pCommentString )
{
if ( char const *szSceneComment = StringAfterPrefix( pCommentString, "// SCENE=" ) )
{
char szScene[1024];
Q_strncpy( szScene, szSceneComment, ARRAYSIZE( szScene ) );
Q_FixSlashes( szScene );
ProcessOriginalContentFile( psource->filename, szScene );
}
}
// Processes original content file "szOriginalContentFile" that was used to generate
// data file "szDataFile"
void ProcessOriginalContentFile( char const *szDataFile, char const *szOriginalContentFile )
{
// Early out: if no p4
if ( g_bNoP4 )
return;
char const *szContentDirRootEnd = strstr( szDataFile, "\\content\\" );
char const *szSceneName = strstr( szOriginalContentFile, "\\content\\" );
if ( szContentDirRootEnd && szSceneName )
{
char chScenePath[ MAX_PATH ] = {0};
Q_snprintf( chScenePath, sizeof( chScenePath ) - 1, "%.*s%s",
szContentDirRootEnd - szDataFile, szDataFile, szSceneName );
EnsureDependencyFileCheckedIn( chScenePath );
}
else if ( szContentDirRootEnd && !szSceneName )
{
// Assume relative path
char chScenePath[ MAX_PATH ] = {0};
Q_snprintf( chScenePath, sizeof( chScenePath ) - 1, "%.*s%s",
max( strrchr( szDataFile, '\\' ), strrchr( szDataFile, '/' ) ) + 1 - szDataFile,
szDataFile, szOriginalContentFile );
EnsureDependencyFileCheckedIn( chScenePath );
}
else
{
MdlWarning( "ProcessOriginalContentFile for '%s' cannot detect scene source file from '%s'!\n", szDataFile, szOriginalContentFile );
}
}
//-----------------------------------------------------------------------------
// Checks to see if the model source was already loaded
//-----------------------------------------------------------------------------
static s_source_t *FindCachedSource( const char* name, const char* xext )
{
int i;
if( xext[0] )
{
// we know what extension is necessary. . look for it.
Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.%s", cddir[numdirs], name, xext );
for (i = 0; i < g_numsources; i++)
{
if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
return g_source[i];
}
}
else
{
// we don't know what extension to use, so look for all of 'em.
Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.vrm", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
return g_source[i];
}
Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.smd", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
return g_source[i];
}
Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.dmx", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
return g_source[i];
}
Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.xml", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
return g_source[i];
}
Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.obj", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
return g_source[i];
}
/*
sprintf (g_szFilename, "%s%s.vta", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if (stricmp( g_szFilename, g_source[i]->filename ) == 0)
return g_source[i];
}
*/
}
// Not found
return 0;
}
//-----------------------------------------------------------------------------
// Loads an animation/model source
//-----------------------------------------------------------------------------
s_source_t *Load_Source( const char *name, const char *ext, bool reverse, bool isActiveModel )
{
if ( g_numsources >= MAXSTUDIOSEQUENCES )
TokenError( "Load_Source( %s ) - overflowed g_numsources.", name );
Assert(name);
int namelen = strlen(name) + 1;
char* pTempName = (char*)_alloca( namelen );
char xext[32];
int result = false;
V_strncpy( pTempName, name, namelen );
Q_ExtractFileExtension( pTempName, xext, sizeof( xext ) );
if (xext[0] == '\0')
{
V_strcpy_safe( xext, ext );
}
else
{
Q_StripExtension( pTempName, pTempName, namelen );
}
s_source_t* pSource = FindCachedSource( pTempName, xext );
if (pSource)
{
if (isActiveModel)
pSource->isActiveModel = true;
return pSource;
}
g_source[g_numsources] = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
if (isActiveModel)
{
g_source[g_numsources]->isActiveModel = true;
}
char const * load_extensions[] = { "vrm", "smd", "sma", "phys", "vta", "obj", "dmx", "xml" };
int ( *load_procs[] )( s_source_t * ) = { Load_VRM, Load_SMD, Load_SMD, Load_SMD, Load_VTA, Load_OBJ, Load_DMX, Load_DMX };
Assert( ARRAYSIZE(load_extensions) == ARRAYSIZE(load_procs) );
for ( int kk = 0; kk < ARRAYSIZE( load_extensions ); ++ kk )
{
if ( ( !result && xext[0] == '\0' ) || Q_stricmp( xext, load_extensions[kk] ) == 0)
{
Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.%s", cddir[numdirs], pTempName, load_extensions[kk] );
V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
result = (load_procs[kk])( g_source[g_numsources] );
if ( result )
EnsureDependencyFileCheckedIn( g_source[g_numsources]->filename );
}
}
if (!g_bCreateMakefile && !result)
{
if (xext[0] == '\0')
TokenError( "could not load file '%s%s'\n", cddir[numdirs], pTempName );
else
TokenError( "could not load file '%s%s.%s'\n", cddir[numdirs], pTempName, xext );
}
if ( g_source[g_numsources]->numbones == 0 )
{
TokenError( "missing all bones in file '%s'\n", g_source[g_numsources]->filename );
}
// copy over default settings of when the model was loaded (since there's no actual animation for some of the systems)
VectorCopy( g_defaultadjust, g_source[g_numsources]->adjust );
g_source[g_numsources]->scale = 1.0f;
g_source[g_numsources]->rotation = g_defaultrotation;
g_numsources++;
if( reverse )
{
FlipFacing( g_source[g_numsources-1] );
}
return g_source[g_numsources-1];
}
s_sequence_t *LookupSequence( const char *name )
{
int i;
for ( i = 0; i < g_sequence.Count(); ++i )
{
if ( !Q_stricmp( g_sequence[i].name, name ) )
return &g_sequence[i];
}
return NULL;
}
s_animation_t *LookupAnimation( const char *name )
{
int i;
for ( i = 0; i < g_numani; i++)
{
if ( !Q_stricmp( g_panimation[i]->name, name ) )
return g_panimation[i];
}
s_sequence_t *pseq = LookupSequence( name );
return pseq ? pseq->panim[0][0] : NULL;
}
//-----------------------------------------------------------------------------
// Purpose: parse order dependant s_animcmd_t token for $animations
//-----------------------------------------------------------------------------
int ParseCmdlistToken( int &numcmds, s_animcmd_t *cmds )
{
if (numcmds >= MAXSTUDIOCMDS)
{
return false;
}
s_animcmd_t *pcmd = &cmds[numcmds];
if (stricmp("fixuploop", token ) == 0)
{
pcmd->cmd = CMD_FIXUP;
GetToken( false );
pcmd->u.fixuploop.start = verify_atoi( token );
GetToken( false );
pcmd->u.fixuploop.end = verify_atoi( token );
}
else if (strnicmp("weightlist", token, 6 ) == 0)
{
GetToken( false );
int i;
for ( i = 1; i < g_numweightlist; i++)
{
if (stricmp( g_weightlist[i].name, token ) == 0)
{
break;
}
}
if (i == g_numweightlist)
{
TokenError( "unknown weightlist '%s\'\n", token );
}
pcmd->cmd = CMD_WEIGHTS;
pcmd->u.weightlist.index = i;
}
else if (stricmp("subtract", token ) == 0)
{
pcmd->cmd = CMD_SUBTRACT;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown subtract animation '%s\'\n", token );
}
pcmd->u.subtract.ref = extanim;
GetToken( false );
pcmd->u.subtract.frame = verify_atoi( token );
pcmd->u.subtract.flags |= STUDIO_POST;
}
else if (stricmp("presubtract", token ) == 0) // FIXME: rename this to something better
{
pcmd->cmd = CMD_SUBTRACT;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown presubtract animation '%s\'\n", token );
}
pcmd->u.subtract.ref = extanim;
GetToken( false );
pcmd->u.subtract.frame = verify_atoi( token );
}
else if (stricmp( "alignto", token ) == 0)
{
pcmd->cmd = CMD_AO;
pcmd->u.ao.pBonename = NULL;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown alignto animation '%s\'\n", token );
}
pcmd->u.ao.ref = extanim;
pcmd->u.ao.motiontype = STUDIO_X | STUDIO_Y;
pcmd->u.ao.srcframe = 0;
pcmd->u.ao.destframe = 0;
}
else if (stricmp( "align", token ) == 0)
{
pcmd->cmd = CMD_AO;
pcmd->u.ao.pBonename = NULL;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown align animation '%s\'\n", token );
}
pcmd->u.ao.ref = extanim;
// motion type to match
pcmd->u.ao.motiontype = 0;
GetToken( false );
int ctrl;
while ((ctrl = lookupControl( token )) != -1)
{
pcmd->u.ao.motiontype |= ctrl;
GetToken( false );
}
if (pcmd->u.ao.motiontype == 0)
{
TokenError( "missing controls on align\n" );
}
// frame of reference animation to match
pcmd->u.ao.srcframe = verify_atoi( token );
// against what frame of the current animation
GetToken( false );
pcmd->u.ao.destframe = verify_atoi( token );
}
else if (stricmp( "alignboneto", token ) == 0)
{
pcmd->cmd = CMD_AO;
GetToken( false );
pcmd->u.ao.pBonename = strdup( token );
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown alignboneto animation '%s\'\n", token );
}
pcmd->u.ao.ref = extanim;
pcmd->u.ao.motiontype = STUDIO_X | STUDIO_Y;
pcmd->u.ao.srcframe = 0;
pcmd->u.ao.destframe = 0;
}
else if (stricmp( "alignbone", token ) == 0)
{
pcmd->cmd = CMD_AO;
GetToken( false );
pcmd->u.ao.pBonename = strdup( token );
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown alignboneto animation '%s\'\n", token );
}
pcmd->u.ao.ref = extanim;
// motion type to match
pcmd->u.ao.motiontype = 0;
GetToken( false );
int ctrl;
while ((ctrl = lookupControl( token )) != -1)
{
pcmd->u.ao.motiontype |= ctrl;
GetToken( false );
}
if (pcmd->u.ao.motiontype == 0)
{
TokenError( "missing controls on align\n" );
}
// frame of reference animation to match
pcmd->u.ao.srcframe = verify_atoi( token );
// against what frame of the current animation
GetToken( false );
pcmd->u.ao.destframe = verify_atoi( token );
}
else if (stricmp( "match", token ) == 0)
{
pcmd->cmd = CMD_MATCH;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown match animation '%s\'\n", token );
}
pcmd->u.match.ref = extanim;
}
else if (stricmp( "matchblend", token ) == 0)
{
pcmd->cmd = CMD_MATCHBLEND;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
MdlError( "unknown match animation '%s\'\n", token );
}
pcmd->u.match.ref = extanim;
// frame of reference animation to match
GetToken( false );
pcmd->u.match.srcframe = verify_atoi( token );
// against what frame of the current animation
GetToken( false );
pcmd->u.match.destframe = verify_atoi( token );
// backup and starting match in here
GetToken( false );
pcmd->u.match.destpre = verify_atoi( token );
// continue blending match till here
GetToken( false );
pcmd->u.match.destpost = verify_atoi( token );
}
else if (stricmp( "worldspaceblend", token ) == 0)
{
pcmd->cmd = CMD_WORLDSPACEBLEND;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown worldspaceblend animation '%s\'\n", token );
}
pcmd->u.world.ref = extanim;
pcmd->u.world.startframe = 0;
pcmd->u.world.loops = false;
}
else if (stricmp( "worldspaceblendloop", token ) == 0)
{
pcmd->cmd = CMD_WORLDSPACEBLEND;
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown worldspaceblend animation '%s\'\n", token );
}
pcmd->u.world.ref = extanim;
GetToken( false );
pcmd->u.world.startframe = atoi( token );
pcmd->u.world.loops = true;
}
else if (stricmp( "rotateto", token ) == 0)
{
pcmd->cmd = CMD_ANGLE;
GetToken( false );
pcmd->u.angle.angle = verify_atof( token );
}
else if (stricmp( "ikrule", token ) == 0)
{
pcmd->cmd = CMD_IKRULE;
pcmd->u.ikrule.pRule = (s_ikrule_t *)kalloc( 1, sizeof( s_ikrule_t ) );
Option_IKRule( pcmd->u.ikrule.pRule );
}
else if (stricmp( "ikfixup", token ) == 0)
{
pcmd->cmd = CMD_IKFIXUP;
pcmd->u.ikfixup.pRule = (s_ikrule_t *)kalloc( 1, sizeof( s_ikrule_t ) );
Option_IKRule( pcmd->u.ikrule.pRule );
}
else if (stricmp( "walkframe", token ) == 0)
{
pcmd->cmd = CMD_MOTION;
// frame
GetToken( false );
pcmd->u.motion.iEndFrame = verify_atoi( token );
// motion type to match
pcmd->u.motion.motiontype = 0;
while (TokenAvailable())
{
GetToken( false );
int ctrl = lookupControl( token );
if (ctrl != -1)
{
pcmd->u.motion.motiontype |= ctrl;
}
else
{
UnGetToken();
break;
}
}
/*
GetToken( false ); // X
pcmd->u.motion.x = verify_atof( token );
GetToken( false ); // Y
pcmd->u.motion.y = verify_atof( token );
GetToken( false ); // A
pcmd->u.motion.zr = verify_atof( token );
*/
}
else if (stricmp( "walkalignto", token ) == 0)
{
pcmd->cmd = CMD_REFMOTION;
GetToken( false );
pcmd->u.motion.iEndFrame = verify_atoi( token );
pcmd->u.motion.iSrcFrame = pcmd->u.motion.iEndFrame;
GetToken( false ); // reference animation
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown alignto animation '%s\'\n", token );
}
pcmd->u.motion.pRefAnim = extanim;
pcmd->u.motion.iRefFrame = 0;
// motion type to match
pcmd->u.motion.motiontype = 0;
while (TokenAvailable())
{
GetToken( false );
int ctrl = lookupControl( token );
if (ctrl != -1)
{
pcmd->u.motion.motiontype |= ctrl;
}
else
{
UnGetToken();
break;
}
}
/*
GetToken( false ); // X
pcmd->u.motion.x = verify_atof( token );
GetToken( false ); // Y
pcmd->u.motion.y = verify_atof( token );
GetToken( false ); // A
pcmd->u.motion.zr = verify_atof( token );
*/
}
else if (stricmp( "walkalign", token ) == 0)
{
pcmd->cmd = CMD_REFMOTION;
// end frame to apply motion over
GetToken( false );
pcmd->u.motion.iEndFrame = verify_atoi( token );
// reference animation
GetToken( false );
s_animation_t *extanim = LookupAnimation( token );
if (extanim == NULL)
{
TokenError( "unknown alignto animation '%s\'\n", token );
}
pcmd->u.motion.pRefAnim = extanim;
// motion type to match
pcmd->u.motion.motiontype = 0;
while (TokenAvailable())
{
GetToken( false );
int ctrl = lookupControl( token );
if (ctrl != -1)
{
pcmd->u.motion.motiontype |= ctrl;
}
else
{
break;
}
}
if (pcmd->u.motion.motiontype == 0)
{
TokenError( "missing controls on walkalign\n" );
}
// frame of reference animation to match
pcmd->u.motion.iRefFrame = verify_atoi( token );
// against what frame of the current animation
GetToken( false );
pcmd->u.motion.iSrcFrame = verify_atoi( token );
}
else if (stricmp("derivative", token ) == 0)
{
pcmd->cmd = CMD_DERIVATIVE;
// get scale
GetToken( false );
pcmd->u.derivative.scale = verify_atof( token );
}
else if (stricmp("noanimation", token ) == 0)
{
pcmd->cmd = CMD_NOANIMATION;
}
else if (stricmp("lineardelta", token ) == 0)
{
pcmd->cmd = CMD_LINEARDELTA;
pcmd->u.linear.flags |= STUDIO_AL_POST;
}
else if (stricmp("splinedelta", token ) == 0)
{
pcmd->cmd = CMD_LINEARDELTA;
pcmd->u.linear.flags |= STUDIO_AL_POST;
pcmd->u.linear.flags |= STUDIO_AL_SPLINE;
}
else if (stricmp("compress", token ) == 0)
{
pcmd->cmd = CMD_COMPRESS;
// get frames to skip
GetToken( false );
pcmd->u.compress.frames = verify_atoi( token );
}
else if (stricmp("numframes", token ) == 0)
{
pcmd->cmd = CMD_NUMFRAMES;
// get frames to force
GetToken( false );
pcmd->u.compress.frames = verify_atoi( token );
}
else if (stricmp("counterrotate", token ) == 0)
{
pcmd->cmd = CMD_COUNTERROTATE;
// get bone name
GetToken( false );
pcmd->u.counterrotate.pBonename = strdup( token );
}
else if (stricmp("counterrotateto", token ) == 0)
{
pcmd->cmd = CMD_COUNTERROTATE;
pcmd->u.counterrotate.bHasTarget = true;
// get pitch
GetToken( false );
pcmd->u.counterrotate.targetAngle[0] = verify_atof( token );
// get yaw
GetToken( false );
pcmd->u.counterrotate.targetAngle[1] = verify_atof( token );
// get roll
GetToken( false );
pcmd->u.counterrotate.targetAngle[2] = verify_atof( token );
// get bone name
GetToken( false );
pcmd->u.counterrotate.pBonename = strdup( token );
}
else if (stricmp("localhierarchy", token ) == 0)
{
pcmd->cmd = CMD_LOCALHIERARCHY;
// get bone name
GetToken( false );
pcmd->u.localhierarchy.pBonename = strdup( token );
// get parent name
GetToken( false );
pcmd->u.localhierarchy.pParentname = strdup( token );
pcmd->u.localhierarchy.start = -1;
pcmd->u.localhierarchy.peak = -1;
pcmd->u.localhierarchy.tail = -1;
pcmd->u.localhierarchy.end = -1;
if (TokenAvailable())
{
GetToken( false );
if (stricmp( token, "range" ) == 0)
{
//
GetToken( false );
pcmd->u.localhierarchy.start = verify_atof_with_null( token );
//
GetToken( false );
pcmd->u.localhierarchy.peak = verify_atof_with_null( token );
//
GetToken( false );
pcmd->u.localhierarchy.tail = verify_atof_with_null( token );
//
GetToken( false );
pcmd->u.localhierarchy.end = verify_atof_with_null( token );
}
else
{
UnGetToken();
}
}
}
else
{
return false;
}
numcmds++;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: parse order independant s_animation_t token for $animations
//-----------------------------------------------------------------------------
bool ParseAnimationToken( s_animation_t *panim )
{
if ( !Q_stricmp( "if", token ) )
{
// fixme: add expression evaluation
GetToken( false );
if (atoi( token ) == 0 && stricmp( token, "true" ) != 0)
{
GetToken(true);
if (token[0] == '{')
{
int depth = 1;
while (TokenAvailable() && depth > 0)
{
GetToken( true );
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
}
}
}
return true;
}
if ( !Q_stricmp( "fps", token ) )
{
GetToken( false );
panim->fps = verify_atof( token );
if ( panim->fps <= 0.0f )
{
TokenError( "ParseAnimationToken: fps (%f from '%s') <= 0.0\n", panim->fps, token );
}
return true;
}
if ( !Q_stricmp( "origin", token ) )
{
GetToken (false);
panim->adjust.x = verify_atof (token);
GetToken (false);
panim->adjust.y = verify_atof (token);
GetToken (false);
panim->adjust.z = verify_atof (token);
return true;
}
if ( !Q_stricmp( "rotate", token ) )
{
GetToken( false );
// FIXME: broken for Maya
panim->rotation.z = DEG2RAD( verify_atof( token ) + 90 );
return true;
}
if ( !Q_stricmp( "angles", token ) )
{
GetToken( false );
panim->rotation.x = DEG2RAD( verify_atof( token ) );
GetToken( false );
panim->rotation.y = DEG2RAD( verify_atof( token ) );
GetToken( false );
panim->rotation.z = DEG2RAD( verify_atof( token ) + 90.0f);
return true;
}
if ( !Q_stricmp( "scale", token ) )
{
GetToken( false );
panim->scale = verify_atof( token );
return true;
}
if ( !Q_strnicmp( "loop", token, 4 ) )
{
panim->flags |= STUDIO_LOOPING;
return true;
}
if ( !Q_strnicmp( "startloop", token, 5 ) )
{
GetToken( false );
panim->looprestart = verify_atoi( token );
panim->flags |= STUDIO_LOOPING;
return true;
}
if ( !Q_stricmp( "fudgeloop", token ) )
{
panim->fudgeloop = true;
panim->flags |= STUDIO_LOOPING;
return true;
}
if ( !Q_strnicmp( "snap", token, 4 ) )
{
panim->flags |= STUDIO_SNAP;
return true;
}
if ( !Q_strnicmp( "frame", token, 5 ) )
{
GetToken( false );
panim->startframe = verify_atoi( token );
GetToken( false );
panim->endframe = verify_atoi( token );
// NOTE: This always affects the first source anim read in
s_sourceanim_t *pSourceAnim = FindSourceAnim( panim->source, panim->animationname );
if ( pSourceAnim )
{
if ( panim->startframe < pSourceAnim->startframe )
{
panim->startframe = pSourceAnim->startframe;
}
if ( panim->endframe > pSourceAnim->endframe )
{
panim->endframe = pSourceAnim->endframe;
}
}
if ( !g_bCreateMakefile && panim->endframe < panim->startframe )
{
TokenError( "end frame before start frame in %s", panim->name );
}
panim->numframes = panim->endframe - panim->startframe + 1;
return true;
}
if ( !Q_stricmp( "blockname", token ) )
{
GetToken( false );
s_sourceanim_t *pSourceAnim = FindSourceAnim( panim->source, token );
// NOTE: This always affects the first source anim read in
if ( pSourceAnim )
{
panim->startframe = pSourceAnim->startframe;
panim->endframe = pSourceAnim->endframe;
if ( !g_bCreateMakefile && panim->endframe < panim->startframe )
{
TokenError( "end frame before start frame in %s", panim->name );
}
panim->numframes = panim->endframe - panim->startframe + 1;
Q_strncpy( panim->animationname, token, sizeof(panim->animationname) );
}
else
{
MdlError( "Requested unknown animation block name %s\n", token );
}
return true;
}
if ( !Q_stricmp( "post", token ) )
{
panim->flags |= STUDIO_POST;
return true;
}
if ( !Q_stricmp( "noautoik", token ) )
{
panim->noAutoIK = true;
return true;
}
if ( !Q_stricmp( "autoik", token ) )
{
panim->noAutoIK = false;
return true;
}
if ( ParseCmdlistToken( panim->numcmds, panim->cmds ) )
return true;
if ( !Q_stricmp( "cmdlist", token ) )
{
GetToken( false ); // A
int i;
for ( i = 0; i < g_numcmdlists; i++)
{
if (stricmp( g_cmdlist[i].name, token) == 0)
{
break;
}
}
if (i == g_numcmdlists)
TokenError( "unknown cmdlist %s\n", token );
for (int j = 0; j < g_cmdlist[i].numcmds; j++)
{
if (panim->numcmds >= MAXSTUDIOCMDS)
{
TokenError("Too many cmds in %s\n", panim->name );
}
panim->cmds[panim->numcmds++] = g_cmdlist[i].cmds[j];
}
return true;
}
if ( !Q_stricmp( "motionrollback", token ) )
{
GetToken( false );
panim->motionrollback = atof( token );
return true;
}
if ( !Q_stricmp( "noanimblock", token ) )
{
panim->disableAnimblocks = true;
return true;
}
if ( !Q_stricmp( "noanimblockstall", token ) )
{
panim->isFirstSectionLocal = true;
return true;
}
if ( lookupControl( token ) != -1 )
{
panim->motiontype |= lookupControl( token );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: create named order dependant s_animcmd_t blocks, used as replicated token list for $animations
//-----------------------------------------------------------------------------
void Cmd_Cmdlist( )
{
int depth = 0;
// name
GetToken(false);
V_strcpy_safe( g_cmdlist[g_numcmdlists].name, token );
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
else if (ParseCmdlistToken( g_cmdlist[g_numcmdlists].numcmds, g_cmdlist[g_numcmdlists].cmds ))
{
}
else
{
TokenError( "unknown command: %s\n", token );
}
if (depth < 0)
{
TokenError("missing {\n");
}
};
g_numcmdlists++;
}
int ParseAnimation( s_animation_t *panim, bool isAppend );
int ParseEmpty( void );
//-----------------------------------------------------------------------------
// Purpose: allocate an entry for $animation
//-----------------------------------------------------------------------------
void Cmd_Animation( )
{
// name
GetToken(false);
s_animation_t *panim = LookupAnimation( token );
if (panim != NULL)
{
if (!panim->isOverride)
{
TokenError( "Duplicate animation name \"%s\"\n", token );
}
else
{
panim->doesOverride = true;
ParseEmpty();
return;
}
}
// allocate animation entry
g_panimation[g_numani] = (s_animation_t *)kalloc( 1, sizeof( s_animation_t ) );
g_panimation[g_numani]->index = g_numani;
panim = g_panimation[g_numani];
V_strcpy_safe( panim->name, token );
g_numani++;
// filename
GetToken(false);
V_strcpy_safe( panim->filename, token );
panim->source = Load_Source( panim->filename, "" );
if ( panim->source->m_Animations.Count() )
{
s_sourceanim_t *pSourceAnim = &panim->source->m_Animations[0];
panim->startframe = pSourceAnim->startframe;
panim->endframe = pSourceAnim->endframe;
Q_strncpy( panim->animationname, pSourceAnim->animationname, sizeof(panim->animationname) );
}
else
{
panim->startframe = 0;
panim->endframe = 0;
Q_strncpy( panim->animationname, "", sizeof(panim->animationname) );
}
VectorCopy( g_defaultadjust, panim->adjust );
panim->rotation = g_defaultrotation;
panim->scale = 1.0f;
panim->fps = 30.0;
panim->motionrollback = g_flDefaultMotionRollback;
ParseAnimation( panim, false );
panim->numframes = panim->endframe - panim->startframe + 1;
//CheckAutoShareAnimationGroup( panim->name );
}
//-----------------------------------------------------------------------------
// Purpose: wrapper for parsing $animation tokens
//-----------------------------------------------------------------------------
int ParseAnimation( s_animation_t *panim, bool isAppend )
{
int depth = 0;
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return 1;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
else if (ParseAnimationToken( panim ))
{
}
else
{
TokenError( "Unknown animation option\'%s\'\n", token );
}
if (depth < 0)
{
TokenError("missing {\n");
}
};
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: create a virtual $animation command from a $sequence reference
//-----------------------------------------------------------------------------
s_animation_t *Cmd_ImpliedAnimation( s_sequence_t *psequence, const char *filename )
{
// allocate animation entry
g_panimation[g_numani] = (s_animation_t *)kalloc( 1, sizeof( s_animation_t ) );
g_panimation[g_numani]->index = g_numani;
s_animation_t *panim = g_panimation[g_numani];
g_numani++;
panim->isImplied = true;
panim->startframe = 0;
panim->endframe = MAXSTUDIOANIMFRAMES - 1;
V_strcpy_safe( panim->name, "@" );
V_strcat_safe( panim->name, psequence->name );
V_strcpy_safe( panim->filename, filename );
VectorCopy( g_defaultadjust, panim->adjust );
panim->scale = 1.0f;
panim->rotation = g_defaultrotation;
panim->fps = 30;
panim->motionrollback = g_flDefaultMotionRollback;
//panim->source = Load_Source( panim->filename, "smd" );
panim->source = Load_Source( panim->filename, "" );
if ( panim->source->m_Animations.Count() )
{
s_sourceanim_t *pSourceAnim = &panim->source->m_Animations[0];
Q_strncpy( panim->animationname, panim->source->m_Animations[0].animationname, sizeof(panim->animationname) );
if ( panim->startframe < pSourceAnim->startframe )
{
panim->startframe = pSourceAnim->startframe;
}
if ( panim->endframe > pSourceAnim->endframe )
{
panim->endframe = pSourceAnim->endframe;
}
}
else
{
Q_strncpy( panim->animationname, "", sizeof( panim->animationname ) );
}
if ( !g_bCreateMakefile && panim->endframe < panim->startframe )
{
TokenError( "end frame before start frame in %s", panim->name );
}
panim->numframes = panim->endframe - panim->startframe + 1;
//CheckAutoShareAnimationGroup( panim->name );
return panim;
}
//-----------------------------------------------------------------------------
// Purpose: copy globally reavent $animation options from one $animation to another
//-----------------------------------------------------------------------------
void CopyAnimationSettings( s_animation_t *pdest, s_animation_t *psrc )
{
pdest->fps = psrc->fps;
VectorCopy( psrc->adjust, pdest->adjust );
pdest->scale = psrc->scale;
pdest->rotation = psrc->rotation;
pdest->motiontype = psrc->motiontype;
//Adrian - Hey! Revisit me later.
/*if (pdest->startframe < psrc->startframe)
pdest->startframe = psrc->startframe;
if (pdest->endframe > psrc->endframe)
pdest->endframe = psrc->endframe;
if (pdest->endframe < pdest->startframe)
TokenError( "fixedup end frame before start frame in %s", pdest->name );
pdest->numframes = pdest->endframe - pdest->startframe + 1;*/
for (int i = 0; i < psrc->numcmds; i++)
{
if (pdest->numcmds >= MAXSTUDIOCMDS)
{
TokenError("Too many cmds in %s\n", pdest->name );
}
pdest->cmds[pdest->numcmds++] = psrc->cmds[i];
}
}
int ParseSequence( s_sequence_t *pseq, bool isAppend );
//-----------------------------------------------------------------------------
// Purpose: allocate an entry for $sequence
//-----------------------------------------------------------------------------
s_sequence_t *ProcessCmdSequence( const char *pSequenceName )
{
s_animation_t *panim = LookupAnimation( pSequenceName );
// allocate sequence
if ( panim != NULL )
{
if ( !panim->isOverride )
{
TokenError( "Duplicate sequence name \"%s\"\n", pSequenceName );
}
else
{
panim->doesOverride = true;
return NULL;
}
}
if ( g_sequence.Count() >= MAXSTUDIOSEQUENCES )
{
TokenError("Too many sequences (%d max)\n", MAXSTUDIOSEQUENCES );
}
s_sequence_t *pseq = &g_sequence[ g_sequence.AddToTail() ];
memset( pseq, 0, sizeof( s_sequence_t ) );
// initialize sequence
Q_strncpy( pseq->name, pSequenceName, sizeof(pseq->name) );
pseq->actweight = 0;
pseq->activityname[0] = '\0';
pseq->activity = -1; // -1 is the default for 'no activity'
pseq->paramindex[0] = -1;
pseq->paramindex[1] = -1;
pseq->groupsize[0] = 0;
pseq->groupsize[1] = 0;
pseq->fadeintime = 0.2;
pseq->fadeouttime = 0.2;
return pseq;
}
//-----------------------------------------------------------------------------
// Process the sequence command
//-----------------------------------------------------------------------------
void Cmd_Sequence( )
{
if ( !GetToken(false) )
return;
// Find existing sequences
const char *pSequenceName = token;
s_animation_t *panim = LookupAnimation( pSequenceName );
if ( panim != NULL && panim->isOverride )
{
ParseEmpty( );
}
s_sequence_t *pseq = ProcessCmdSequence( pSequenceName );
if ( pseq )
{
ParseSequence( pseq, false );
}
}
//-----------------------------------------------------------------------------
// Performs processing on a sequence
//-----------------------------------------------------------------------------
void ProcessSequence( s_sequence_t *pseq, int numblends, s_animation_t **animations, bool isAppend )
{
if (isAppend)
return;
if ( numblends == 0 )
{
TokenError("no animations found\n");
}
if ( pseq->groupsize[0] == 0 )
{
if (numblends < 4)
{
pseq->groupsize[0] = numblends;
pseq->groupsize[1] = 1;
}
else
{
int i = sqrt( (float) numblends );
if (i * i == numblends)
{
pseq->groupsize[0] = i;
pseq->groupsize[1] = i;
}
else
{
TokenError( "non-square (%d) number of blends without \"blendwidth\" set\n", numblends );
}
}
}
else
{
pseq->groupsize[1] = numblends / pseq->groupsize[0];
if (pseq->groupsize[0] * pseq->groupsize[1] != numblends)
{
TokenError( "missing animation blends. Expected %d, found %d\n",
pseq->groupsize[0] * pseq->groupsize[1], numblends );
}
}
for (int i = 0; i < numblends; i++)
{
int j = i % pseq->groupsize[0];
int k = i / pseq->groupsize[0];
pseq->panim[j][k] = animations[i];
if (i > 0 && animations[i]->isImplied)
{
CopyAnimationSettings( animations[i], animations[0] );
}
animations[i]->isImplied = false; // don't copy any more commands
pseq->flags |= animations[i]->flags;
}
pseq->numblends = numblends;
}
//-----------------------------------------------------------------------------
// Purpose: parse options unique to $sequence
//-----------------------------------------------------------------------------
int ParseSequence( s_sequence_t *pseq, bool isAppend )
{
int depth = 0;
s_animation_t *animations[64];
int i, j, n;
int numblends = 0;
if (isAppend)
{
animations[0] = pseq->panim[0][0];
}
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return 1;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
/*
else if (stricmp("deform", token ) == 0)
{
Option_Deform( pseq );
}
*/
else if (stricmp("event", token ) == 0)
{
depth -= Option_Event( pseq );
}
else if (stricmp("activity", token ) == 0)
{
Option_Activity( pseq );
}
else if (stricmp("activitymodifier", token ) == 0)
{
Option_ActivityModifier( pseq );
}
else if (strnicmp( token, "ACT_", 4 ) == 0)
{
UnGetToken( );
Option_Activity( pseq );
}
else if (stricmp("snap", token ) == 0)
{
pseq->flags |= STUDIO_SNAP;
}
else if (stricmp("blendwidth", token ) == 0)
{
GetToken( false );
pseq->groupsize[0] = verify_atoi( token );
}
else if (stricmp("blend", token ) == 0)
{
i = 0;
if (pseq->paramindex[0] != -1)
{
i = 1;
}
GetToken( false );
j = LookupPoseParameter( token );
pseq->paramindex[i] = j;
pseq->paramattachment[i] = -1;
GetToken( false );
pseq->paramstart[i] = verify_atof( token );
GetToken( false );
pseq->paramend[i] = verify_atof( token );
g_pose[j].min = min( g_pose[j].min, pseq->paramstart[i] );
g_pose[j].min = min( g_pose[j].min, pseq->paramend[i] );
g_pose[j].max = max( g_pose[j].max, pseq->paramstart[i] );
g_pose[j].max = max( g_pose[j].max, pseq->paramend[i] );
}
else if (stricmp("calcblend", token ) == 0)
{
i = 0;
if (pseq->paramindex[0] != -1)
{
i = 1;
}
GetToken( false );
j = LookupPoseParameter( token );
pseq->paramindex[i] = j;
GetToken( false );
pseq->paramattachment[i] = LookupAttachment( token );
if (pseq->paramattachment[i] == -1)
{
TokenError( "Unknown calcblend attachment \"%s\"\n", token );
}
GetToken( false );
pseq->paramcontrol[i] = lookupControl( token );
}
else if (stricmp("blendref", token ) == 0)
{
GetToken( false );
pseq->paramanim = LookupAnimation( token );
if (pseq->paramanim == NULL)
{
TokenError( "Unknown blendref animation \"%s\"\n", token );
}
}
else if (stricmp("blendcomp", token ) == 0)
{
GetToken( false );
pseq->paramcompanim = LookupAnimation( token );
if (pseq->paramcompanim == NULL)
{
TokenError( "Unknown blendcomp animation \"%s\"\n", token );
}
}
else if (stricmp("blendcenter", token ) == 0)
{
GetToken( false );
pseq->paramcenter = LookupAnimation( token );
if (pseq->paramcenter == NULL)
{
TokenError( "Unknown blendcenter animation \"%s\"\n", token );
}
}
else if (stricmp("node", token ) == 0)
{
GetToken( false );
pseq->entrynode = pseq->exitnode = LookupXNode( token );
}
else if (stricmp("transition", token ) == 0)
{
GetToken( false );
pseq->entrynode = LookupXNode( token );
GetToken( false );
pseq->exitnode = LookupXNode( token );
}
else if (stricmp("rtransition", token ) == 0)
{
GetToken( false );
pseq->entrynode = LookupXNode( token );
GetToken( false );
pseq->exitnode = LookupXNode( token );
pseq->nodeflags |= 1;
}
else if (stricmp("exitphase", token ) == 0)
{
GetToken( false );
pseq->exitphase = verify_atof( token );
}
else if (stricmp("delta", token) == 0)
{
pseq->flags |= STUDIO_DELTA;
pseq->flags |= STUDIO_POST;
}
else if (stricmp("worldspace", token) == 0)
{
pseq->flags |= STUDIO_WORLD;
pseq->flags |= STUDIO_POST;
}
else if (stricmp("post", token) == 0) // remove
{
pseq->flags |= STUDIO_POST;
}
else if (stricmp("predelta", token) == 0)
{
pseq->flags |= STUDIO_DELTA;
}
else if (stricmp("autoplay", token) == 0)
{
pseq->flags |= STUDIO_AUTOPLAY;
}
else if (stricmp( "fadein", token ) == 0)
{
GetToken( false );
pseq->fadeintime = verify_atof( token );
}
else if (stricmp( "fadeout", token ) == 0)
{
GetToken( false );
pseq->fadeouttime = verify_atof( token );
}
else if (stricmp( "realtime", token ) == 0)
{
pseq->flags |= STUDIO_REALTIME;
}
else if (stricmp( "posecycle", token ) == 0)
{
pseq->flags |= STUDIO_CYCLEPOSE;
GetToken( false );
pseq->cycleposeindex = LookupPoseParameter( token );
}
else if (stricmp( "hidden", token ) == 0)
{
pseq->flags |= STUDIO_HIDDEN;
}
else if (stricmp( "addlayer", token ) == 0)
{
GetToken( false );
V_strcpy_safe( pseq->autolayer[pseq->numautolayers].name, token );
pseq->numautolayers++;
}
else if (stricmp( "iklock", token ) == 0)
{
GetToken(false);
V_strcpy_safe( pseq->iklock[pseq->numiklocks].name, token );
GetToken(false);
pseq->iklock[pseq->numiklocks].flPosWeight = verify_atof( token );
GetToken(false);
pseq->iklock[pseq->numiklocks].flLocalQWeight = verify_atof( token );
pseq->numiklocks++;
}
else if (stricmp( "keyvalues", token ) == 0)
{
Option_KeyValues( &pseq->KeyValue );
}
else if (stricmp( "blendlayer", token ) == 0)
{
pseq->autolayer[pseq->numautolayers].flags = 0;
GetToken( false );
V_strcpy_safe( pseq->autolayer[pseq->numautolayers].name, token );
GetToken( false );
pseq->autolayer[pseq->numautolayers].start = verify_atof( token );
GetToken( false );
pseq->autolayer[pseq->numautolayers].peak = verify_atof( token );
GetToken( false );
pseq->autolayer[pseq->numautolayers].tail = verify_atof( token );
GetToken( false );
pseq->autolayer[pseq->numautolayers].end = verify_atof( token );
while (TokenAvailable( ))
{
GetToken( false );
if (stricmp( "xfade", token ) == 0)
{
pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_XFADE;
}
else if (stricmp( "spline", token ) == 0)
{
pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_SPLINE;
}
else if (stricmp( "noblend", token ) == 0)
{
pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_NOBLEND;
}
else if (stricmp( "poseparameter", token ) == 0)
{
pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_POSE;
GetToken( false );
pseq->autolayer[pseq->numautolayers].pose = LookupPoseParameter( token );
}
else if (stricmp( "local", token ) == 0)
{
pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_LOCAL;
pseq->flags |= STUDIO_LOCAL;
}
else
{
UnGetToken();
break;
}
}
pseq->numautolayers++;
}
else if ((numblends || isAppend) && ParseAnimationToken( animations[0] ))
{
}
else if (!isAppend)
{
// assume it's an animation reference
// first look up an existing animation
for (n = 0; n < g_numani; n++)
{
if (stricmp( token, g_panimation[n]->name ) == 0)
{
animations[numblends++] = g_panimation[n];
break;
}
}
if (n >= g_numani)
{
// assume it's an implied animation
animations[numblends++] = Cmd_ImpliedAnimation( pseq, token );
}
// hack to allow animation commands to refer to same sequence
if (numblends == 1)
{
pseq->panim[0][0] = animations[0];
}
}
else
{
TokenError( "unknown command \"%s\"\n", token );
}
if (depth < 0)
{
TokenError("missing {\n");
}
}
ProcessSequence( pseq, numblends, animations, isAppend );
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: throw away all the options for a specific sequence or animation
//-----------------------------------------------------------------------------
int ParseEmpty( )
{
int depth = 0;
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return 1;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
if (depth < 0)
{
TokenError("missing {\n");
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: append commands to either a sequence or an animation
//-----------------------------------------------------------------------------
void Cmd_Append( )
{
GetToken(false);
s_sequence_t *pseq = LookupSequence( token );
if (pseq)
{
ParseSequence( pseq, true );
return;
}
else
{
s_animation_t *panim = LookupAnimation( token );
if (panim)
{
ParseAnimation( panim, true );
return;
}
}
TokenError( "unknown append animation %s\n", token );
}
void Cmd_Prepend( )
{
GetToken(false);
s_sequence_t *pseq = LookupSequence( token );
int count = 0;
s_animation_t *panim = NULL;
int iRet = false;
if (pseq)
{
panim = pseq->panim[0][0];
count = panim->numcmds;
iRet = ParseSequence( pseq, true );
}
else
{
panim = LookupAnimation( token );
if (panim)
{
count = panim->numcmds;
iRet = ParseAnimation( panim, true );
}
}
if (panim && count != panim->numcmds)
{
s_animcmd_t tmp;
tmp = panim->cmds[panim->numcmds - 1];
int i;
for (i = panim->numcmds - 1; i > 0; i--)
{
panim->cmds[i] = panim->cmds[i-1];
}
panim->cmds[0] = tmp;
return;
}
TokenError( "unknown prepend animation \"%s\"\n", token );
}
void Cmd_Continue( )
{
GetToken(false);
s_sequence_t *pseq = LookupSequence( token );
if (pseq)
{
GetToken(true);
UnGetToken();
if (token[0] != '$')
ParseSequence( pseq, true );
return;
}
else
{
s_animation_t *panim = LookupAnimation( token );
if (panim)
{
GetToken(true);
UnGetToken();
if (token[0] != '$')
ParseAnimation( panim, true );
return;
}
}
TokenError( "unknown continue animation %s\n", token );
}
//-----------------------------------------------------------------------------
// Purpose: foward declare an empty sequence
//-----------------------------------------------------------------------------
void Cmd_DeclareSequence( void )
{
if (g_sequence.Count() >= MAXSTUDIOSEQUENCES)
{
TokenError("Too many sequences (%d max)\n", MAXSTUDIOSEQUENCES );
}
s_sequence_t *pseq = &g_sequence[ g_sequence.AddToTail() ];
memset( pseq, 0, sizeof( s_sequence_t ) );
pseq->flags = STUDIO_OVERRIDE;
// initialize sequence
GetToken( false );
V_strcpy_safe( pseq->name, token );
}
//-----------------------------------------------------------------------------
// Purpose: foward declare an empty sequence
//-----------------------------------------------------------------------------
void Cmd_DeclareAnimation( void )
{
if (g_numani >= MAXSTUDIOANIMS)
{
TokenError("Too many animations (%d max)\n", MAXSTUDIOANIMS );
}
// allocate animation entry
s_animation_t *panim = (s_animation_t *)kalloc( 1, sizeof( s_animation_t ) );
g_panimation[g_numani] = panim;
panim->index = g_numani;
panim->flags = STUDIO_OVERRIDE;
g_numani++;
// initialize animation
GetToken( false );
V_strcpy_safe( panim->name, token );
}
//-----------------------------------------------------------------------------
// Purpose: create named list of boneweights
//-----------------------------------------------------------------------------
void Option_Weightlist( s_weightlist_t *pweightlist )
{
int depth = 0;
int i;
pweightlist->numbones = 0;
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
else if (stricmp("posweight", token ) == 0)
{
i = pweightlist->numbones - 1;
if (i < 0)
{
MdlError( "Error with specifing bone Position weight \'%s:%s\'\n", pweightlist->name, pweightlist->bonename[i] );
}
GetToken( false );
pweightlist->boneposweight[i] = verify_atof( token );
if (pweightlist->boneweight[i] == 0 && pweightlist->boneposweight[i] > 0)
{
MdlError( "Non-zero Position weight with zero Rotation weight not allowed \'%s:%s %f %f\'\n",
pweightlist->name, pweightlist->bonename[i], pweightlist->boneweight[i], pweightlist->boneposweight[i] );
}
}
else
{
i = pweightlist->numbones++;
if (i >= MAXWEIGHTSPERLIST)
{
TokenError("Too many bones (%d) in weightlist '%s'\n", i, pweightlist->name );
}
pweightlist->bonename[i] = strdup( token );
GetToken( false );
pweightlist->boneweight[i] = verify_atof( token );
pweightlist->boneposweight[i] = pweightlist->boneweight[i];
}
if (depth < 0)
{
TokenError("missing {\n");
}
};
}
void Cmd_Weightlist( )
{
int i;
if (!GetToken(false))
return;
if (g_numweightlist >= MAXWEIGHTLISTS)
{
TokenError( "Too many weightlist commands (%d)\n", MAXWEIGHTLISTS );
}
for (i = 1; i < g_numweightlist; i++)
{
if (stricmp( g_weightlist[i].name, token ) == 0)
{
TokenError( "Duplicate weightlist '%s'\n", token );
}
}
V_strcpy_safe( g_weightlist[i].name, token );
Option_Weightlist( &g_weightlist[g_numweightlist] );
g_numweightlist++;
}
void Cmd_DefaultWeightlist( )
{
Option_Weightlist( &g_weightlist[0] );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Option_Eyeball( s_model_t *pmodel )
{
Vector tmp;
int i, j;
int mesh_material;
char szMeshMaterial[256];
s_eyeball_t *eyeball = &(pmodel->eyeball[pmodel->numeyeballs++]);
// name
GetToken (false);
V_strcpy_safe( eyeball->name, token );
// bone name
GetToken (false);
for (i = 0; i < pmodel->source->numbones; i++)
{
if ( !Q_stricmp( pmodel->source->localBone[i].name, token ) )
{
eyeball->bone = i;
break;
}
}
if (!g_bCreateMakefile && i >= pmodel->source->numbones)
{
TokenError( "unknown eyeball bone \"%s\"\n", token );
}
// X
GetToken (false);
tmp[0] = verify_atof (token);
// Y
GetToken (false);
tmp[1] = verify_atof (token);
// Z
GetToken (false);
tmp[2] = verify_atof (token);
// mesh material
GetToken (false);
Q_strncpy( szMeshMaterial, token, sizeof(szMeshMaterial) );
mesh_material = UseTextureAsMaterial( LookupTexture( token ) );
// diameter
GetToken (false);
eyeball->radius = verify_atof (token) / 2.0;
// Z angle offset
GetToken (false);
eyeball->zoffset = tan( DEG2RAD( verify_atof (token) ) );
// iris material (no longer used, but we need to remove the token)
GetToken (false);
// pupil scale
GetToken (false);
eyeball->iris_scale = 1.0 / verify_atof( token );
VectorCopy( tmp, eyeball->org );
for (i = 0; i < pmodel->source->nummeshes; i++)
{
j = pmodel->source->meshindex[i]; // meshes are internally stored by material index
if (j == mesh_material)
{
eyeball->mesh = i; // FIXME: should this be pre-adjusted?
break;
}
}
if (!g_bCreateMakefile && i >= pmodel->source->nummeshes)
{
TokenError("can't find eyeball texture \"%s\" on model\n", szMeshMaterial );
}
// translate eyeball into bone space
VectorITransform( tmp, pmodel->source->boneToPose[eyeball->bone], eyeball->org );
matrix3x4_t vtmp;
AngleMatrix( g_defaultrotation, vtmp );
VectorIRotate( Vector( 0, 0, 1 ), vtmp, tmp );
VectorIRotate( tmp, pmodel->source->boneToPose[eyeball->bone], eyeball->up );
VectorIRotate( Vector( 1, 0, 0 ), vtmp, tmp );
VectorIRotate( tmp, pmodel->source->boneToPose[eyeball->bone], eyeball->forward );
// these get overwritten by "eyelid" data
eyeball->upperlidflexdesc = -1;
eyeball->lowerlidflexdesc = -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Option_Spherenormals( s_source_t *psource )
{
Vector pos;
int i, j;
int mesh_material;
char szMeshMaterial[256];
// mesh material
GetToken (false);
V_strcpy_safe( szMeshMaterial, token );
mesh_material = UseTextureAsMaterial( LookupTexture( token ) );
// X
GetToken (false);
pos[0] = verify_atof (token);
// Y
GetToken (false);
pos[1] = verify_atof (token);
// Z
GetToken (false);
pos[2] = verify_atof (token);
for (i = 0; i < psource->nummeshes; i++)
{
j = psource->meshindex[i]; // meshes are internally stored by material index
if (j == mesh_material)
{
s_vertexinfo_t *vertex = &psource->vertex[psource->mesh[i].vertexoffset];
for (int k = 0; k < psource->mesh[i].numvertices; k++)
{
Vector n = vertex[k].position - pos;
VectorNormalize( n );
if (DotProduct( n, vertex[k].normal ) < 0.0)
{
vertex[k].normal = -1 * n;
}
else
{
vertex[k].normal = n;
}
#if 0
vertex[k].normal[0] += 0.5f * ( 2.0f * ( ( float )rand() ) / ( float )VALVE_RAND_MAX ) - 1.0f;
vertex[k].normal[1] += 0.5f * ( 2.0f * ( ( float )rand() ) / ( float )VALVE_RAND_MAX ) - 1.0f;
vertex[k].normal[2] += 0.5f * ( 2.0f * ( ( float )rand() ) / ( float )VALVE_RAND_MAX ) - 1.0f;
VectorNormalize( vertex[k].normal );
#endif
}
break;
}
}
if (i >= psource->nummeshes)
{
TokenError("can't find spherenormal texture \"%s\" on model\n", szMeshMaterial );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int Add_Flexdesc( const char *name )
{
int flexdesc;
for ( flexdesc = 0; flexdesc < g_numflexdesc; flexdesc++)
{
if (stricmp( name, g_flexdesc[flexdesc].FACS ) == 0)
{
break;
}
}
if (flexdesc >= MAXSTUDIOFLEXDESC)
{
TokenError( "Too many flex types, max %d\n", MAXSTUDIOFLEXDESC );
}
if (flexdesc == g_numflexdesc)
{
V_strcpy_safe( g_flexdesc[flexdesc].FACS, name );
g_numflexdesc++;
}
return flexdesc;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Option_Flex( char *name, char *vtafile, int imodel, float pairsplit )
{
if (g_numflexkeys >= MAXSTUDIOFLEXKEYS)
{
TokenError( "Too many flexes, max %d\n", MAXSTUDIOFLEXKEYS );
}
int flexdesc, flexpair;
if (pairsplit != 0)
{
char mod[256];
sprintf( mod, "%sR", name );
flexdesc = Add_Flexdesc( mod );
sprintf( mod, "%sL", name );
flexpair = Add_Flexdesc( mod );
}
else
{
flexdesc = Add_Flexdesc( name );
flexpair = 0;
}
// initialize
g_flexkey[g_numflexkeys].imodel = imodel;
g_flexkey[g_numflexkeys].flexdesc = flexdesc;
g_flexkey[g_numflexkeys].target0 = 0.0;
g_flexkey[g_numflexkeys].target1 = 1.0;
g_flexkey[g_numflexkeys].target2 = 10;
g_flexkey[g_numflexkeys].target3 = 11;
g_flexkey[g_numflexkeys].split = pairsplit;
g_flexkey[g_numflexkeys].flexpair = flexpair;
g_flexkey[g_numflexkeys].decay = 1.0;
while (TokenAvailable())
{
GetToken(false);
if (stricmp( token, "frame") == 0)
{
GetToken (false);
g_flexkey[g_numflexkeys].frame = verify_atoi( token );
}
else if (stricmp( token, "position") == 0)
{
GetToken (false);
g_flexkey[g_numflexkeys].target1 = verify_atof( token );
}
else if (stricmp( token, "split") == 0)
{
GetToken (false);
g_flexkey[g_numflexkeys].split = verify_atof( token );
}
else if (stricmp( token, "decay") == 0)
{
GetToken (false);
g_flexkey[g_numflexkeys].decay = verify_atof( token );
}
else
{
TokenError( "unknown option: %s", token );
}
}
if (g_numflexkeys > 1)
{
if (g_flexkey[g_numflexkeys-1].flexdesc == g_flexkey[g_numflexkeys].flexdesc)
{
g_flexkey[g_numflexkeys-1].target2 = g_flexkey[g_numflexkeys-1].target1;
g_flexkey[g_numflexkeys-1].target3 = g_flexkey[g_numflexkeys].target1;
g_flexkey[g_numflexkeys].target0 = g_flexkey[g_numflexkeys-1].target1;
}
}
// link to source
s_source_t *pSource = Load_Source( vtafile, "vta" );
g_flexkey[g_numflexkeys].source = pSource;
if ( pSource->m_Animations.Count() )
{
Q_strncpy( g_flexkey[g_numflexkeys].animationname, pSource->m_Animations[0].animationname, sizeof( g_flexkey[g_numflexkeys].animationname ) );
}
else
{
g_flexkey[g_numflexkeys].animationname[0] = 0;
}
g_numflexkeys++;
// this needs to be per model.
}
//-----------------------------------------------------------------------------
// Adds combination data to the source
//-----------------------------------------------------------------------------
int FindSourceFlexKey( s_source_t *pSource, const char *pName )
{
int nCount = pSource->m_FlexKeys.Count();
for ( int i = 0; i < nCount; ++i )
{
if ( !Q_stricmp( pSource->m_FlexKeys[i].animationname, pName ) )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
// Adds flexkey data to a particular source
//-----------------------------------------------------------------------------
void AddFlexKey( s_source_t *pSource, CDmeCombinationOperator *pComboOp, const char *pFlexKeyName )
{
// See if the delta state is already accounted for
if ( FindSourceFlexKey( pSource, pFlexKeyName ) >= 0 )
return;
int i = pSource->m_FlexKeys.AddToTail();
s_flexkey_t &key = pSource->m_FlexKeys[i];
memset( &key, 0, sizeof(key) );
key.target0 = 0.0f;
key.target1 = 1.0f;
key.target2 = 10.0f;
key.target3 = 11.0f;
key.decay = 1.0f;
key.source = pSource;
Q_strncpy( key.animationname, pFlexKeyName, sizeof(key.animationname) );
key.flexpair = pComboOp->IsDeltaStateStereo( pFlexKeyName ); // Signal used by AddBodyFlexData
}
//-----------------------------------------------------------------------------
// Adds combination data to the source
//-----------------------------------------------------------------------------
void AddCombination( s_source_t *pSource, CDmeCombinationOperator *pCombination )
{
// Define the remapped controls
int nControlCount = pCombination->GetRawControlCount();
for ( int i = 0; i < nControlCount; ++i )
{
int m = pSource->m_CombinationControls.AddToTail();
s_combinationcontrol_t &control = pSource->m_CombinationControls[m];
Q_strncpy( control.name, pCombination->GetRawControlName( i ), sizeof(control.name) );
}
// Define the combination + domination rules
int nTargetCount = pCombination->GetOperationTargetCount();
for ( int i = 0; i < nTargetCount; ++i )
{
int nOpCount = pCombination->GetOperationCount( i );
for ( int j = 0; j < nOpCount; ++j )
{
CDmElement *pDeltaState = pCombination->GetOperationDeltaState( i, j );
if ( !pDeltaState )
continue;
int nFlex = FindSourceFlexKey( pSource, pDeltaState->GetName() );
if ( nFlex < 0 )
continue;
int k = pSource->m_CombinationRules.AddToTail();
s_combinationrule_t &rule = pSource->m_CombinationRules[k];
rule.m_nFlex = nFlex;
rule.m_Combination = pCombination->GetOperationControls( i, j );
int nDominatorCount = pCombination->GetOperationDominatorCount( i, j );
for ( int l = 0; l < nDominatorCount; ++l )
{
int m = rule.m_Dominators.AddToTail();
rule.m_Dominators[m] = pCombination->GetOperationDominator( i, j, l );
}
}
}
// Define the remapping controls
nControlCount = pCombination->GetControlCount();
for ( int i = 0; i < nControlCount; ++i )
{
int k = pSource->m_FlexControllerRemaps.AddToTail();
s_flexcontrollerremap_t &remap = pSource->m_FlexControllerRemaps[k];
remap.m_Name = pCombination->GetControlName( i );
remap.m_bIsStereo = pCombination->IsStereoControl( i );
remap.m_Index = -1; // Don't know this right now
remap.m_LeftIndex = -1; // Don't know this right now
remap.m_RightIndex = -1; // Don't know this right now
remap.m_MultiIndex = -1; // Don't know this right now
remap.m_EyesUpDownFlexController = -1;
remap.m_BlinkController = -1;
int nRemapCount = pCombination->GetRawControlCount( i );
if ( pCombination->IsEyelidControl( i ) )
{
remap.m_RemapType = FLEXCONTROLLER_REMAP_EYELID;
// Save the eyes_updown flex for later
const char *pEyesUpDownFlexName = pCombination->GetEyesUpDownFlexName( i );
remap.m_EyesUpDownFlexName = pEyesUpDownFlexName ? pEyesUpDownFlexName : "eyes_updown";
}
else
{
switch( nRemapCount )
{
case 0:
case 1:
remap.m_RemapType = FLEXCONTROLLER_REMAP_PASSTHRU;
break;
case 2:
remap.m_RemapType = FLEXCONTROLLER_REMAP_2WAY;
break;
default:
remap.m_RemapType = FLEXCONTROLLER_REMAP_NWAY;
break;
}
}
Assert( nRemapCount != 0 );
for ( int j = 0; j < nRemapCount; ++j )
{
const char *pRemapName = pCombination->GetRawControlName( i, j );
remap.m_RawControls.AddToTail( pRemapName );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Option_Eyelid( int imodel )
{
char type[256];
char vtafile[256];
// type
GetToken (false);
V_strcpy_safe( type, token );
// source
GetToken (false);
V_strcpy_safe( vtafile, token );
int lowererframe = 0;
int neutralframe = 0;
int raiserframe = 0;
float lowerertarget = 0.0f;
float neutraltarget = 0.0f;
float raisertarget = 0.0f;
int lowererdesc = 0;
int neutraldesc = 0;
int raiserdesc = 0;
int basedesc;
float split = 0;
char szEyeball[64] = {""};
basedesc = g_numflexdesc;
V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, type );
while (TokenAvailable())
{
GetToken(false);
char localdesc[256];
V_strcpy_safe( localdesc, type );
V_strcat_safe( localdesc, "_" );
V_strcat_safe( localdesc, token );
if (stricmp( token, "lowerer") == 0)
{
GetToken (false);
lowererframe = verify_atoi( token );
GetToken (false);
lowerertarget = verify_atof( token );
lowererdesc = g_numflexdesc;
V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, localdesc );
}
else if (stricmp( token, "neutral") == 0)
{
GetToken (false);
neutralframe = verify_atoi( token );
GetToken (false);
neutraltarget = verify_atof( token );
neutraldesc = g_numflexdesc;
V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, localdesc );
}
else if (stricmp( token, "raiser") == 0)
{
GetToken (false);
raiserframe = verify_atoi( token );
GetToken (false);
raisertarget = verify_atof( token );
raiserdesc = g_numflexdesc;
V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, localdesc );
}
else if (stricmp( token, "split") == 0)
{
GetToken (false);
split = verify_atof( token );
}
else if (stricmp( token, "eyeball") == 0)
{
GetToken (false);
V_strcpy_safe( szEyeball, token );
}
else
{
TokenError( "unknown option: %s", token );
}
}
s_source_t *pSource = Load_Source( vtafile, "vta" );
g_flexkey[g_numflexkeys+0].source = pSource;
g_flexkey[g_numflexkeys+0].frame = lowererframe;
g_flexkey[g_numflexkeys+0].flexdesc = basedesc;
g_flexkey[g_numflexkeys+0].imodel = imodel;
g_flexkey[g_numflexkeys+0].split = split;
g_flexkey[g_numflexkeys+0].target0 = -11;
g_flexkey[g_numflexkeys+0].target1 = -10;
g_flexkey[g_numflexkeys+0].target2 = lowerertarget;
g_flexkey[g_numflexkeys+0].target3 = neutraltarget;
g_flexkey[g_numflexkeys+0].decay = 0.0;
if ( pSource->m_Animations.Count() > 0 )
{
Q_strncpy( g_flexkey[g_numflexkeys+0].animationname, pSource->m_Animations[0].animationname, sizeof(g_flexkey[g_numflexkeys+0].animationname) );
}
else
{
g_flexkey[g_numflexkeys+0].animationname[0] = 0;
}
g_flexkey[g_numflexkeys+1].source = g_flexkey[g_numflexkeys+0].source;
Q_strncpy( g_flexkey[g_numflexkeys+1].animationname, g_flexkey[g_numflexkeys+0].animationname, sizeof(g_flexkey[g_numflexkeys+1].animationname) );
g_flexkey[g_numflexkeys+1].frame = neutralframe;
g_flexkey[g_numflexkeys+1].flexdesc = basedesc;
g_flexkey[g_numflexkeys+1].imodel = imodel;
g_flexkey[g_numflexkeys+1].split = split;
g_flexkey[g_numflexkeys+1].target0 = lowerertarget;
g_flexkey[g_numflexkeys+1].target1 = neutraltarget;
g_flexkey[g_numflexkeys+1].target2 = neutraltarget;
g_flexkey[g_numflexkeys+1].target3 = raisertarget;
g_flexkey[g_numflexkeys+1].decay = 0.0;
g_flexkey[g_numflexkeys+2].source = g_flexkey[g_numflexkeys+0].source;
Q_strncpy( g_flexkey[g_numflexkeys+2].animationname, g_flexkey[g_numflexkeys+0].animationname, sizeof(g_flexkey[g_numflexkeys+2].animationname) );
g_flexkey[g_numflexkeys+2].frame = raiserframe;
g_flexkey[g_numflexkeys+2].flexdesc = basedesc;
g_flexkey[g_numflexkeys+2].imodel = imodel;
g_flexkey[g_numflexkeys+2].split = split;
g_flexkey[g_numflexkeys+2].target0 = neutraltarget;
g_flexkey[g_numflexkeys+2].target1 = raisertarget;
g_flexkey[g_numflexkeys+2].target2 = 10;
g_flexkey[g_numflexkeys+2].target3 = 11;
g_flexkey[g_numflexkeys+2].decay = 0.0;
g_numflexkeys += 3;
s_model_t *pmodel = g_model[imodel];
for (int i = 0; i < pmodel->numeyeballs; i++)
{
s_eyeball_t *peyeball = &(pmodel->eyeball[i]);
if (szEyeball[0] != '\0')
{
if (stricmp( peyeball->name, szEyeball ) != 0)
continue;
}
if (fabs( lowerertarget ) > peyeball->radius)
{
TokenError( "Eyelid \"%s\" lowerer out of range (+-%.1f)\n", type, peyeball->radius );
}
if (fabs( neutraltarget ) > peyeball->radius)
{
TokenError( "Eyelid \"%s\" neutral out of range (+-%.1f)\n", type, peyeball->radius );
}
if (fabs( raisertarget ) > peyeball->radius)
{
TokenError( "Eyelid \"%s\" raiser out of range (+-%.1f)\n", type, peyeball->radius );
}
switch( type[0] )
{
case 'u':
peyeball->upperlidflexdesc = basedesc;
peyeball->upperflexdesc[0] = lowererdesc;
peyeball->uppertarget[0] = lowerertarget;
peyeball->upperflexdesc[1] = neutraldesc;
peyeball->uppertarget[1] = neutraltarget;
peyeball->upperflexdesc[2] = raiserdesc;
peyeball->uppertarget[2] = raisertarget;
break;
case 'l':
peyeball->lowerlidflexdesc = basedesc;
peyeball->lowerflexdesc[0] = lowererdesc;
peyeball->lowertarget[0] = lowerertarget;
peyeball->lowerflexdesc[1] = neutraldesc;
peyeball->lowertarget[1] = neutraltarget;
peyeball->lowerflexdesc[2] = raiserdesc;
peyeball->lowertarget[2] = raisertarget;
break;
}
}
}
/*
=================
=================
*/
int Option_Mouth( s_model_t *pmodel )
{
// index
GetToken (false);
int index = verify_atoi( token );
if (index >= g_nummouths)
g_nummouths = index + 1;
// flex controller name
GetToken (false);
g_mouth[index].flexdesc = Add_Flexdesc( token );
// bone name
GetToken (false);
V_strcpy_safe( g_mouth[index].bonename, token );
// vector
GetToken (false);
g_mouth[index].forward[0] = verify_atof( token );
GetToken (false);
g_mouth[index].forward[1] = verify_atof( token );
GetToken (false);
g_mouth[index].forward[2] = verify_atof( token );
return 0;
}
void Option_Flexcontroller( s_model_t *pmodel )
{
char type[256];
float range_min = 0.0f;
float range_max = 1.0f;
// g_flex
GetToken (false);
V_strcpy_safe( type, token );
while (TokenAvailable())
{
GetToken(false);
if (stricmp( token, "range") == 0)
{
GetToken(false);
range_min = verify_atof( token );
GetToken(false);
range_max = verify_atof( token );
}
else
{
if (g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
{
TokenError( "Too many flex controllers, max %d\n", MAXSTUDIOFLEXCTRL );
}
V_strcpy_safe( g_flexcontroller[g_numflexcontrollers].name, token );
V_strcpy_safe( g_flexcontroller[g_numflexcontrollers].type, type );
g_flexcontroller[g_numflexcontrollers].min = range_min;
g_flexcontroller[g_numflexcontrollers].max = range_max;
g_numflexcontrollers++;
}
}
// this needs to be per model.
}
void Option_Flexrule( s_model_t *pmodel, char *name )
{
int precedence[32];
precedence[ STUDIO_CONST ] = 0;
precedence[ STUDIO_FETCH1 ] = 0;
precedence[ STUDIO_FETCH2 ] = 0;
precedence[ STUDIO_ADD ] = 1;
precedence[ STUDIO_SUB ] = 1;
precedence[ STUDIO_MUL ] = 2;
precedence[ STUDIO_DIV ] = 2;
precedence[ STUDIO_NEG ] = 4;
precedence[ STUDIO_EXP ] = 3;
precedence[ STUDIO_OPEN ] = 0; // only used in token parsing
precedence[ STUDIO_CLOSE ] = 0;
precedence[ STUDIO_COMMA ] = 0;
precedence[ STUDIO_MAX ] = 5;
precedence[ STUDIO_MIN ] = 5;
s_flexop_t stream[MAX_OPS];
int i = 0;
s_flexop_t stack[MAX_OPS];
int j = 0;
int k = 0;
s_flexrule_t *pRule = &g_flexrule[g_numflexrules++];
if (g_numflexrules > MAXSTUDIOFLEXRULES)
{
TokenError( "Too many flex rules (max %d)\n", MAXSTUDIOFLEXRULES );
}
int flexdesc;
for ( flexdesc = 0; flexdesc < g_numflexdesc; flexdesc++)
{
if (stricmp( name, g_flexdesc[flexdesc].FACS ) == 0)
{
break;
}
}
if (flexdesc >= g_numflexdesc)
{
TokenError( "Rule for unknown flex %s\n", name );
}
pRule->flex = flexdesc;
pRule->numops = 0;
// =
GetToken(false);
// parse all the tokens
bool linecontinue = false;
while ( linecontinue || TokenAvailable())
{
GetExprToken(linecontinue);
linecontinue = false;
if ( token[0] == '\\' )
{
if (!GetToken(false) || token[0] != '\\')
{
TokenError( "unknown expression token '\\%s\n", token );
}
linecontinue = true;
}
else if ( token[0] == '(' )
{
stream[i++].op = STUDIO_OPEN;
}
else if ( token[0] == ')' )
{
stream[i++].op = STUDIO_CLOSE;
}
else if ( token[0] == '+' )
{
stream[i++].op = STUDIO_ADD;
}
else if ( token[0] == '-' )
{
stream[i].op = STUDIO_SUB;
if (i > 0)
{
switch( stream[i-1].op )
{
case STUDIO_OPEN:
case STUDIO_ADD:
case STUDIO_SUB:
case STUDIO_MUL:
case STUDIO_DIV:
case STUDIO_COMMA:
// it's a unary if it's preceded by a "(+-*/,"?
stream[i].op = STUDIO_NEG;
break;
}
}
i++;
}
else if ( token[0] == '*' )
{
stream[i++].op = STUDIO_MUL;
}
else if ( token[0] == '/' )
{
stream[i++].op = STUDIO_DIV;
}
else if ( V_isdigit( token[0] ))
{
stream[i].op = STUDIO_CONST;
stream[i++].d.value = verify_atof( token );
}
else if ( token[0] == ',' )
{
stream[i++].op = STUDIO_COMMA;
}
else if ( stricmp( token, "max" ) == 0)
{
stream[i++].op = STUDIO_MAX;
}
else if ( stricmp( token, "min" ) == 0)
{
stream[i++].op = STUDIO_MIN;
}
else
{
if (token[0] == '%')
{
GetExprToken(false);
for (k = 0; k < g_numflexdesc; k++)
{
if (stricmp( token, g_flexdesc[k].FACS ) == 0)
{
stream[i].op = STUDIO_FETCH2;
stream[i++].d.index = k;
break;
}
}
if (k >= g_numflexdesc)
{
TokenError( "unknown flex %s\n", token );
}
}
else
{
for (k = 0; k < g_numflexcontrollers; k++)
{
if (stricmp( token, g_flexcontroller[k].name ) == 0)
{
stream[i].op = STUDIO_FETCH1;
stream[i++].d.index = k;
break;
}
}
if (k >= g_numflexcontrollers)
{
TokenError( "unknown controller %s\n", token );
}
}
}
}
if (i > MAX_OPS)
{
TokenError("expression %s too complicated\n", g_flexdesc[pRule->flex].FACS );
}
if (0)
{
printf("%s = ", g_flexdesc[pRule->flex].FACS );
for ( k = 0; k < i; k++)
{
switch( stream[k].op )
{
case STUDIO_CONST: printf("%f ", stream[k].d.value ); break;
case STUDIO_FETCH1: printf("%s ", g_flexcontroller[stream[k].d.index].name ); break;
case STUDIO_FETCH2: printf("[%d] ", stream[k].d.index ); break;
case STUDIO_ADD: printf("+ "); break;
case STUDIO_SUB: printf("- "); break;
case STUDIO_MUL: printf("* "); break;
case STUDIO_DIV: printf("/ "); break;
case STUDIO_NEG: printf("neg "); break;
case STUDIO_MAX: printf("max "); break;
case STUDIO_MIN: printf("min "); break;
case STUDIO_COMMA: printf(", "); break; // error
case STUDIO_OPEN: printf("( " ); break; // error
case STUDIO_CLOSE: printf(") " ); break; // error
default:
printf("err%d ", stream[k].op ); break;
}
}
printf("\n");
// exit(1);
}
j = 0;
for (k = 0; k < i; k++)
{
if (j >= MAX_OPS)
{
TokenError("expression %s too complicated\n", g_flexdesc[pRule->flex].FACS );
}
switch( stream[k].op )
{
case STUDIO_CONST:
case STUDIO_FETCH1:
case STUDIO_FETCH2:
pRule->op[pRule->numops++] = stream[k];
break;
case STUDIO_OPEN:
stack[j++] = stream[k];
break;
case STUDIO_CLOSE:
// pop all operators off of the stack until an open paren
while (j > 0 && stack[j-1].op != STUDIO_OPEN)
{
pRule->op[pRule->numops++] = stack[j-1];
j--;
}
if (j == 0)
{
TokenError( "unmatched closed parentheses\n" );
}
if (j > 0)
j--;
break;
case STUDIO_COMMA:
// pop all operators off of the stack until an open paren
while (j > 0 && stack[j-1].op != STUDIO_OPEN)
{
pRule->op[pRule->numops++] = stack[j-1];
j--;
}
// push operator onto the stack
stack[j++] = stream[k];
break;
case STUDIO_ADD:
case STUDIO_SUB:
case STUDIO_MUL:
case STUDIO_DIV:
// pop all operators off of the stack that have equal or higher precedence
while (j > 0 && precedence[stream[k].op] <= precedence[stack[j-1].op])
{
pRule->op[pRule->numops++] = stack[j-1];
j--;
}
// push operator onto the stack
stack[j++] = stream[k];
break;
case STUDIO_NEG:
if (stream[k+1].op == STUDIO_CONST)
{
// change sign of constant, skip op
stream[k+1].d.value = -stream[k+1].d.value;
}
else
{
// push operator onto the stack
stack[j++] = stream[k];
}
break;
case STUDIO_MAX:
case STUDIO_MIN:
// push operator onto the stack
stack[j++] = stream[k];
break;
}
if (pRule->numops >= MAX_OPS)
TokenError("expression for \"%s\" too complicated\n", g_flexdesc[pRule->flex].FACS );
}
// pop all operators off of the stack
while (j > 0)
{
pRule->op[pRule->numops++] = stack[j-1];
j--;
if (pRule->numops >= MAX_OPS)
TokenError("expression for \"%s\" too complicated\n", g_flexdesc[pRule->flex].FACS );
}
// reprocess the operands, eating commas for all functions
int numCommas = 0;
j = 0;
for (k = 0; k < pRule->numops; k++)
{
switch( pRule->op[k].op )
{
case STUDIO_MAX:
case STUDIO_MIN:
if (pRule->op[j-1].op != STUDIO_COMMA)
{
TokenError( "missing comma\n");
}
// eat the comma operator
numCommas--;
pRule->op[j-1] = pRule->op[k];
break;
case STUDIO_COMMA:
numCommas++;
pRule->op[j++] = pRule->op[k];
break;
default:
pRule->op[j++] = pRule->op[k];
break;
}
}
pRule->numops = j;
if (numCommas != 0)
{
TokenError( "too many comma's\n" );
}
if (pRule->numops > MAX_OPS)
{
TokenError("expression %s too complicated\n", g_flexdesc[pRule->flex].FACS );
}
if (0)
{
printf("%s = ", g_flexdesc[pRule->flex].FACS );
for ( i = 0; i < pRule->numops; i++)
{
switch( pRule->op[i].op )
{
case STUDIO_CONST: printf("%f ", pRule->op[i].d.value ); break;
case STUDIO_FETCH1: printf("%s ", g_flexcontroller[pRule->op[i].d.index].name ); break;
case STUDIO_FETCH2: printf("[%d] ", pRule->op[i].d.index ); break;
case STUDIO_ADD: printf("+ "); break;
case STUDIO_SUB: printf("- "); break;
case STUDIO_MUL: printf("* "); break;
case STUDIO_DIV: printf("/ "); break;
case STUDIO_NEG: printf("neg "); break;
case STUDIO_MAX: printf("max "); break;
case STUDIO_MIN: printf("min "); break;
case STUDIO_COMMA: printf(", "); break; // error
case STUDIO_OPEN: printf("( " ); break; // error
case STUDIO_CLOSE: printf(") " ); break; // error
default:
printf("err%d ", pRule->op[i].op ); break;
}
}
printf("\n");
// exit(1);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Model( )
{
g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
// name
if (!GetToken(false))
return;
V_strcpy_safe( g_model[g_nummodels]->name, token );
// fake g_bodypart stuff
if (g_numbodyparts == 0)
{
g_bodypart[g_numbodyparts].base = 1;
}
else
{
g_bodypart[g_numbodyparts].base = g_bodypart[g_numbodyparts-1].base * g_bodypart[g_numbodyparts-1].nummodels;
}
V_strcpy_safe( g_bodypart[g_numbodyparts].name, token );
g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
g_bodypart[g_numbodyparts].nummodels = 1;
g_numbodyparts++;
Option_Studio( g_model[g_nummodels] );
if ( g_model[g_nummodels]->source )
{
// Body command should add any flex commands in the source loaded
AddBodyFlexData( g_model[g_nummodels]->source, g_nummodels );
AddBodyAttachments( g_model[g_nummodels]->source );
}
int depth = 0;
while (1)
{
char FAC[256], vtafile[256];
if (depth > 0)
{
if( !GetToken(true) )
break;
}
else
{
if ( !TokenAvailable() )
{
break;
}
else
{
GetToken (false);
}
}
if ( endofscript )
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return;
}
if ( !Q_stricmp("{", token ) )
{
depth++;
}
else if ( !Q_stricmp("}", token ) )
{
depth--;
}
else if ( !Q_stricmp( "eyeball", token ) )
{
Option_Eyeball( g_model[g_nummodels] );
}
else if ( !Q_stricmp( "eyelid", token ) )
{
Option_Eyelid( g_nummodels );
}
else if ( !Q_stricmp( "flex", token ) )
{
// g_flex
GetToken (false);
V_strcpy_safe( FAC, token );
if (depth == 0)
{
// file
GetToken (false);
V_strcpy_safe( vtafile, token );
}
Option_Flex( FAC, vtafile, g_nummodels, 0.0 ); // FIXME: this needs to point to a model used, not loaded!!!
}
else if ( !Q_stricmp( "flexpair", token ) )
{
// g_flex
GetToken (false);
V_strcpy_safe( FAC, token );
GetToken( false );
float split = atof( token );
if (depth == 0)
{
// file
GetToken (false);
V_strcpy_safe( vtafile, token );
}
Option_Flex( FAC, vtafile, g_nummodels, split ); // FIXME: this needs to point to a model used, not loaded!!!
}
else if ( !Q_stricmp( "defaultflex", token ) )
{
if (depth == 0)
{
// file
GetToken (false);
V_strcpy_safe( vtafile, token );
}
// g_flex
Option_Flex( "default", vtafile, g_nummodels, 0.0 ); // FIXME: this needs to point to a model used, not loaded!!!
g_defaultflexkey = &g_flexkey[g_numflexkeys-1];
}
else if ( !Q_stricmp( "flexfile", token ) )
{
// file
GetToken (false);
V_strcpy_safe( vtafile, token );
}
else if ( !Q_stricmp( "localvar", token ) )
{
while (TokenAvailable())
{
GetToken( false );
Add_Flexdesc( token );
}
}
else if ( !Q_stricmp( "mouth", token ) )
{
Option_Mouth( g_model[g_nummodels] );
}
else if ( !Q_stricmp( "flexcontroller", token ) )
{
Option_Flexcontroller( g_model[g_nummodels] );
}
else if ( token[0] == '%' )
{
Option_Flexrule( g_model[g_nummodels], &token[1] );
}
else if ( !Q_stricmp("attachment", token ) )
{
// Option_Attachment( g_model[g_nummodels] );
}
else if ( !Q_stricmp( token, "spherenormals" ) )
{
Option_Spherenormals( g_model[g_nummodels]->source );
}
else
{
TokenError( "unknown model option \"%s\"\n", token );
}
if (depth < 0)
{
TokenError("missing {\n");
}
};
// Actually connect up the expressions between the Dme Flex Controllers & Flex Descriptors
// In case there was data added by some other eyeball command (like eyelid)
AddBodyFlexRules( g_model[ g_nummodels ]->source );
g_nummodels++;
}
void Cmd_FakeVTA( void )
{
int depth = 0;
GetToken( false );
s_source_t *psource = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
g_source[g_numsources] = psource;
V_strcpy_safe( g_source[g_numsources]->filename, token );
g_numsources++;
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
else if (stricmp("appendvta", token ) == 0)
{
char filename[256];
// file
GetToken (false);
V_strcpy_safe( filename, token );
GetToken( false );
int frame = verify_atoi( token );
AppendVTAtoOBJ( psource, filename, frame );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_IKChain( )
{
if (!GetToken(false))
return;
int i;
for ( i = 0; i < g_numikchains; i++)
{
if (stricmp( token, g_ikchain[i].name ) == 0)
{
break;
}
}
if (i < g_numikchains)
{
if (!g_quiet)
{
printf("duplicate ikchain \"%s\" ignored\n", token );
}
while (TokenAvailable())
{
GetToken(false);
}
return;
}
V_strcpy_safe( g_ikchain[g_numikchains].name, token );
GetToken(false);
V_strcpy_safe( g_ikchain[g_numikchains].bonename, token );
g_ikchain[g_numikchains].axis = STUDIO_Z;
g_ikchain[g_numikchains].value = 0.0;
g_ikchain[g_numikchains].height = 18.0;
g_ikchain[g_numikchains].floor = 0.0;
g_ikchain[g_numikchains].radius = 0.0;
while (TokenAvailable())
{
GetToken(false);
if (lookupControl( token ) != -1)
{
g_ikchain[g_numikchains].axis = lookupControl( token );
GetToken(false);
g_ikchain[g_numikchains].value = verify_atof( token );
}
else if (stricmp( "height", token ) == 0)
{
GetToken(false);
g_ikchain[g_numikchains].height = verify_atof( token );
}
else if (stricmp( "pad", token ) == 0)
{
GetToken(false);
g_ikchain[g_numikchains].radius = verify_atof( token ) / 2.0;
}
else if (stricmp( "floor", token ) == 0)
{
GetToken(false);
g_ikchain[g_numikchains].floor = verify_atof( token );
}
else if (stricmp( "knee", token ) == 0)
{
GetToken(false);
g_ikchain[g_numikchains].link[0].kneeDir.x = verify_atof( token );
GetToken(false);
g_ikchain[g_numikchains].link[0].kneeDir.y = verify_atof( token );
GetToken(false);
g_ikchain[g_numikchains].link[0].kneeDir.z = verify_atof( token );
}
else if (stricmp( "center", token ) == 0)
{
GetToken(false);
g_ikchain[g_numikchains].center.x = verify_atof( token );
GetToken(false);
g_ikchain[g_numikchains].center.y = verify_atof( token );
GetToken(false);
g_ikchain[g_numikchains].center.z = verify_atof( token );
}
}
g_numikchains++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_IKAutoplayLock( )
{
GetToken(false);
V_strcpy_safe( g_ikautoplaylock[g_numikautoplaylocks].name, token );
GetToken(false);
g_ikautoplaylock[g_numikautoplaylocks].flPosWeight = verify_atof( token );
GetToken(false);
g_ikautoplaylock[g_numikautoplaylocks].flLocalQWeight = verify_atof( token );
g_numikautoplaylocks++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Root ()
{
if (GetToken (false))
{
V_strcpy_safe( rootname, token );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Controller (void)
{
if (GetToken (false))
{
if (!stricmp("mouth",token))
{
g_bonecontroller[g_numbonecontrollers].inputfield = 4;
}
else
{
g_bonecontroller[g_numbonecontrollers].inputfield = verify_atoi(token);
}
if (GetToken(false))
{
V_strcpy_safe( g_bonecontroller[g_numbonecontrollers].name, token );
GetToken(false);
if ((g_bonecontroller[g_numbonecontrollers].type = lookupControl(token)) == -1)
{
MdlWarning("unknown g_bonecontroller type '%s'\n", token );
return;
}
GetToken(false);
g_bonecontroller[g_numbonecontrollers].start = verify_atof( token );
GetToken(false);
g_bonecontroller[g_numbonecontrollers].end = verify_atof( token );
if (g_bonecontroller[g_numbonecontrollers].type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
{
if (((int)(g_bonecontroller[g_numbonecontrollers].start + 360) % 360) == ((int)(g_bonecontroller[g_numbonecontrollers].end + 360) % 360))
{
g_bonecontroller[g_numbonecontrollers].type |= STUDIO_RLOOP;
}
}
g_numbonecontrollers++;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
// Debugging function that enumerate all a models bones to stdout.
static void SpewBones()
{
MdlWarning("g_numbones %i\n",g_numbones);
for ( int i = g_numbones; --i >= 0; )
{
printf("%s\n",g_bonetable[i].name);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_ScreenAlign ( void )
{
if (GetToken (false))
{
Assert( g_numscreenalignedbones < MAXSTUDIOSRCBONES );
V_strcpy_safe( g_screenalignedbone[g_numscreenalignedbones].name, token );
g_screenalignedbone[g_numscreenalignedbones].flags = BONE_SCREEN_ALIGN_SPHERE;
if( GetToken( false ) )
{
if( !stricmp( "sphere", token ) )
{
g_screenalignedbone[g_numscreenalignedbones].flags = BONE_SCREEN_ALIGN_SPHERE;
}
else if( !stricmp( "cylinder", token ) )
{
g_screenalignedbone[g_numscreenalignedbones].flags = BONE_SCREEN_ALIGN_CYLINDER;
}
}
g_numscreenalignedbones++;
} else
{
TokenError( "$screenalign: expected bone name\n" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_BBox (void)
{
GetToken (false);
bbox[0][0] = verify_atof( token );
GetToken (false);
bbox[0][1] = verify_atof( token );
GetToken (false);
bbox[0][2] = verify_atof( token );
GetToken (false);
bbox[1][0] = verify_atof( token );
GetToken (false);
bbox[1][1] = verify_atof( token );
GetToken (false);
bbox[1][2] = verify_atof( token );
g_wrotebbox = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_CBox (void)
{
GetToken (false);
cbox[0][0] = verify_atof( token );
GetToken (false);
cbox[0][1] = verify_atof( token );
GetToken (false);
cbox[0][2] = verify_atof( token );
GetToken (false);
cbox[1][0] = verify_atof( token );
GetToken (false);
cbox[1][1] = verify_atof( token );
GetToken (false);
cbox[1][2] = verify_atof( token );
g_wrotecbox = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Gamma (void)
{
GetToken (false);
g_gamma = verify_atof( token );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_TextureGroup( )
{
if( g_bCreateMakefile )
{
return;
}
int i;
int depth = 0;
int index = 0;
int group = 0;
if (!GetToken(false))
return;
if (g_numskinref == 0)
g_numskinref = g_numtextures;
while (1)
{
if(!GetToken(true))
{
break;
}
if (endofscript)
{
if (depth != 0)
{
TokenError("missing }\n" );
}
return;
}
if (token[0] == '{')
{
depth++;
}
else if (token[0] == '}')
{
depth--;
if (depth == 0)
break;
group++;
index = 0;
}
else if (depth == 2)
{
i = UseTextureAsMaterial( LookupTexture( token ) );
g_texturegroup[g_numtexturegroups][group][index] = i;
if (group != 0)
g_texture[i].parent = g_texturegroup[g_numtexturegroups][0][index];
index++;
g_numtexturereps[g_numtexturegroups] = index;
g_numtexturelayers[g_numtexturegroups] = group + 1;
}
}
g_numtexturegroups++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Hitgroup( )
{
GetToken (false);
g_hitgroup[g_numhitgroups].group = verify_atoi( token );
GetToken (false);
V_strcpy_safe( g_hitgroup[g_numhitgroups].name, token );
g_numhitgroups++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Hitbox( )
{
bool autogenerated = false;
if ( g_hitboxsets.Size() == 0 )
{
g_hitboxsets.AddToTail();
autogenerated = true;
}
// Last one
s_hitboxset *set = &g_hitboxsets[ g_hitboxsets.Size() - 1 ];
if ( autogenerated )
{
memset( set, 0, sizeof( *set ) );
// fill in name if it wasn't specified in the .qc
V_strcpy_safe( set->hitboxsetname, "default" );
}
GetToken (false);
set->hitbox[set->numhitboxes].group = verify_atoi( token );
// Grab the bone name:
GetToken (false);
V_strcpy_safe( set->hitbox[set->numhitboxes].name, token );
GetToken (false);
set->hitbox[set->numhitboxes].bmin[0] = verify_atof( token );
GetToken (false);
set->hitbox[set->numhitboxes].bmin[1] = verify_atof( token );
GetToken (false);
set->hitbox[set->numhitboxes].bmin[2] = verify_atof( token );
GetToken (false);
set->hitbox[set->numhitboxes].bmax[0] = verify_atof( token );
GetToken (false);
set->hitbox[set->numhitboxes].bmax[1] = verify_atof( token );
GetToken (false);
set->hitbox[set->numhitboxes].bmax[2] = verify_atof( token );
//Scale hitboxes
scale_vertex( set->hitbox[set->numhitboxes].bmin );
scale_vertex( set->hitbox[set->numhitboxes].bmax );
// clear out the hitboxname:
memset( set->hitbox[set->numhitboxes].hitboxname, 0, sizeof( set->hitbox[set->numhitboxes].hitboxname ) );
// Grab the hit box name if present:
if( TokenAvailable() )
{
GetToken (false);
V_strcpy_safe( set->hitbox[set->numhitboxes].hitboxname, token );
}
set->numhitboxes++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_HitboxSet( void )
{
// Add a new hitboxset
s_hitboxset *set = &g_hitboxsets[ g_hitboxsets.AddToTail() ];
GetToken( false );
memset( set, 0, sizeof( *set ) );
V_strcpy_safe( set->hitboxsetname, token );
}
//-----------------------------------------------------------------------------
// Assigns a default surface property to the entire model
//-----------------------------------------------------------------------------
struct SurfacePropName_t
{
char m_pJointName[128];
char m_pSurfaceProp[128];
};
static char s_pDefaultSurfaceProp[128] = {"default"};
static CUtlVector<SurfacePropName_t> s_JointSurfaceProp;
//-----------------------------------------------------------------------------
// Assigns a default surface property to the entire model
//-----------------------------------------------------------------------------
void Cmd_SurfaceProp ()
{
GetToken (false);
V_strcpy_safe( s_pDefaultSurfaceProp, token );
}
//-----------------------------------------------------------------------------
// Assigns a surface property to a particular joint
//-----------------------------------------------------------------------------
void Cmd_JointSurfaceProp ()
{
// Get joint name...
GetToken (false);
// Search for the name in our list
int i;
for ( i = s_JointSurfaceProp.Count(); --i >= 0; )
{
if (!stricmp(s_JointSurfaceProp[i].m_pJointName, token))
{
break;
}
}
// Add new entry if we haven't seen this name before
if (i < 0)
{
i = s_JointSurfaceProp.AddToTail();
V_strcpy_safe( s_JointSurfaceProp[i].m_pJointName, token );
}
// surface property name
GetToken(false);
V_strcpy_safe( s_JointSurfaceProp[i].m_pSurfaceProp, token );
}
//-----------------------------------------------------------------------------
// Returns the default surface prop name
//-----------------------------------------------------------------------------
char* GetDefaultSurfaceProp ( )
{
return s_pDefaultSurfaceProp;
}
//-----------------------------------------------------------------------------
// Returns surface property for a given joint
//-----------------------------------------------------------------------------
static char* FindSurfaceProp ( const char* pJointName )
{
for ( int i = s_JointSurfaceProp.Count(); --i >= 0; )
{
if (!stricmp(s_JointSurfaceProp[i].m_pJointName, pJointName))
{
return s_JointSurfaceProp[i].m_pSurfaceProp;
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Returns surface property for a given joint
//-----------------------------------------------------------------------------
char* GetSurfaceProp ( const char* pJointName )
{
while( pJointName )
{
// First try to find this joint
char* pSurfaceProp = FindSurfaceProp( pJointName );
if (pSurfaceProp)
return pSurfaceProp;
// If we can't find the joint, then find it's parent...
if (!g_numbones)
return s_pDefaultSurfaceProp;
int i = findGlobalBone( pJointName );
if ((i >= 0) && (g_bonetable[i].parent >= 0))
{
pJointName = g_bonetable[g_bonetable[i].parent].name;
}
else
{
pJointName = 0;
}
}
// No match, return the default one
return s_pDefaultSurfaceProp;
}
//-----------------------------------------------------------------------------
// Returns surface property for a given joint
//-----------------------------------------------------------------------------
void ConsistencyCheckSurfaceProp ( )
{
for ( int i = s_JointSurfaceProp.Count(); --i >= 0; )
{
int j = findGlobalBone( s_JointSurfaceProp[i].m_pJointName );
if (j < 0)
{
MdlWarning("You specified a joint surface property for joint\n"
" \"%s\" which either doesn't exist or was optimized out.\n", s_JointSurfaceProp[i].m_pJointName );
}
}
}
//-----------------------------------------------------------------------------
// Assigns a default contents to the entire model
//-----------------------------------------------------------------------------
struct ContentsName_t
{
char m_pJointName[128];
int m_nContents;
};
static int s_nDefaultContents = CONTENTS_SOLID;
static CUtlVector<ContentsName_t> s_JointContents;
//-----------------------------------------------------------------------------
// Parse contents flags
//-----------------------------------------------------------------------------
static void ParseContents( int *pAddFlags, int *pRemoveFlags )
{
*pAddFlags = 0;
*pRemoveFlags = 0;
do
{
GetToken (false);
if ( !stricmp( token, "grate" ) )
{
*pAddFlags |= CONTENTS_GRATE;
*pRemoveFlags |= CONTENTS_SOLID;
}
else if ( !stricmp( token, "ladder" ) )
{
*pAddFlags |= CONTENTS_LADDER;
}
else if ( !stricmp( token, "solid" ) )
{
*pAddFlags |= CONTENTS_SOLID;
}
else if ( !stricmp( token, "monster" ) )
{
*pAddFlags |= CONTENTS_MONSTER;
}
else if ( !stricmp( token, "notsolid" ) )
{
*pRemoveFlags |= CONTENTS_SOLID;
}
} while (TokenAvailable());
}
//-----------------------------------------------------------------------------
// Assigns a default contents to the entire model
//-----------------------------------------------------------------------------
void Cmd_Contents()
{
int nAddFlags, nRemoveFlags;
ParseContents( &nAddFlags, &nRemoveFlags );
s_nDefaultContents |= nAddFlags;
s_nDefaultContents &= ~nRemoveFlags;
}
//-----------------------------------------------------------------------------
// Assigns contents to a particular joint
//-----------------------------------------------------------------------------
void Cmd_JointContents ()
{
// Get joint name...
GetToken (false);
// Search for the name in our list
int i;
for ( i = s_JointContents.Count(); --i >= 0; )
{
if (!stricmp(s_JointContents[i].m_pJointName, token))
{
break;
}
}
// Add new entry if we haven't seen this name before
if (i < 0)
{
i = s_JointContents.AddToTail();
V_strcpy_safe( s_JointContents[i].m_pJointName, token );
}
int nAddFlags, nRemoveFlags;
ParseContents( &nAddFlags, &nRemoveFlags );
s_JointContents[i].m_nContents = CONTENTS_SOLID;
s_JointContents[i].m_nContents |= nAddFlags;
s_JointContents[i].m_nContents &= ~nRemoveFlags;
}
//-----------------------------------------------------------------------------
// Returns the default contents
//-----------------------------------------------------------------------------
int GetDefaultContents( )
{
return s_nDefaultContents;
}
//-----------------------------------------------------------------------------
// Returns contents for a given joint
//-----------------------------------------------------------------------------
static int FindContents( const char* pJointName )
{
for ( int i = s_JointContents.Count(); --i >= 0; )
{
if (!stricmp(s_JointContents[i].m_pJointName, pJointName))
{
return s_JointContents[i].m_nContents;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Returns contents for a given joint
//-----------------------------------------------------------------------------
int GetContents( const char* pJointName )
{
while( pJointName )
{
// First try to find this joint
int nContents = FindContents( pJointName );
if (nContents != -1)
return nContents;
// If we can't find the joint, then find it's parent...
if (!g_numbones)
return s_nDefaultContents;
int i = findGlobalBone( pJointName );
if ((i >= 0) && (g_bonetable[i].parent >= 0))
{
pJointName = g_bonetable[g_bonetable[i].parent].name;
}
else
{
pJointName = 0;
}
}
// No match, return the default one
return s_nDefaultContents;
}
//-----------------------------------------------------------------------------
// Checks specified contents
//-----------------------------------------------------------------------------
void ConsistencyCheckContents( )
{
for ( int i = s_JointContents.Count(); --i >= 0; )
{
int j = findGlobalBone( s_JointContents[i].m_pJointName );
if (j < 0)
{
MdlWarning("You specified a joint contents for joint\n"
" \"%s\" which either doesn't exist or was optimized out.\n", s_JointSurfaceProp[i].m_pJointName );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_BoneMerge( )
{
if( g_bCreateMakefile )
return;
int nIndex = g_BoneMerge.AddToTail();
// bone name
GetToken (false);
V_strcpy_safe( g_BoneMerge[nIndex].bonename, token );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Attachment( )
{
if( g_bCreateMakefile )
return;
// name
GetToken (false);
V_strcpy_safe( g_attachment[g_numattachments].name, token );
// bone name
GetToken (false);
V_strcpy_safe( g_attachment[g_numattachments].bonename, token );
Vector tmp;
// position
GetToken (false);
tmp.x = verify_atof( token );
GetToken (false);
tmp.y = verify_atof( token );
GetToken (false);
tmp.z = verify_atof( token );
scale_vertex( tmp );
// identity matrix
AngleMatrix( QAngle( 0, 0, 0 ), g_attachment[g_numattachments].local );
while (TokenAvailable())
{
GetToken (false);
if (stricmp(token,"absolute") == 0)
{
g_attachment[g_numattachments].type |= IS_ABSOLUTE;
AngleIMatrix( g_defaultrotation, g_attachment[g_numattachments].local );
// AngleIMatrix( Vector( 0, 0, 0 ), g_attachment[g_numattachments].local );
}
else if (stricmp(token,"rigid") == 0)
{
g_attachment[g_numattachments].type |= IS_RIGID;
}
else if (stricmp(token,"world_align") == 0)
{
g_attachment[g_numattachments].flags |= ATTACHMENT_FLAG_WORLD_ALIGN;
}
else if (stricmp(token,"rotate") == 0)
{
QAngle angles;
for (int i = 0; i < 3; ++i)
{
if (!TokenAvailable())
break;
GetToken(false);
angles[i] = verify_atof( token );
}
AngleMatrix( angles, g_attachment[g_numattachments].local );
}
else if (stricmp(token,"x_and_z_axes") == 0)
{
int i;
Vector xaxis, yaxis, zaxis;
for (i = 0; i < 3; ++i)
{
if (!TokenAvailable())
break;
GetToken(false);
xaxis[i] = verify_atof( token );
}
for (i = 0; i < 3; ++i)
{
if (!TokenAvailable())
break;
GetToken(false);
zaxis[i] = verify_atof( token );
}
VectorNormalize( xaxis );
VectorMA( zaxis, -DotProduct( zaxis, xaxis ), xaxis, zaxis );
VectorNormalize( zaxis );
CrossProduct( zaxis, xaxis, yaxis );
MatrixSetColumn( xaxis, 0, g_attachment[g_numattachments].local );
MatrixSetColumn( yaxis, 1, g_attachment[g_numattachments].local );
MatrixSetColumn( zaxis, 2, g_attachment[g_numattachments].local );
MatrixSetColumn( vec3_origin, 3, g_attachment[g_numattachments].local );
}
else
{
TokenError("unknown attachment (%s) option: ", g_attachment[g_numattachments].name, token );
}
}
g_attachment[g_numattachments].local[0][3] = tmp.x;
g_attachment[g_numattachments].local[1][3] = tmp.y;
g_attachment[g_numattachments].local[2][3] = tmp.z;
g_numattachments++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int LookupAttachment( char *name )
{
int i;
for (i = 0; i < g_numattachments; i++)
{
if (stricmp( g_attachment[i].name, name ) == 0)
{
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Renamebone( )
{
// from
GetToken (false);
V_strcpy_safe( g_renamedbone[g_numrenamedbones].from, token );
// to
GetToken (false);
V_strcpy_safe( g_renamedbone[g_numrenamedbones].to, token );
g_numrenamedbones++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Cmd_Skiptransition( )
{
int nskips = 0;
int list[10];
while (TokenAvailable())
{
GetToken (false);
list[nskips++] = LookupXNode( token );
}
for (int i = 0; i < nskips; i++)
{
for (int j = 0; j < nskips; j++)
{
if (list[i] != list[j])
{
g_xnodeskip[g_numxnodeskips][0] = list[i];
g_xnodeskip[g_numxnodeskips][1] = list[j];
g_numxnodeskips++;
}
}
}
}
//-----------------------------------------------------------------------------
//
// The following code is all related to LODs
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Parse replacemodel command, causes an LOD to use a new model
//-----------------------------------------------------------------------------
static void Cmd_ReplaceModel( LodScriptData_t& lodData )
{
int i = lodData.modelReplacements.AddToTail();
CLodScriptReplacement_t& newReplacement = lodData.modelReplacements[i];
// from
GetToken( false );
// Strip off extensions for the source...
char* pDot = strrchr( token, '.' );
if (pDot)
{
*pDot = 0;
}
if (!FindCachedSource( token, "" ))
{
// must have prior knowledge of the from
TokenError( "Unknown replace model '%s'\n", token );
}
newReplacement.SetSrcName( token );
// to
GetToken( false );
newReplacement.SetDstName( token );
// check for "reverse"
bool reverse = false;
if( TokenAvailable() && GetToken( false ) )
{
if( stricmp( "reverse", token ) == 0 )
{
reverse = true;
}
else
{
TokenError( "\"%s\" unexpected\n", token );
}
}
// If the LOD system tells us to replace "blank", let's forget
// we ever read this. Have to do it here so parsing works
if( !stricmp( newReplacement.GetSrcName(), "blank" ) )
{
lodData.modelReplacements.FastRemove( i );
return;
}
// Load the source right here baby! That way its bones will get converted
if ( !lodData.IsStrippedFromModel() )
{
newReplacement.m_pSource = Load_Source( newReplacement.GetDstName(), "smd", reverse, false );
}
else if ( !g_quiet )
{
printf( "Stripped lod \"%s\" @ %.1f\n", newReplacement.GetDstName(), lodData.switchValue );
}
}
//-----------------------------------------------------------------------------
// Parse removemodel command, causes an LOD to stop using a model
//-----------------------------------------------------------------------------
static void Cmd_RemoveModel( LodScriptData_t& lodData )
{
int i = lodData.modelReplacements.AddToTail();
CLodScriptReplacement_t& newReplacement = lodData.modelReplacements[i];
// from
GetToken( false );
// Strip off extensions...
char* pDot = strrchr( token, '.' );
if (pDot)
*pDot = 0;
newReplacement.SetSrcName( token );
// to
newReplacement.SetDstName( "" );
// If the LOD system tells us to replace "blank", let's forget
// we ever read this. Have to do it here so parsing works
if( !stricmp( newReplacement.GetSrcName(), "blank" ) )
{
lodData.modelReplacements.FastRemove( i );
}
}
//-----------------------------------------------------------------------------
// Parse replacebone command, causes a part of an LOD model to use a different bone
//-----------------------------------------------------------------------------
static void Cmd_ReplaceBone( LodScriptData_t& lodData )
{
int i = lodData.boneReplacements.AddToTail();
CLodScriptReplacement_t& newReplacement = lodData.boneReplacements[i];
// from
GetToken( false );
newReplacement.SetSrcName( token );
// to
GetToken( false );
newReplacement.SetDstName( token );
}
//-----------------------------------------------------------------------------
// Parse bonetreecollapse command, causes the entire subtree to use the same bone as the node
//-----------------------------------------------------------------------------
static void Cmd_BoneTreeCollapse( LodScriptData_t& lodData )
{
int i = lodData.boneTreeCollapses.AddToTail();
CLodScriptReplacement_t& newCollapse = lodData.boneTreeCollapses[i];
// from
GetToken( false );
newCollapse.SetSrcName( token );
}
//-----------------------------------------------------------------------------
// Parse replacematerial command, causes a material to be used in place of another
//-----------------------------------------------------------------------------
static void Cmd_ReplaceMaterial( LodScriptData_t& lodData )
{
int i = lodData.materialReplacements.AddToTail();
CLodScriptReplacement_t& newReplacement = lodData.materialReplacements[i];
// from
GetToken( false );
newReplacement.SetSrcName( token );
// to
GetToken( false );
newReplacement.SetDstName( token );
if ( !lodData.IsStrippedFromModel() )
{
// make sure it goes into the master list
UseTextureAsMaterial( LookupTexture( token ) );
}
}
//-----------------------------------------------------------------------------
// Parse removemesh command, causes a mesh to not be used anymore
//-----------------------------------------------------------------------------
static void Cmd_RemoveMesh( LodScriptData_t& lodData )
{
int i = lodData.meshRemovals.AddToTail();
CLodScriptReplacement_t& newReplacement = lodData.meshRemovals[i];
// from
GetToken( false );
Q_FixSlashes( token );
newReplacement.SetSrcName( token );
}
void Cmd_LOD( const char *cmdname )
{
if ( gflags & STUDIOHDR_FLAGS_HASSHADOWLOD )
{
MdlError( "Model can only have one $shadowlod and it must be the last lod in the .qc (%d) : %s\n", g_iLinecount, g_szLine );
}
int i = g_ScriptLODs.AddToTail();
LodScriptData_t& newLOD = g_ScriptLODs[i];
if( g_ScriptLODs.Count() > MAX_NUM_LODS )
{
MdlError( "Too many LODs (MAX_NUM_LODS==%d)\n", ( int )MAX_NUM_LODS );
}
// Shadow lod reserves -1 as switch value
// which uniquely identifies a shadow lod
newLOD.switchValue = -1.0f;
bool isShadowCall = ( !stricmp( cmdname, "$shadowlod" ) ) ? true : false;
if ( isShadowCall )
{
if ( TokenAvailable() )
{
GetToken( false );
MdlWarning( "(%d) : %s: Ignoring switch value on %s command line\n", g_iLinecount, cmdname, g_szLine );
}
// Disable facial animation by default
newLOD.EnableFacialAnimation( false );
}
else
{
if ( TokenAvailable() )
{
GetToken( false );
newLOD.switchValue = verify_atof( token );
if ( newLOD.switchValue < 0.0f )
{
MdlError( "Negative switch value reserved for $shadowlod (%d) : %s\n", g_iLinecount, g_szLine );
}
}
else
{
MdlError( "Expected LOD switch value (%d) : %s\n", g_iLinecount, g_szLine );
}
}
GetToken( true );
if( stricmp( "{", token ) != 0 )
{
MdlError( "\"{\" expected while processing %s (%d) : %s", cmdname, g_iLinecount, g_szLine );
}
// In case we are stripping all lods and it's not Lod0, strip it
if ( i && g_bStripLods )
newLOD.StripFromModel( true );
while( 1 )
{
GetToken( true );
if( stricmp( "replacemodel", token ) == 0 )
{
Cmd_ReplaceModel(newLOD);
}
else if( stricmp( "removemodel", token ) == 0 )
{
Cmd_RemoveModel(newLOD);
}
else if( stricmp( "replacebone", token ) == 0 )
{
Cmd_ReplaceBone( newLOD );
}
else if( stricmp( "bonetreecollapse", token ) == 0 )
{
Cmd_BoneTreeCollapse( newLOD );
}
else if( stricmp( "replacematerial", token ) == 0 )
{
Cmd_ReplaceMaterial( newLOD );
}
else if( stricmp( "removemesh", token ) == 0 )
{
Cmd_RemoveMesh( newLOD );
}
else if( stricmp( "nofacial", token ) == 0 )
{
newLOD.EnableFacialAnimation( false );
}
else if( stricmp( "facial", token ) == 0 )
{
if (isShadowCall)
{
// facial animation has no reasonable purpose on a shadow lod
TokenError( "Facial animation is not allowed for $shadowlod\n" );
}
newLOD.EnableFacialAnimation( true );
}
else if ( stricmp( "use_shadowlod_materials", token ) == 0 )
{
if (isShadowCall)
{
gflags |= STUDIOHDR_FLAGS_USE_SHADOWLOD_MATERIALS;
}
}
else if( stricmp( "}", token ) == 0 )
{
break;
}
else
{
MdlError( "invalid input while processing %s (%d) : %s", cmdname, g_iLinecount, g_szLine );
}
}
// If the LOD is stripped, then forget we saw it
if ( newLOD.IsStrippedFromModel() )
{
g_ScriptLODs.FastRemove( i );
}
}
void Cmd_ShadowLOD( void )
{
if (!g_quiet)
{
printf( "Processing $shadowlod\n" );
}
// Act like it's a regular lod entry
Cmd_LOD( "$shadowlod" );
// Mark .mdl as having shadow lod (we also check above that we have only one of these
// and that it's the last entered lod )
gflags |= STUDIOHDR_FLAGS_HASSHADOWLOD;
}
//-----------------------------------------------------------------------------
// A couple commands related to translucency sorting
//-----------------------------------------------------------------------------
void Cmd_Opaque( )
{
// Force Opaque has precedence
gflags |= STUDIOHDR_FLAGS_FORCE_OPAQUE;
gflags &= ~STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS;
}
void Cmd_TranslucentTwoPass( )
{
// Force Opaque has precedence
if ((gflags & STUDIOHDR_FLAGS_FORCE_OPAQUE) == 0)
{
gflags |= STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS;
}
}
//-----------------------------------------------------------------------------
// Indicates the model be rendered with ambient boost heuristic (first used on Alyx in Episode 1)
//-----------------------------------------------------------------------------
void Cmd_AmbientBoost()
{
gflags |= STUDIOHDR_FLAGS_AMBIENT_BOOST;
}
//-----------------------------------------------------------------------------
// Indicates the model should not cast shadows (useful for first-person models as used in L4D)
//-----------------------------------------------------------------------------
void Cmd_DoNotCastShadows()
{
gflags |= STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS;
}
//-----------------------------------------------------------------------------
// Indicates the model should cast texutre-based shadows in vrad (NOTE: only applicable to prop_static)
//-----------------------------------------------------------------------------
void Cmd_CastTextureShadows()
{
gflags |= STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS;
}
//-----------------------------------------------------------------------------
// Indicates the model should not fade out even if the level or fallback settings say to
//-----------------------------------------------------------------------------
void Cmd_NoForcedFade()
{
gflags |= STUDIOHDR_FLAGS_NO_FORCED_FADE;
}
//-----------------------------------------------------------------------------
// Indicates the model should not use the bone origin when calculating bboxes, sequence boxes, etc.
//-----------------------------------------------------------------------------
void Cmd_SkipBoneInBBox()
{
g_bUseBoneInBBox = false;
}
//-----------------------------------------------------------------------------
// Indicates the model will lengthen the viseme check to always include two phonemes
//-----------------------------------------------------------------------------
void Cmd_ForcePhonemeCrossfade()
{
gflags |= STUDIOHDR_FLAGS_FORCE_PHONEME_CROSSFADE;
}
//-----------------------------------------------------------------------------
// Indicates the model should keep pre-defined bone lengths regardless of animation changes
//-----------------------------------------------------------------------------
void Cmd_LockBoneLengths()
{
g_bLockBoneLengths = true;
}
//-----------------------------------------------------------------------------
// Indicates the model should replace pre-defined bone lengths and default orientations
//-----------------------------------------------------------------------------
void Cmd_UnlockDefineBones()
{
g_bOverridePreDefinedBones = true;
}
//-----------------------------------------------------------------------------
// Mark this model as obsolete so that it'll show the obsolete material in game.
//-----------------------------------------------------------------------------
void Cmd_Obsolete( )
{
// Force Opaque has precedence
gflags |= STUDIOHDR_FLAGS_OBSOLETE;
}
//-----------------------------------------------------------------------------
// The bones should be moved so that they center themselves on the verts they own.
//-----------------------------------------------------------------------------
void Cmd_CenterBonesOnVerts( )
{
// force centering on bones
g_bCenterBonesOnVerts = true;
}
//-----------------------------------------------------------------------------
// How far back should simple motion extract pull back from the last frame
//-----------------------------------------------------------------------------
void Cmd_MotionExtractionRollBack( )
{
GetToken( false );
g_flDefaultMotionRollback = atof( token );
}
//-----------------------------------------------------------------------------
// rules for breaking up long animations into multiple sub anims
//-----------------------------------------------------------------------------
void Cmd_SectionFrames( )
{
GetToken( false );
g_sectionFrames = atof( token );
GetToken( false );
g_minSectionFrameLimit = atoi( token );
}
//-----------------------------------------------------------------------------
// world space clamping boundaries for animations
//-----------------------------------------------------------------------------
void Cmd_ClampWorldspace( )
{
GetToken (false);
g_vecMinWorldspace[0] = verify_atof( token );
GetToken (false);
g_vecMinWorldspace[1] = verify_atof( token );
GetToken (false);
g_vecMinWorldspace[2] = verify_atof( token );
GetToken (false);
g_vecMaxWorldspace[0] = verify_atof( token );
GetToken (false);
g_vecMaxWorldspace[1] = verify_atof( token );
GetToken (false);
g_vecMaxWorldspace[2] = verify_atof( token );
}
//-----------------------------------------------------------------------------
// Key value block!
//-----------------------------------------------------------------------------
void Option_KeyValues( CUtlVector< char > *pKeyValue )
{
// Simply read in the block between { }s as text
// and plop it out unchanged into the .mdl file.
// Make sure to respect the fact that we may have nested {}s
int nLevel = 1;
if ( !GetToken( true ) )
return;
if ( token[0] != '{' )
return;
AppendKeyValueText( pKeyValue, "mdlkeyvalue\n{\n" );
while ( GetToken(true) )
{
if ( !stricmp( token, "}" ) )
{
nLevel--;
if ( nLevel <= 0 )
break;
AppendKeyValueText( pKeyValue, " }\n" );
}
else if ( !stricmp( token, "{" ) )
{
AppendKeyValueText( pKeyValue, "{\n" );
nLevel++;
}
else
{
// tokens inside braces are quoted
if ( nLevel > 1 )
{
AppendKeyValueText( pKeyValue, "\"" );
AppendKeyValueText( pKeyValue, token );
AppendKeyValueText( pKeyValue, "\" " );
}
else
{
AppendKeyValueText( pKeyValue, token );
AppendKeyValueText( pKeyValue, " " );
}
}
}
if ( nLevel >= 1 )
{
TokenError( "Keyvalue block missing matching braces.\n" );
}
AppendKeyValueText( pKeyValue, "}\n" );
}
//-----------------------------------------------------------------------------
// Purpose: force a specific parent child relationship
//-----------------------------------------------------------------------------
void Cmd_ForcedHierarchy( )
{
// child name
GetToken (false);
V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].childname, token );
// parent name
GetToken (false);
V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].parentname, token );
g_numforcedhierarchy++;
}
//-----------------------------------------------------------------------------
// Purpose: insert a virtual bone between a child and parent (currently unsupported)
//-----------------------------------------------------------------------------
void Cmd_InsertHierarchy( )
{
// child name
GetToken (false);
V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].childname, token );
// subparent name
GetToken (false);
V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].subparentname, token );
// parent name
GetToken (false);
V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].parentname, token );
g_numforcedhierarchy++;
}
//-----------------------------------------------------------------------------
// Purpose: rotate a specific bone
//-----------------------------------------------------------------------------
void Cmd_ForceRealign( )
{
// bone name
GetToken (false);
V_strcpy_safe( g_forcedrealign[g_numforcedrealign].name, token );
// skip
GetToken (false);
// X axis
GetToken (false);
g_forcedrealign[g_numforcedrealign].rot.x = DEG2RAD( verify_atof( token ) );
// Y axis
GetToken (false);
g_forcedrealign[g_numforcedrealign].rot.y = DEG2RAD( verify_atof( token ) );
// Z axis
GetToken (false);
g_forcedrealign[g_numforcedrealign].rot.z = DEG2RAD( verify_atof( token ) );
g_numforcedrealign++;
}
//-----------------------------------------------------------------------------
// Purpose: specify a bone to allow > 180 but < 360 rotation (forces a calculated "mid point" to rotation)
//-----------------------------------------------------------------------------
void Cmd_LimitRotation( )
{
// bone name
GetToken (false);
V_strcpy_safe( g_limitrotation[g_numlimitrotation].name, token );
while (TokenAvailable())
{
// sequence name
GetToken (false);
// This was a call to strcpyn but since sequencename is an array of char*
// it was passing sizeof(char*) as the number of characters to copy, which
// makes no sense. Commenting out until a better idea comes along.
Assert( 0 );
//V_strcpy_safe( g_limitrotation[g_numlimitrotation].sequencename[g_limitrotation[g_numlimitrotation].numseq++], token );
}
g_numlimitrotation++;
}
//-----------------------------------------------------------------------------
// Purpose: specify bones to store, even if nothing references them
//-----------------------------------------------------------------------------
void Cmd_DefineBone( )
{
// bone name
GetToken (false);
V_strcpy_safe( g_importbone[g_numimportbones].name, token );
// parent name
GetToken (false);
V_strcpy_safe( g_importbone[g_numimportbones].parent, token );
Vector pos;
QAngle angles;
// default pos
GetToken (false);
pos.x = verify_atof( token );
GetToken (false);
pos.y = verify_atof( token );
GetToken (false);
pos.z = verify_atof( token );
GetToken (false);
angles.x = verify_atof( token );
GetToken (false);
angles.y = verify_atof( token );
GetToken (false);
angles.z = verify_atof( token );
AngleMatrix( angles, pos, g_importbone[g_numimportbones].rawLocal );
if (TokenAvailable())
{
g_importbone[g_numimportbones].bPreAligned = true;
// realign pos
GetToken (false);
pos.x = verify_atof( token );
GetToken (false);
pos.y = verify_atof( token );
GetToken (false);
pos.z = verify_atof( token );
GetToken (false);
angles.x = verify_atof( token );
GetToken (false);
angles.y = verify_atof( token );
GetToken (false);
angles.z = verify_atof( token );
AngleMatrix( angles, pos, g_importbone[g_numimportbones].srcRealign );
}
else
{
SetIdentityMatrix( g_importbone[g_numimportbones].srcRealign );
}
g_numimportbones++;
}
//----------------------------------------------------------------------------------------------
float ParseJiggleStiffness( void )
{
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting stiffness value\n" );
return 0.0f;
}
float stiffness = verify_atof( token );
const float minStiffness = 0.0f;
const float maxStiffness = 1000.0f;
return clamp( stiffness, minStiffness, maxStiffness );
}
//----------------------------------------------------------------------------------------------
float ParseJiggleDamping( void )
{
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting damping value\n" );
return 0.0f;
}
float damping = verify_atof( token );
const float minDamping = 0.0f;
const float maxDamping = 10.0f;
return clamp( damping, minDamping, maxDamping );
}
//----------------------------------------------------------------------------------------------
bool ParseJiggleAngleConstraint( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= JIGGLE_HAS_ANGLE_CONSTRAINT;
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting angle value\n" );
return false;
}
jiggleInfo->data.angleLimit = verify_atof( token ) * M_PI / 180.0f;
return true;
}
//----------------------------------------------------------------------------------------------
bool ParseJiggleYawConstraint( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= JIGGLE_HAS_YAW_CONSTRAINT;
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting minimum yaw value\n" );
return false;
}
jiggleInfo->data.minYaw = verify_atof( token ) * M_PI / 180.0f;
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting maximum yaw value\n" );
return false;
}
jiggleInfo->data.maxYaw = verify_atof( token ) * M_PI / 180.0f;
return true;
}
//----------------------------------------------------------------------------------------------
bool ParseJigglePitchConstraint( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= JIGGLE_HAS_PITCH_CONSTRAINT;
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting minimum pitch value\n" );
return false;
}
jiggleInfo->data.minPitch = verify_atof( token ) * M_PI / 180.0f;
if ( !GetToken( false ) )
{
MdlError( "$jigglebone: expecting maximum pitch value\n" );
return false;
}
jiggleInfo->data.maxPitch = verify_atof( token ) * M_PI / 180.0f;
return true;
}
//----------------------------------------------------------------------------------------------
/**
* Parse common parameters.
* This assumes a token has already been read, and returns true if
* the token is recognized and parsed.
*/
bool ParseCommonJiggle( s_jigglebone_t *jiggleInfo )
{
if (!stricmp( token, "tip_mass" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.tipMass = verify_atof( token );
}
else if (!stricmp( token, "length" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.length = verify_atof( token );
}
else if (!stricmp( token, "angle_constraint" ))
{
if (ParseJiggleAngleConstraint( jiggleInfo ) == false)
{
return false;
}
}
else if (!stricmp( token, "yaw_constraint" ))
{
if (ParseJiggleYawConstraint( jiggleInfo ) == false)
{
return false;
}
}
else if (!stricmp( token, "yaw_friction" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.yawFriction = verify_atof( token );
}
else if (!stricmp( token, "yaw_bounce" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.yawBounce = verify_atof( token );
}
else if (!stricmp( token, "pitch_constraint" ))
{
if (ParseJigglePitchConstraint( jiggleInfo ) == false)
{
return false;
}
}
else if (!stricmp( token, "pitch_friction" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.pitchFriction = verify_atof( token );
}
else if (!stricmp( token, "pitch_bounce" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.pitchBounce = verify_atof( token );
}
else
{
// unknown token
MdlError( "$jigglebone: invalid syntax '%s'\n", token );
return false;
}
return true;
}
//----------------------------------------------------------------------------------------------
/**
* Parse parameters for is_flexible subsection
*/
bool ParseFlexibleJiggle( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= (JIGGLE_IS_FLEXIBLE | JIGGLE_HAS_LENGTH_CONSTRAINT);
bool gotOpenBracket = false;
while (true)
{
if (GetToken( true ) == false)
{
MdlError( "$jigglebone:is_flexible: parse error\n" );
return false;
}
if (!stricmp( token, "{" ))
{
gotOpenBracket = true;
}
else if (!gotOpenBracket)
{
MdlError( "$jigglebone:is_flexible: missing '{'\n" );
return false;
}
else if (!stricmp( token, "}" ))
{
// definition complete
break;
}
else if (!stricmp( token, "yaw_stiffness" ))
{
jiggleInfo->data.yawStiffness = ParseJiggleStiffness();
}
else if (!stricmp( token, "yaw_damping" ))
{
jiggleInfo->data.yawDamping = ParseJiggleStiffness();
}
else if (!stricmp( token, "pitch_stiffness" ))
{
jiggleInfo->data.pitchStiffness = ParseJiggleStiffness();
}
else if (!stricmp( token, "pitch_damping" ))
{
jiggleInfo->data.pitchDamping = ParseJiggleStiffness();
}
else if (!stricmp( token, "along_stiffness" ))
{
jiggleInfo->data.alongStiffness = ParseJiggleStiffness();
}
else if (!stricmp( token, "along_damping" ))
{
jiggleInfo->data.alongDamping = ParseJiggleStiffness();
}
else if (!stricmp( token, "allow_length_flex" ))
{
jiggleInfo->data.flags &= ~JIGGLE_HAS_LENGTH_CONSTRAINT;
}
else if (ParseCommonJiggle( jiggleInfo ) == false)
{
MdlError( "$jigglebone:is_flexible: invalid syntax '%s'\n", token );
return false;
}
}
return true;
}
//----------------------------------------------------------------------------------------------
/**
* Parse parameters for is_rigid subsection
*/
bool ParseRigidJiggle( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= (JIGGLE_IS_RIGID | JIGGLE_HAS_LENGTH_CONSTRAINT);
bool gotOpenBracket = false;
while (true)
{
if (GetToken( true ) == false)
{
MdlError( "$jigglebone:is_rigid: parse error\n" );
return false;
}
if (!stricmp( token, "{" ))
{
gotOpenBracket = true;
}
else if (!gotOpenBracket)
{
MdlError( "$jigglebone:is_rigid: missing '{'\n" );
return false;
}
else if (!stricmp( token, "}" ))
{
// definition complete
break;
}
else if (ParseCommonJiggle( jiggleInfo ) == false)
{
MdlError( "$jigglebone:is_rigid: invalid syntax '%s'\n", token );
return false;
}
}
return true;
}
//----------------------------------------------------------------------------------------------
/**
* Parse parameters for has_base_spring subsection
*/
bool ParseBaseSpringJiggle( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= JIGGLE_HAS_BASE_SPRING;
bool gotOpenBracket = false;
while (true)
{
if (GetToken( true ) == false)
{
MdlError( "$jigglebone:has_base_spring: parse error\n" );
return false;
}
if (!stricmp( token, "{" ))
{
gotOpenBracket = true;
}
else if (!gotOpenBracket)
{
MdlError( "$jigglebone:has_base_spring: missing '{'\n" );
return false;
}
else if (!stricmp( token, "}" ))
{
// definition complete
break;
}
else if (!stricmp( token, "stiffness" ))
{
jiggleInfo->data.baseStiffness = ParseJiggleStiffness();
}
else if (!stricmp( token, "damping" ))
{
jiggleInfo->data.baseDamping = ParseJiggleStiffness();
}
else if (!stricmp( token, "left_constraint" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMinLeft = verify_atof( token );
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMaxLeft = verify_atof( token );
}
else if (!stricmp( token, "left_friction" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseLeftFriction = verify_atof( token );
}
else if (!stricmp( token, "up_constraint" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMinUp = verify_atof( token );
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMaxUp = verify_atof( token );
}
else if (!stricmp( token, "up_friction" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseUpFriction = verify_atof( token );
}
else if (!stricmp( token, "forward_constraint" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMinForward = verify_atof( token );
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMaxForward = verify_atof( token );
}
else if (!stricmp( token, "forward_friction" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseForwardFriction = verify_atof( token );
}
else if (!stricmp( token, "base_mass" ))
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.baseMass = verify_atof( token );
}
else if (ParseCommonJiggle( jiggleInfo ) == false)
{
MdlError( "$jigglebone:has_base_spring: invalid syntax '%s'\n", token );
return false;
}
}
return true;
}
//----------------------------------------------------------------------------------------------
/**
* Parse parameters for is_boing subsection
*/
bool ParseBoing( s_jigglebone_t *jiggleInfo )
{
jiggleInfo->data.flags |= JIGGLE_IS_BOING;
// default values
jiggleInfo->data.boingImpactSpeed = 100.0f;
jiggleInfo->data.boingImpactAngle = 0.7071f;
jiggleInfo->data.boingDampingRate = 0.25f;
jiggleInfo->data.boingFrequency = 30.0f;
jiggleInfo->data.boingAmplitude = 0.35f;
bool gotOpenBracket = false;
while ( true )
{
if ( GetToken( true ) == false )
{
MdlError( "$jigglebone:is_boing: parse error\n" );
return false;
}
if ( !stricmp( token, "{" ) )
{
gotOpenBracket = true;
}
else if ( !gotOpenBracket )
{
MdlError( "$jigglebone:is_boing: missing '{'\n" );
return false;
}
else if ( !stricmp( token, "}" ) )
{
// definition complete
break;
}
else if ( !stricmp( token, "impact_speed" ) )
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.boingImpactSpeed = verify_atof( token );
}
else if ( !stricmp( token, "impact_angle" ) )
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.boingImpactAngle = cos( DEG2RAD( verify_atof( token ) ) );
}
else if ( !stricmp( token, "damping_rate" ) )
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.boingDampingRate = verify_atof( token );
}
else if ( !stricmp( token, "frequency" ) )
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.boingFrequency = verify_atof( token );
}
else if ( !stricmp( token, "amplitude" ) )
{
if ( !GetToken( false ) )
{
return false;
}
jiggleInfo->data.boingAmplitude = verify_atof( token );
}
}
return true;
}
//----------------------------------------------------------------------------------------------
/**
* Parse $jigglebone parameters
*/
void Cmd_JiggleBone( void )
{
struct s_jigglebone_t *jiggleInfo = &g_jigglebones[ g_numjigglebones ];
// bone name
GetToken( false );
V_strcpy_safe( jiggleInfo->bonename, token );
// default values
memset( &jiggleInfo->data, 0, sizeof( mstudiojigglebone_t ) );
jiggleInfo->data.length = 10.0f;
jiggleInfo->data.yawStiffness = 100.0f;
jiggleInfo->data.pitchStiffness = 100.0f;
jiggleInfo->data.alongStiffness = 100.0f;
jiggleInfo->data.baseStiffness = 100.0f;
jiggleInfo->data.baseMinUp = -100.0f;
jiggleInfo->data.baseMaxUp = 100.0f;
jiggleInfo->data.baseMinLeft = -100.0f;
jiggleInfo->data.baseMaxLeft = 100.0f;
jiggleInfo->data.baseMinForward = -100.0f;
jiggleInfo->data.baseMaxForward = 100.0f;
bool gotOpenBracket = false;
while (true)
{
if (GetToken( true ) == false)
{
MdlError( "$jigglebone: parse error\n" );
return;
}
if (!stricmp( token, "{" ))
{
gotOpenBracket = true;
}
else if (!gotOpenBracket)
{
MdlError( "$jigglebone: missing '{'\n" );
return;
}
else if (!stricmp( token, "}" ))
{
// definition complete
break;
}
else if (!stricmp( token, "is_flexible" ))
{
if (ParseFlexibleJiggle( jiggleInfo ) == false)
{
return;
}
}
else if (!stricmp( token, "is_rigid" ))
{
if (ParseRigidJiggle( jiggleInfo ) == false)
{
return;
}
}
else if (!stricmp( token, "has_base_spring" ))
{
if (ParseBaseSpringJiggle( jiggleInfo ) == false)
{
return;
}
}
else if ( !stricmp( token, "is_boing" ) )
{
if ( ParseBoing( jiggleInfo ) == false )
{
return;
}
}
else
{
MdlError( "$jigglebone: invalid syntax '%s'\n", token );
return;
}
}
if (!g_quiet)
Msg( "Marking bone %s as a jiggle bone\n", jiggleInfo->bonename );
g_numjigglebones++;
}
//-----------------------------------------------------------------------------
// Purpose: specify bones to store, even if nothing references them
//-----------------------------------------------------------------------------
void Cmd_IncludeModel( )
{
GetToken( false );
V_strcpy_safe( g_includemodel[g_numincludemodels].name, "models/" );
V_strcat_safe( g_includemodel[g_numincludemodels].name, token );
g_numincludemodels++;
}
/*
=================
=================
*/
void Grab_Vertexanimation( s_source_t *psource, const char *pAnimName )
{
char cmd[1024];
int index;
Vector pos;
Vector normal;
int t = -1;
int count = 0;
static s_vertanim_t tmpvanim[MAXSTUDIOVERTS*4];
s_sourceanim_t *pAnim = FindSourceAnim( psource, pAnimName );
if ( !pAnim )
{
MdlError( "Unknown animation %s(%d) : %s\n", pAnimName, g_iLinecount, g_szLine );
}
while (GetLineInput())
{
if (sscanf( g_szLine, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &normal[0], &normal[1], &normal[2] ) == 7)
{
if ( pAnim->startframe < 0 )
{
MdlError( "Missing frame start(%d) : %s", g_iLinecount, g_szLine );
}
if (t < 0)
{
MdlError( "VTA Frame Sync (%d) : %s", g_iLinecount, g_szLine );
}
tmpvanim[count].vertex = index;
VectorCopy( pos, tmpvanim[count].pos );
VectorCopy( normal, tmpvanim[count].normal );
count++;
if ( index >= psource->numvertices )
{
psource->numvertices = index + 1;
}
}
else
{
// flush data
if (count)
{
pAnim->numvanims[t] = count;
pAnim->vanim[t] = (s_vertanim_t *)kalloc( count, sizeof( s_vertanim_t ) );
memcpy( pAnim->vanim[t], tmpvanim, count * sizeof( s_vertanim_t ) );
}
else if (t > 0)
{
pAnim->numvanims[t] = 0;
}
// next command
if (sscanf( g_szLine, "%1023s %d", cmd, &index ))
{
if (stricmp( cmd, "time" ) == 0)
{
t = index;
count = 0;
if ( t < pAnim->startframe )
{
MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
}
if ( t > pAnim->endframe )
{
MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
}
t -= pAnim->startframe;
}
else if ( !Q_stricmp( cmd, "end" ) )
{
pAnim->numframes = pAnim->endframe - pAnim->startframe + 1;
return;
}
else
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
}
else
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
}
}
MdlError( "unexpected EOF: %s\n", psource->filename );
}
bool GetGlobalFilePath( const char *pSrc, char *pFullPath, int nMaxLen )
{
char pFileName[1024];
Q_strncpy( pFileName, ExpandPath( (char*)pSrc ), sizeof(pFileName) );
// This is kinda gross. . . doing the same work in cmdlib on SafeOpenRead.
int nPathLength;
if( CmdLib_HasBasePath( pFileName, nPathLength ) )
{
char tmp[1024];
int i;
int nNumBasePaths = CmdLib_GetNumBasePaths();
for( i = 0; i < nNumBasePaths; i++ )
{
V_strcpy_safe( tmp, CmdLib_GetBasePath( i ) );
V_strcat_safe( tmp, pFileName + nPathLength );
struct _stat buf;
int rt = _stat( tmp, &buf );
if ( rt != -1 && ( buf.st_size > 0 ) && ( ( buf.st_mode & _S_IFDIR ) == 0 ) )
{
Q_strncpy( pFullPath, tmp, nMaxLen );
return true;
}
}
return false;
}
struct _stat buf;
int rt = _stat( pFileName, &buf );
if ( rt != -1 && ( buf.st_size > 0 ) && ( ( buf.st_mode & _S_IFDIR ) == 0 ) )
{
Q_strncpy( pFullPath, pFileName, nMaxLen );
return true;
}
return false;
}
int OpenGlobalFile( char *src )
{
int time1;
char filename[1024];
V_strcpy_safe( filename, ExpandPath( src ) );
int pathLength;
int numBasePaths = CmdLib_GetNumBasePaths();
// This is kinda gross. . . doing the same work in cmdlib on SafeOpenRead.
if( CmdLib_HasBasePath( filename, pathLength ) )
{
char tmp[1024];
int i;
for( i = 0; i < numBasePaths; i++ )
{
V_strcpy_safe( tmp, CmdLib_GetBasePath( i ) );
V_strcat_safe( tmp, filename + pathLength );
if( g_bCreateMakefile )
{
CreateMakefile_AddDependency( tmp );
return 0;
}
time1 = FileTime( tmp );
if( time1 != -1 )
{
if ((g_fpInput = fopen(tmp, "r" ) ) == 0)
{
MdlWarning( "reader: could not open file '%s'\n", src );
return 0;
}
else
{
return 1;
}
}
}
return 0;
}
else
{
time1 = FileTime (filename);
if (time1 == -1)
return 0;
if( g_bCreateMakefile )
{
CreateMakefile_AddDependency( filename );
return 0;
}
if ((g_fpInput = fopen(filename, "r" ) ) == 0)
{
MdlWarning( "reader: could not open file '%s'\n", src );
return 0;
}
return 1;
}
}
int Load_VTA( s_source_t *psource )
{
char cmd[1024];
int option;
if (!OpenGlobalFile( psource->filename ))
return 0;
if (!g_quiet)
printf ("VTA MODEL %s\n", psource->filename);
g_iLinecount = 0;
while (GetLineInput())
{
g_iLinecount++;
sscanf( g_szLine, "%s %d", cmd, &option );
if (stricmp( cmd, "version" ) == 0)
{
if (option != 1)
{
MdlError("bad version\n");
}
}
else if (stricmp( cmd, "nodes" ) == 0)
{
psource->numbones = Grab_Nodes( psource->localBone );
}
else if (stricmp( cmd, "skeleton" ) == 0)
{
Grab_Animation( psource, "VertexAnimation" );
}
else if (stricmp( cmd, "vertexanimation" ) == 0)
{
Grab_Vertexanimation( psource, "VertexAnimation" );
}
else
{
MdlWarning("unknown studio command \"%s\"\n", cmd );
}
}
fclose( g_fpInput );
return 1;
}
void Grab_AxisInterpBones( )
{
char cmd[1024], tmp[1025];
Vector basepos;
s_axisinterpbone_t *pAxis = NULL;
s_axisinterpbone_t *pBone = &g_axisinterpbones[g_numaxisinterpbones];
while (GetLineInput())
{
if (IsEnd( g_szLine ))
{
return;
}
int i = sscanf( g_szLine, "%1023s \"%[^\"]\" \"%[^\"]\" \"%[^\"]\" \"%[^\"]\" %d", cmd, pBone->bonename, tmp, pBone->controlname, tmp, &pBone->axis );
if (i == 6 && stricmp( cmd, "bone") == 0)
{
// printf( "\"%s\" \"%s\" \"%s\" \"%s\"\n", cmd, pBone->bonename, tmp, pBone->controlname );
pAxis = pBone;
pBone->axis = pBone->axis - 1; // MAX uses 1..3, engine 0..2
g_numaxisinterpbones++;
pBone = &g_axisinterpbones[g_numaxisinterpbones];
}
else if (stricmp( cmd, "display" ) == 0)
{
// skip all display info
}
else if (stricmp( cmd, "type" ) == 0)
{
// skip all type info
}
else if (stricmp( cmd, "basepos" ) == 0)
{
i = sscanf( g_szLine, "basepos %f %f %f", &basepos.x, &basepos.y, &basepos.z );
// skip all type info
}
else if (stricmp( cmd, "axis" ) == 0)
{
Vector pos;
QAngle rot;
int j;
i = sscanf( g_szLine, "axis %d %f %f %f %f %f %f", &j, &pos[0], &pos[1], &pos[2], &rot[2], &rot[0], &rot[1] );
if (i == 7)
{
VectorAdd( basepos, pos, pAxis->pos[j] );
AngleQuaternion( rot, pAxis->quat[j] );
}
}
}
}
bool Grab_AimAtBones( )
{
s_aimatbone_t *pAimAtBone( &g_aimatbones[g_numaimatbones] );
// Already know it's <aimconstraint> in the first string, otherwise wouldn't be here
if ( sscanf( g_szLine, "%*s %127s %127s %127s", pAimAtBone->bonename, pAimAtBone->parentname, pAimAtBone->aimname ) == 3 )
{
g_numaimatbones++;
char cmd[1024];
Vector vector;
while ( GetLineInput() )
{
g_iLinecount++;
if (IsEnd( g_szLine ))
{
return false;
}
if ( sscanf( g_szLine, "%1024s %f %f %f", cmd, &vector[0], &vector[1], &vector[2] ) != 4 )
{
// Allow blank lines to be skipped without error
bool allSpace( true );
for ( const char *pC( g_szLine ); *pC != '\0' && pC < ( g_szLine + 4096 ); ++pC )
{
if ( !V_isspace( *pC ) )
{
allSpace = false;
break;
}
}
if ( allSpace )
{
continue;
}
return true;
}
if ( stricmp( cmd, "<aimvector>" ) == 0)
{
// Make sure these are unit length on read
VectorNormalize( vector );
pAimAtBone->aimvector = vector;
}
else if ( stricmp( cmd, "<upvector>" ) == 0)
{
// Make sure these are unit length on read
VectorNormalize( vector );
pAimAtBone->upvector = vector;
}
else if ( stricmp( cmd, "<basepos>" ) == 0)
{
pAimAtBone->basepos = vector;
}
else
{
return true;
}
}
}
// If we get here, we're at EOF
return false;
}
void Grab_QuatInterpBones( )
{
char cmd[1024];
Vector basepos;
RadianEuler rotateaxis( 0.0f, 0.0f, 0.0f );
RadianEuler jointorient( 0.0f, 0.0f, 0.0f );
s_quatinterpbone_t *pAxis = NULL;
s_quatinterpbone_t *pBone = &g_quatinterpbones[g_numquatinterpbones];
while (GetLineInput())
{
g_iLinecount++;
if (IsEnd( g_szLine ))
{
return;
}
int i = sscanf( g_szLine, "%s %s %s %s %s", cmd, pBone->bonename, pBone->parentname, pBone->controlparentname, pBone->controlname );
while ( i == 4 && stricmp( cmd, "<aimconstraint>" ) == 0 )
{
// If Grab_AimAtBones() returns false, there file is at EOF
if ( !Grab_AimAtBones() )
{
return;
}
// Grab_AimAtBones will read input into g_szLine same as here until it gets a line it doesn't understand, at which point
// it will exit leaving that line in g_szLine, so check for the end and scan the current buffer again and continue on with
// the normal QuatInterpBones process
i = sscanf( g_szLine, "%s %s %s %s %s", cmd, pBone->bonename, pBone->parentname, pBone->controlparentname, pBone->controlname );
}
if (i == 5 && stricmp( cmd, "<helper>") == 0)
{
// printf( "\"%s\" \"%s\" \"%s\" \"%s\"\n", cmd, pBone->bonename, tmp, pBone->controlname );
pAxis = pBone;
g_numquatinterpbones++;
pBone = &g_quatinterpbones[g_numquatinterpbones];
}
else if ( i > 0 )
{
// There was a bug before which could cause the same command to be parsed twice
// because if the sscanf above completely fails, it will return 0 and not
// change the contents of cmd, so i should be greater than 0 in order for
// any of these checks to be valid... Still kind of buggy as these checks
// do case insensitive stricmp but then the sscanf does case sensitive
// matching afterwards... Should probably change those to
// sscanf( g_szLine, "%*s %f ... ) etc...
if ( stricmp( cmd, "<display>" ) == 0)
{
// skip all display info
Vector size;
float distance;
i = sscanf( g_szLine, "<display> %f %f %f %f",
&size[0], &size[1], &size[2],
&distance );
if (i == 4)
{
pAxis->percentage = distance / 100.0;
pAxis->size = size;
}
else
{
MdlError( "Line %d: Unable to parse procedual <display> bone: %s", g_iLinecount, g_szLine );
}
}
else if ( stricmp( cmd, "<basepos>" ) == 0)
{
i = sscanf( g_szLine, "<basepos> %f %f %f", &basepos.x, &basepos.y, &basepos.z );
// skip all type info
}
else if ( stricmp( cmd, "<rotateaxis>" ) == 0)
{
i = sscanf( g_szLine, "%*s %f %f %f", &rotateaxis.x, &rotateaxis.y, &rotateaxis.z );
rotateaxis.x = DEG2RAD( rotateaxis.x );
rotateaxis.y = DEG2RAD( rotateaxis.y );
rotateaxis.z = DEG2RAD( rotateaxis.z );
}
else if ( stricmp( cmd, "<jointorient>" ) == 0)
{
i = sscanf( g_szLine, "%*s %f %f %f", &jointorient.x, &jointorient.y, &jointorient.z );
jointorient.x = DEG2RAD( jointorient.x );
jointorient.y = DEG2RAD( jointorient.y );
jointorient.z = DEG2RAD( jointorient.z );
}
else if ( stricmp( cmd, "<trigger>" ) == 0)
{
float tolerance;
RadianEuler trigger;
Vector pos;
RadianEuler ang;
QAngle rot;
int j;
i = sscanf( g_szLine, "<trigger> %f %f %f %f %f %f %f %f %f %f",
&tolerance,
&trigger.x, &trigger.y, &trigger.z,
&ang.x, &ang.y, &ang.z,
&pos.x, &pos.y, &pos.z );
if (i == 10)
{
trigger.x = DEG2RAD( trigger.x );
trigger.y = DEG2RAD( trigger.y );
trigger.z = DEG2RAD( trigger.z );
ang.x = DEG2RAD( ang.x );
ang.y = DEG2RAD( ang.y );
ang.z = DEG2RAD( ang.z );
Quaternion q;
AngleQuaternion( ang, q );
if ( rotateaxis.x != 0.0 || rotateaxis.y != 0.0 || rotateaxis.z != 0.0 )
{
Quaternion q1;
Quaternion q2;
AngleQuaternion( rotateaxis, q1 );
QuaternionMult( q1, q, q2 );
q = q2;
}
if ( jointorient.x != 0.0 || jointorient.y != 0.0 || jointorient.z != 0.0 )
{
Quaternion q1;
Quaternion q2;
AngleQuaternion( jointorient, q1 );
QuaternionMult( q, q1, q2 );
q = q2;
}
j = pAxis->numtriggers++;
pAxis->tolerance[j] = DEG2RAD( tolerance );
AngleQuaternion( trigger, pAxis->trigger[j] );
VectorAdd( basepos, pos, pAxis->pos[j] );
pAxis->quat[j] = q;
}
else
{
MdlError( "Line %d: Unable to parse procedual <trigger> bone: %s", g_iLinecount, g_szLine );
}
}
else
{
MdlError( "Line %d: Unable to parse procedual bone data: %s", g_iLinecount, g_szLine );
}
}
else
{
// Allow blank lines to be skipped without error
bool allSpace( true );
for ( const char *pC( g_szLine ); *pC != '\0' && pC < ( g_szLine + 4096 ); ++pC )
{
if ( !V_isspace( *pC ) )
{
allSpace = false;
break;
}
}
if ( !allSpace )
{
MdlError( "Line %d: Unable to parse procedual bone data: %s", g_iLinecount, g_szLine );
}
}
}
}
void Load_ProceduralBones( )
{
char filename[256];
char cmd[1024];
int option;
GetToken( false );
V_strcpy_safe( filename, token );
if (!OpenGlobalFile( filename ))
return;
g_iLinecount = 0;
char ext[32];
Q_ExtractFileExtension( filename, ext, sizeof( ext ) );
if (stricmp( ext, "vrd") == 0)
{
Grab_QuatInterpBones( );
}
else
{
while (GetLineInput())
{
g_iLinecount++;
sscanf( g_szLine, "%s %d", cmd, &option );
if (stricmp( cmd, "version" ) == 0)
{
if (option != 1)
{
MdlError("bad version\n");
}
}
else if (stricmp( cmd, "proceduralbones" ) == 0)
{
Grab_AxisInterpBones( );
}
}
}
fclose( g_fpInput );
}
void Cmd_CD()
{
if (cdset)
MdlError ("Two $cd in one model");
cdset = true;
GetToken (false);
V_strcpy_safe (cddir[0], token);
V_strcat_safe (cddir[0], "/" );
numdirs = 0;
}
void Cmd_CDMaterials()
{
while (TokenAvailable())
{
GetToken (false);
char szPath[512];
Q_strncpy( szPath, token, sizeof( szPath ) );
int len = strlen( szPath );
if ( len > 0 && szPath[len-1] != '/' && szPath[len-1] != '\\' )
{
Q_strncat( szPath, "/", sizeof( szPath ), COPY_ALL_CHARACTERS );
}
Q_FixSlashes( szPath );
cdtextures[numcdtextures] = strdup( szPath );
numcdtextures++;
}
}
void Cmd_Pushd()
{
GetToken(false);
V_strcpy_safe( cddir[numdirs+1], cddir[numdirs] );
V_strcat_safe( cddir[numdirs+1], token );
V_strcat_safe( cddir[numdirs+1], "/" );
numdirs++;
}
void Cmd_Popd()
{
if (numdirs > 0)
numdirs--;
}
void Cmd_CollisionModel()
{
DoCollisionModel( false );
}
void Cmd_CollisionJoints()
{
DoCollisionModel( true );
}
void Cmd_ExternalTextures()
{
MdlWarning( "ignoring $externaltextures, obsolete..." );
}
void Cmd_ClipToTextures()
{
clip_texcoords = 1;
}
void Cmd_CollapseBones()
{
g_collapse_bones = true;
}
void Cmd_CollapseBonesAggressive()
{
g_collapse_bones = true;
g_collapse_bones_aggressive = true;
}
void Cmd_AlwaysCollapse()
{
g_collapse_bones = true;
GetToken(false);
g_collapse.AddToTail( strdup( token ) );
}
void Cmd_CalcTransitions()
{
g_bMultistageGraph = true;
}
void Cmd_StaticProp()
{
g_staticprop = true;
gflags |= STUDIOHDR_FLAGS_STATIC_PROP;
}
void Cmd_ZBrush()
{
g_bZBrush = true;
}
void Cmd_RealignBones()
{
g_realignbones = true;
}
void Cmd_BaseLOD()
{
Cmd_LOD( "$lod" );
}
void Cmd_KeyValues()
{
Option_KeyValues( &g_KeyValueText );
}
void Cmd_ConstDirectionalLight()
{
gflags |= STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT;
GetToken (false);
g_constdirectionalightdot = (byte)( verify_atof(token) * 255.0f );
}
void Cmd_MinLOD()
{
GetToken( false );
g_minLod = atoi( token );
// "minlod" rules over "allowrootlods"
if ( g_numAllowedRootLODs > 0 && g_numAllowedRootLODs < g_minLod )
{
MdlWarning( "$minlod %d overrides $allowrootlods %d, proceeding with $allowrootlods %d.\n", g_minLod, g_numAllowedRootLODs, g_minLod );
g_numAllowedRootLODs = g_minLod;
}
}
void Cmd_AllowRootLODs()
{
GetToken( false );
g_numAllowedRootLODs = atoi( token );
// Root LOD restriction has to obey "minlod" request
if ( g_numAllowedRootLODs > 0 && g_numAllowedRootLODs < g_minLod )
{
MdlWarning( "$allowrootlods %d is conflicting with $minlod %d, proceeding with $allowrootlods %d.\n", g_numAllowedRootLODs, g_minLod, g_minLod );
g_numAllowedRootLODs = g_minLod;
}
}
void Cmd_BoneSaveFrame( )
{
s_bonesaveframe_t tmp;
// bone name
GetToken( false );
V_strcpy_safe( tmp.name, token );
tmp.bSavePos = false;
tmp.bSaveRot = false;
while (TokenAvailable( ))
{
GetToken( false );
if (stricmp( "position", token ) == 0)
{
tmp.bSavePos = true;
}
else if (stricmp( "rotation", token ) == 0)
{
tmp.bSaveRot = true;
}
else
{
MdlError( "unknown option \"%s\" on $bonesaveframe : %s\n", token, tmp.name );
}
}
g_bonesaveframe.AddToTail( tmp );
}
//
// This is the master list of the commands a QC file supports.
// To add a new command to the QC files, add it here.
//
struct
{
char *m_pName;
void (*m_pCmd)();
} g_Commands[] =
{
{ "$cd", Cmd_CD },
{ "$modelname", Cmd_Modelname },
{ "$cdmaterials", Cmd_CDMaterials },
{ "$pushd", Cmd_Pushd },
{ "$popd", Cmd_Popd },
{ "$scale", Cmd_ScaleUp },
{ "$root", Cmd_Root },
{ "$controller", Cmd_Controller },
{ "$screenalign", Cmd_ScreenAlign },
{ "$model", Cmd_Model },
{ "$collisionmodel", Cmd_CollisionModel },
{ "$collisionjoints", Cmd_CollisionJoints },
{ "$collisiontext", Cmd_CollisionText },
{ "$body", Cmd_Body },
{ "$bodygroup", Cmd_Bodygroup },
{ "$animation", Cmd_Animation },
{ "$autocenter", Cmd_Autocenter },
{ "$sequence", Cmd_Sequence },
{ "$append", Cmd_Append },
{ "$prepend", Cmd_Prepend },
{ "$continue", Cmd_Continue },
{ "$declaresequence", Cmd_DeclareSequence },
{ "$declareanimation", Cmd_DeclareAnimation },
{ "$cmdlist", Cmd_Cmdlist },
{ "$animblocksize", Cmd_AnimBlockSize },
{ "$weightlist", Cmd_Weightlist },
{ "$defaultweightlist", Cmd_DefaultWeightlist },
{ "$ikchain", Cmd_IKChain },
{ "$ikautoplaylock", Cmd_IKAutoplayLock },
{ "$eyeposition", Cmd_Eyeposition },
{ "$illumposition", Cmd_Illumposition },
{ "$origin", Cmd_Origin },
{ "$upaxis", Cmd_UpAxis },
{ "$bbox", Cmd_BBox },
{ "$cbox", Cmd_CBox },
{ "$gamma", Cmd_Gamma },
{ "$texturegroup", Cmd_TextureGroup },
{ "$hgroup", Cmd_Hitgroup },
{ "$hbox", Cmd_Hitbox },
{ "$hboxset", Cmd_HitboxSet },
{ "$surfaceprop", Cmd_SurfaceProp },
{ "$jointsurfaceprop", Cmd_JointSurfaceProp },
{ "$contents", Cmd_Contents },
{ "$jointcontents", Cmd_JointContents },
{ "$attachment", Cmd_Attachment },
{ "$bonemerge", Cmd_BoneMerge },
{ "$externaltextures", Cmd_ExternalTextures },
{ "$cliptotextures", Cmd_ClipToTextures },
{ "$renamebone", Cmd_Renamebone },
{ "$collapsebones", Cmd_CollapseBones },
{ "$collapsebonesaggressive", Cmd_CollapseBonesAggressive },
{ "$alwayscollapse", Cmd_AlwaysCollapse },
{ "$proceduralbones", Load_ProceduralBones },
{ "$skiptransition", Cmd_Skiptransition },
{ "$calctransitions", Cmd_CalcTransitions },
{ "$staticprop", Cmd_StaticProp },
{ "$zbrush", Cmd_ZBrush },
{ "$realignbones", Cmd_RealignBones },
{ "$forcerealign", Cmd_ForceRealign },
{ "$lod", Cmd_BaseLOD },
{ "$shadowlod", Cmd_ShadowLOD },
{ "$poseparameter", Cmd_PoseParameter },
{ "$heirarchy", Cmd_ForcedHierarchy },
{ "$hierarchy", Cmd_ForcedHierarchy },
{ "$insertbone", Cmd_InsertHierarchy },
{ "$limitrotation", Cmd_LimitRotation },
{ "$definebone", Cmd_DefineBone },
{ "$jigglebone", Cmd_JiggleBone },
{ "$includemodel", Cmd_IncludeModel },
{ "$opaque", Cmd_Opaque },
{ "$mostlyopaque", Cmd_TranslucentTwoPass },
// { "$platform", Cmd_Platform },
{ "$keyvalues", Cmd_KeyValues },
{ "$obsolete", Cmd_Obsolete },
{ "$renamematerial", Cmd_RenameMaterial },
{ "$fakevta", Cmd_FakeVTA },
{ "$noforcedfade", Cmd_NoForcedFade },
{ "$skipboneinbbox", Cmd_SkipBoneInBBox },
{ "$forcephonemecrossfade", Cmd_ForcePhonemeCrossfade },
{ "$lockbonelengths", Cmd_LockBoneLengths },
{ "$unlockdefinebones", Cmd_UnlockDefineBones },
{ "$constantdirectionallight", Cmd_ConstDirectionalLight },
{ "$minlod", Cmd_MinLOD },
{ "$allowrootlods", Cmd_AllowRootLODs },
{ "$bonesaveframe", Cmd_BoneSaveFrame },
{ "$ambientboost", Cmd_AmbientBoost },
{ "$centerbonesonverts", Cmd_CenterBonesOnVerts },
{ "$donotcastshadows", Cmd_DoNotCastShadows },
{ "$casttextureshadows", Cmd_CastTextureShadows },
{ "$motionrollback", Cmd_MotionExtractionRollBack },
{ "$sectionframes", Cmd_SectionFrames },
{ "$clampworldspace", Cmd_ClampWorldspace },
{ "$maxeyedeflection", Cmd_MaxEyeDeflection },
{ "$boneflexdriver", Cmd_BoneFlexDriver },
{ "$checkuv", Cmd_CheckUV }
};
/*
===============
ParseScript
===============
*/
void ParseScript (void)
{
while (1)
{
GetToken (true);
if (endofscript)
return;
// Check all the commands we know about.
int i;
for ( i=0; i < ARRAYSIZE( g_Commands ); i++ )
{
if ( !stricmp( g_Commands[i].m_pName, token ) )
{
g_Commands[i].m_pCmd();
break;
}
}
if ( i == ARRAYSIZE( g_Commands ) )
{
if( !g_bCreateMakefile )
{
TokenError("bad command %s\n", token);
}
}
}
}
//-----------------------------------------------------------------------------
// Generate the model name
//-----------------------------------------------------------------------------
bool GenerateModelName( CDmeMDLMakefile *pMDLMakeFile )
{
// The model name is implicit in the makefile name
// NOTE: Model name is relative to the 'models' directory
char pOutputFullPath[MAX_PATH];
pMDLMakeFile->GetOutputName( pOutputFullPath, sizeof(pOutputFullPath) );
Q_SetExtension( pOutputFullPath, ".mdl", sizeof( pOutputFullPath) );
char pModelSubDir[MAX_PATH];
GetModSubdirectory( "models", pModelSubDir, sizeof(pModelSubDir) );
char pRelativePath[MAX_PATH];
if ( !Q_MakeRelativePath( pOutputFullPath, pModelSubDir, pRelativePath, sizeof(pRelativePath) ) )
{
MdlError( "Makefile \"%s\" doesn't lie under the correct vproject \"%s\"!\n",
pOutputFullPath, pModelSubDir );
return false;
}
ProcessModelName( pRelativePath );
return true;
}
//-----------------------------------------------------------------------------
// Process skins
//-----------------------------------------------------------------------------
bool GenerateSkin( CDmeMDLMakefile *pMDLMakeFile )
{
CUtlVector< CDmeHandle< CDmeSourceSkin > > bodies;
pMDLMakeFile->GetSources< CDmeSourceSkin >( bodies );
int nCount = bodies.Count();
for ( int i = 0; i < nCount; ++i )
{
if ( !bodies[i] )
continue;
char pFullPath[MAX_PATH];
pMDLMakeFile->GetSourceFullPath( bodies[i], pFullPath, sizeof(pFullPath) );
// Empty strings are ignored
if ( !pFullPath[0] )
continue;
ProcessCmdBody( pFullPath, bodies[i] );
}
return true;
}
//-----------------------------------------------------------------------------
// Process animations
//-----------------------------------------------------------------------------
bool GenerateAnimations( CDmeMDLMakefile *pMDLMakeFile )
{
CUtlVector< CDmeHandle< CDmeSourceAnimation > > animationFiles;
pMDLMakeFile->GetSources< CDmeSourceAnimation >( animationFiles );
int nCount = animationFiles.Count();
for ( int i = 0; i < nCount; ++i )
{
if ( !animationFiles[i] )
continue;
char pFullPath[MAX_PATH];
pMDLMakeFile->GetSourceFullPath( animationFiles[i], pFullPath, sizeof(pFullPath) );
// Empty strings are ignored
if ( !pFullPath[0] )
continue;
// Totally spoof the animation info.. not sure where to get it from yet
// assume it's an animation reference
// first look up an existing animation
s_sequence_t *pseq = ProcessCmdSequence( animationFiles[i]->m_AnimationName );
if ( !pseq )
continue;
int n;
s_animation_t *animations[64];
int numblends = 0;
for ( n = 0; n < g_numani; n++ )
{
if ( !Q_stricmp( pFullPath, g_panimation[n]->name ) )
{
animations[numblends++] = g_panimation[n];
break;
}
}
if ( n >= g_numani )
{
// assume it's an implied animation
animations[numblends++] = Cmd_ImpliedAnimation( pseq, pFullPath );
}
// hack to allow animation commands to refer to same sequence
if ( numblends == 1 )
{
pseq->panim[0][0] = animations[0];
}
// Look up the source animation from the animation name
for ( int j = 0; j < numblends; ++j )
{
s_sourceanim_t *pSourceAnim = FindSourceAnim( animations[j]->source, animationFiles[i]->m_SourceAnimationName );
// NOTE: This always affects the first source anim read in
if ( pSourceAnim )
{
animations[j]->startframe = pSourceAnim->startframe;
animations[j]->endframe = pSourceAnim->endframe;
if ( !g_bCreateMakefile && animations[j]->endframe < animations[j]->startframe )
{
TokenError( "end frame before start frame in %s", animations[j]->name );
}
animations[j]->numframes = animations[j]->endframe - animations[j]->startframe + 1;
Q_strncpy( animations[j]->animationname, animationFiles[i]->m_SourceAnimationName, sizeof(animations[j]->animationname) );
}
else
{
MdlError( "Requested unknown animation block name %s\n", animationFiles[i]->m_SourceAnimationName.Get() );
}
}
ProcessSequence( pseq, numblends, animations, false );
}
return true;
}
//-----------------------------------------------------------------------------
// Parse the MDL makefile
//-----------------------------------------------------------------------------
void ParseMDLMakeFile( CDmeMDLMakefile *pMDLMakeFile )
{
if ( !GenerateModelName( pMDLMakeFile ) )
return;
// All DMX files have Y as the up axis
RadianEuler angles( M_PI / 2.0f, 0.0f, M_PI / 2.0f );
ProcessUpAxis( angles );
// Process bodies
if ( !GenerateSkin( pMDLMakeFile ) )
return;
// Process animations
if ( !GenerateAnimations( pMDLMakeFile ) )
return;
}
// Used by the CheckSurfaceProps.py script.
// They specify the .mdl file and it prints out all the surface props that the model uses.
bool HandlePrintSurfaceProps( int &returnValue )
{
const char *pFilename = CommandLine()->ParmValue( "-PrintSurfaceProps", (const char*)NULL );
if ( pFilename )
{
CUtlVector<char> buf;
FILE *fp = fopen( pFilename, "rb" );
if ( fp )
{
fseek( fp, 0, SEEK_END );
buf.SetSize( ftell( fp ) );
fseek( fp, 0, SEEK_SET );
fread( buf.Base(), 1, buf.Count(), fp );
fclose( fp );
studiohdr_t *pHdr = (studiohdr_t*)buf.Base();
Studio_ConvertStudioHdrToNewVersion( pHdr );
if ( pHdr->version == STUDIO_VERSION )
{
for ( int i=0; i < pHdr->numbones; i++ )
{
mstudiobone_t *pBone = pHdr->pBone( i );
printf( "%s\n", pBone->pszSurfaceProp() );
}
returnValue = 0;
}
else
{
printf( "-PrintSurfaceProps: '%s' is wrong version (%d should be %d).\n",
pFilename, pHdr->version, STUDIO_VERSION );
returnValue = 1;
}
}
else
{
printf( "-PrintSurfaceProps: can't open '%s'\n", pFilename );
returnValue = 1;
}
return true;
}
else
{
return false;
}
}
// Used by the modelstats.pl script.
// They specify the .mdl file and it prints out perf info.
bool HandleMdlReport( int &returnValue )
{
const char *pFilename = CommandLine()->ParmValue( "-mdlreport", (const char*)NULL );
if ( pFilename )
{
CUtlVector<char> buf;
FILE *fp = fopen( pFilename, "rb" );
if ( fp )
{
fseek( fp, 0, SEEK_END );
buf.SetSize( ftell( fp ) );
fseek( fp, 0, SEEK_SET );
fread( buf.Base(), 1, buf.Count(), fp );
fclose( fp );
studiohdr_t *pHdr = (studiohdr_t*)buf.Base();
Studio_ConvertStudioHdrToNewVersion( pHdr );
if ( pHdr->version == STUDIO_VERSION )
{
int flags = SPEWPERFSTATS_SHOWPERF;
if( CommandLine()->CheckParm( "-mdlreportspreadsheet", NULL ) )
{
flags |= SPEWPERFSTATS_SPREADSHEET;
}
SpewPerfStats( pHdr, pFilename, flags );
returnValue = 0;
}
else
{
printf( "-mdlreport: '%s' is wrong version (%d should be %d).\n",
pFilename, pHdr->version, STUDIO_VERSION );
returnValue = 1;
}
}
else
{
printf( "-mdlreport: can't open '%s'\n", pFilename );
returnValue = 1;
}
return true;
}
else
{
return false;
}
}
void UsageAndExit()
{
MdlError( "Bad or missing options\n"
"usage: studiomdl [options] <file.qc>\n"
"options:\n"
"[-a <normal_blend_angle>]\n"
"[-checklengths]\n"
"[-d] - dump glview files\n"
"[-definebones]\n"
"[-f] - flip all triangles\n"
"[-fullcollide] - don't truncate really big collisionmodels\n"
"[-game <gamedir>]\n"
"[-h] - dump hboxes\n"
"[-i] - ignore warnings\n"
"[-minlod <lod>] - truncate to highest detail <lod>\n"
"[-n] - tag bad normals\n"
"[-perf] report perf info upon compiling model\n"
"[-printbones]\n"
"[-printgraph]\n"
"[-quiet] - operate silently\n"
"[-r] - tag reversed\n"
"[-t <texture>]\n"
"[-x360] - generate xbox360 output\n"
"[-nox360] - disable xbox360 output(default)\n"
"[-nowarnings] - disable warnings\n"
"[-dumpmaterials] - dump out material names\n"
"[-mdlreport] model.mdl - report perf info\n"
"[-mdlreportspreadsheet] - report perf info as a comma-delimited spreadsheet\n"
"[-striplods] - use only lod0\n"
"[-overridedefinebones] - equivalent to specifying $unlockdefinebones in .qc file\n"
"[-stripmodel] - process binary model files and strip extra lod data\n"
"[-stripvhv] - strip hardware verts to match the stripped model\n"
"[-vsi] - generate stripping information .vsi file - can be used on .mdl files too\n"
);
}
#ifndef _DEBUG
LONG __stdcall VExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo )
{
MdlExceptionFilter( ExceptionInfo->ExceptionRecord->ExceptionCode );
return EXCEPTION_EXECUTE_HANDLER; // (never gets here anyway)
}
#endif
/*
==============
main
==============
*/
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
class CStudioMDLApp : public CDefaultAppSystemGroup< CSteamAppSystemGroup >
{
typedef CDefaultAppSystemGroup< CSteamAppSystemGroup > BaseClass;
public:
// Methods of IApplication
virtual bool Create();
virtual bool PreInit( );
virtual int Main();
virtual void PostShutdown();
private:
int Main_StripModel();
int Main_StripVhv();
int Main_MakeVsi();
private:
bool ParseArguments();
};
static bool CStudioMDLApp_SuggestGameInfoDirFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories )
{
const char *pProcessFileName = NULL;
int nParmCount = CommandLine()->ParmCount();
if ( nParmCount > 1 )
{
pProcessFileName = CommandLine()->GetParm( nParmCount - 1 );
}
if ( pProcessFileName )
{
Q_MakeAbsolutePath( pchPathBuffer, nBufferLength, pProcessFileName );
if ( pbBubbleDirectories )
*pbBubbleDirectories = true;
return true;
}
return false;
}
int main( int argc, char **argv )
{
SetSuggestGameInfoDirFn( CStudioMDLApp_SuggestGameInfoDirFn );
CStudioMDLApp s_ApplicationObject;
CSteamApplication s_SteamApplicationObject( &s_ApplicationObject );
return AppMain( argc, argv, &s_SteamApplicationObject );
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CStudioMDLApp::Create()
{
InstallSpewFunction();
// override the default spew function
SpewOutputFunc( MdlSpewOutputFunc );
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
#ifndef _DEBUG
SetUnhandledExceptionFilter( VExceptionFilter );
#endif
if ( CommandLine()->ParmCount() == 1 )
{
UsageAndExit();
return false;
}
int nReturnValue;
if ( HandlePrintSurfaceProps( nReturnValue ) )
return false;
if ( !ParseArguments() )
return false;
AppSystemInfo_t appSystems[] =
{
{ "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION },
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
{ "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION },
{ "mdllib.dll", MDLLIB_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
AddSystem( g_pDataModel, VDATAMODEL_INTERFACE_VERSION );
AddSystem( g_pDmElementFramework, VDMELEMENTFRAMEWORK_VERSION );
AddSystem( g_pDmSerializers, DMSERIALIZERS_INTERFACE_VERSION );
// Add in the locally-defined studio data cache
AppModule_t studioDataCacheModule = LoadModule( Sys_GetFactoryThis() );
AddSystem( studioDataCacheModule, STUDIO_DATA_CACHE_INTERFACE_VERSION );
// Add the P4 module separately so that if it is absent (say in the SDK) then the other system will initialize properly
if ( !CommandLine()->FindParm( "-nop4" ) )
{
AppModule_t p4Module = LoadModule( "p4lib.dll" );
AddSystem( p4Module, P4_INTERFACE_VERSION );
}
bool bOk = AddSystems( appSystems );
if ( !bOk )
return false;
IMaterialSystem *pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
if ( !pMaterialSystem )
return false;
pMaterialSystem->SetShaderAPI( "shaderapiempty.dll" );
return true;
}
bool CStudioMDLApp::PreInit( )
{
CreateInterfaceFn factory = GetFactory();
ConnectTier1Libraries( &factory, 1 );
ConnectTier2Libraries( &factory, 1 );
ConnectTier3Libraries( &factory, 1 );
if ( !g_pFullFileSystem || !g_pDataModel || !g_pMaterialSystem || !g_pStudioRender )
{
Warning( "StudioMDL is missing a required interface!\n" );
return false;
}
if ( !SetupSearchPaths( g_path, false, true ) )
return false;
// NOTE: This is necessary to get the cmdlib filesystem stuff to work.
g_pFileSystem = g_pFullFileSystem;
// NOTE: This is stuff copied out of cmdlib necessary to get
// the tools in cmdlib working
FileSystem_SetupStandardDirectories( g_path, GetGameInfoPath() );
return true;
}
void CStudioMDLApp::PostShutdown()
{
DisconnectTier3Libraries();
DisconnectTier2Libraries();
DisconnectTier1Libraries();
}
//-----------------------------------------------------------------------------
// Method which parses arguments
//-----------------------------------------------------------------------------
bool CStudioMDLApp::ParseArguments()
{
g_currentscale = g_defaultscale = 1.0;
g_defaultrotation = RadianEuler( 0, 0, M_PI / 2 );
// skip weightlist 0
g_numweightlist = 1;
eyeposition = Vector( 0, 0, 0 );
gflags = 0;
numrep = 0;
tag_reversed = 0;
tag_normals = 0;
normal_blend = cos( DEG2RAD( 2.0 ));
g_gamma = 2.2;
g_staticprop = false;
g_centerstaticprop = false;
g_realignbones = false;
g_constdirectionalightdot = 0;
g_bDumpGLViewFiles = false;
g_quiet = false;
g_illumpositionattachment = 0;
g_flMaxEyeDeflection = 0.0f;
int argc = CommandLine()->ParmCount();
int i;
for ( i = 1; i < argc - 1; i++ )
{
const char *pArgv = CommandLine()->GetParm( i );
if ( pArgv[0] != '-' )
continue;
if ( !Q_stricmp( pArgv, "-allowdebug" ) )
{
// Ignore, used by interface system to catch debug builds checked into release tree
continue;
}
if ( !Q_stricmp( pArgv, "-mdlreport" ) )
{
// Will reparse later, ignore rest of arguments.
return true;
}
if ( !Q_stricmp( pArgv, "-mdlreportspreadsheet" ) )
{
// Will reparse later, ignore for now.
continue;
}
if ( !Q_stricmp( pArgv, "-ihvtest" ) )
{
++i;
g_IHVTest = true;
continue;
}
if ( !Q_stricmp( pArgv, "-overridedefinebones" ) )
{
g_bOverridePreDefinedBones = true;
continue;
}
if ( !Q_stricmp( pArgv, "-striplods" ) )
{
g_bStripLods = true;
continue;
}
if ( !Q_stricmp( pArgv, "-stripmodel" ) )
{
g_eRunMode = RUN_MODE_STRIP_MODEL;
continue;
}
if ( !Q_stricmp( pArgv, "-stripvhv" ) )
{
g_eRunMode = RUN_MODE_STRIP_VHV;
continue;
}
if ( !Q_stricmp( pArgv, "-vsi" ) )
{
g_bMakeVsi = true;
continue;
}
if ( !Q_stricmp( pArgv, "-quiet" ) )
{
g_quiet = true;
g_verbose = false;
continue;
}
if ( !Q_stricmp( pArgv, "-verbose" ) )
{
g_quiet = false;
g_verbose = true;
continue;
}
if ( !Q_stricmp( pArgv, "-fullcollide" ) )
{
g_badCollide = true;
continue;
}
if ( !Q_stricmp( pArgv, "-checklengths" ) )
{
g_bCheckLengths = true;
continue;
}
if ( !Q_stricmp( pArgv, "-printbones" ) )
{
g_bPrintBones = true;
continue;
}
if ( !Q_stricmp( pArgv, "-perf" ) )
{
g_bPerf = true;
continue;
}
if ( !Q_stricmp( pArgv, "-printgraph" ) )
{
g_bDumpGraph = true;
continue;
}
if ( !Q_stricmp( pArgv, "-definebones" ) )
{
g_definebones = true;
continue;
}
if ( !Q_stricmp( pArgv, "-makefile" ) )
{
g_bCreateMakefile = true;
g_quiet = true;
continue;
}
if ( !Q_stricmp( pArgv, "-verify" ) )
{
g_bVerifyOnly = true;
continue;
}
if ( !Q_stricmp( pArgv, "-minlod" ) )
{
g_minLod = atoi( CommandLine()->GetParm( ++i ) );
continue;
}
if (!Q_stricmp( pArgv, "-x360"))
{
StudioByteSwap::ActivateByteSwapping( true ); // Set target to big endian
g_bX360 = true;
continue;
}
if (!Q_stricmp( pArgv, "-nox360"))
{
g_bX360 = false;
continue;
}
if ( !Q_stricmp( pArgv, "-nowarnings" ) )
{
g_bNoWarnings = true;
continue;
}
if ( !Q_stricmp( pArgv, "-maxwarnings" ) )
{
g_maxWarnings = atoi( CommandLine()->GetParm( ++i ) );
continue;
}
if ( !Q_stricmp( pArgv, "-preview" ) )
{
g_bBuildPreview = true;
continue;
}
if ( !Q_stricmp( pArgv, "-dumpmaterials" ) )
{
g_bDumpMaterials = true;
continue;
}
if ( pArgv[1] && pArgv[2] == '\0' )
{
switch( pArgv[1] )
{
case 't':
i++;
V_strcpy_safe( defaulttexture[numrep], pArgv );
if (i < argc - 2 && CommandLine()->GetParm(i + 1)[0] != '-')
{
i++;
V_strcpy_safe( sourcetexture[numrep], pArgv );
printf("Replacing %s with %s\n", sourcetexture[numrep], defaulttexture[numrep] );
}
printf( "Using default texture: %s\n", defaulttexture[numrep] );
numrep++;
break;
case 'r':
tag_reversed = 1;
break;
case 'n':
tag_normals = 1;
break;
case 'a':
i++;
normal_blend = cos( DEG2RAD( verify_atof( pArgv ) ) );
break;
case 'h':
dump_hboxes = 1;
break;
case 'i':
ignore_warnings = 1;
break;
case 'd':
g_bDumpGLViewFiles = true;
break;
// case 'p':
// i++;
// V_strcpy_safe( qproject, pArgv );
// break;
}
}
}
if ( i >= argc )
{
// misformed arguments
// otherwise generating unintended results
UsageAndExit();
return false;
}
const char *pArgv = CommandLine()->GetParm( i );
Q_strncpy( g_path, pArgv, sizeof(g_path) );
if ( Q_IsAbsolutePath( g_path ) )
{
// Set the working directory to be the path of the qc file
// so the relative-file fopen code works
char pQCDir[MAX_PATH];
Q_ExtractFilePath( g_path, pQCDir, sizeof(pQCDir) );
_chdir( pQCDir );
}
Q_StripExtension( pArgv, outname, sizeof( outname ) );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: search through the "GamePath" key and create a mirrored version in the content path searches
//-----------------------------------------------------------------------------
void AddContentPaths( )
{
// look for the "content" in the path to the initial QC file
char *match = "content\\";
char *sp = strstr( qdir, match );
if (!sp)
return;
// copy off everything before and including "content"
char pre[1024];
strncpy( pre, qdir, sp - qdir + strlen( match ) );
pre[sp - qdir + strlen( match )] = '\0';
sp = sp + strlen( match );
// copy off everything folling the word after "content"
char post[1024];
sp = strstr( sp+1, "\\" );
V_strcpy_safe( post, sp );
// get a copy of the game search paths
char paths[1024];
g_pFullFileSystem->GetSearchPath( "GAME", false, paths, sizeof( paths ) );
if (!g_quiet)
printf("all paths:%s\n", paths );
// pull out the game names and insert them into a content path string
sp = strstr( paths, "game\\" );
while (sp)
{
char temp[1024];
sp = sp + 5;
char *sz = strstr( sp, "\\" );
if (!sz)
return;
V_strcpy_safe( temp, pre );
strncat( temp, sp, sz - sp );
V_strcat_safe( temp, post );
sp = sz;
sp = strstr( sp, "game\\" );
CmdLib_AddBasePath( temp );
if (!g_quiet)
printf("content:%s\n", temp );
}
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
int CStudioMDLApp::Main()
{
const bool bP4DLLExists = g_pFullFileSystem->FileExists( "p4lib.dll", "EXECUTABLE_PATH" );
// No p4 mode if specified on the command line or no p4lib.dll found
if ( ( CommandLine()->FindParm( "-nop4" ) ) || ( !bP4DLLExists ) )
{
g_bNoP4 = true;
g_p4factory->SetDummyMode( true );
}
// Set the named changelist
g_p4factory->SetOpenFileChangeList( "StudioMDL Auto Checkout" );
// This bit of hackery allows us to access files on the harddrive
g_pFullFileSystem->AddSearchPath( "", "LOCAL", PATH_ADD_TO_HEAD );
MaterialSystem_Config_t config;
g_pMaterialSystem->OverrideConfig( config, false );
int nReturnValue;
if ( HandleMdlReport( nReturnValue ) )
return false;
// Don't bother with undo here
g_pDataModel->SetUndoEnabled( false );
// look for the "content\hl2x" string in the qdir and add what should be the correct path as an alternate
// FIXME: add these to an envvar if folks are using complicated directory mappings instead of defaults
char *match = "content\\hl2x\\";
char *sp = strstr( qdir, match );
if (sp)
{
char temp[1024];
strncpy( temp, qdir, sp - qdir + strlen( match ) );
temp[sp - qdir + strlen( match )] = '\0';
CmdLib_AddBasePath( temp );
V_strcat_safe( temp, "..\\..\\..\\..\\main\\content\\hl2\\" );
CmdLib_AddBasePath( temp );
}
AddContentPaths();
if (!g_quiet)
{
printf("qdir: \"%s\"\n", qdir );
printf("gamedir: \"%s\"\n", gamedir );
printf("g_path: \"%s\"\n", g_path );
}
switch ( g_eRunMode )
{
case RUN_MODE_STRIP_MODEL:
return Main_StripModel();
case RUN_MODE_STRIP_VHV:
return Main_StripVhv();
case RUN_MODE_BUILD:
default:
break;
}
const char *pExt = Q_GetFileExtension( g_path );
// Look for the presence of a .mdl file (only -vsi is currently supported for .mdl files)
if ( pExt && !Q_stricmp( pExt, "mdl" ) )
{
if ( g_bMakeVsi )
return Main_MakeVsi();
printf( "ERROR: .qc or .dmx file should be specified to build.\n" );
return 1;
}
if ( !g_quiet )
printf( "Building binary model files...\n" );
// Look for the presence of a .dmx file of the same name
// If so, load it first
CDmeMDLMakefile *pMDLMakeFile = NULL;
if ( pExt && !Q_stricmp( pExt, "dmx" ) )
{
CDmElement *pRoot;
if ( g_pDataModel->RestoreFromFile( g_path, NULL, NULL, &pRoot ) != DMFILEID_INVALID )
{
pMDLMakeFile = CastElement<CDmeMDLMakefile>( pRoot );
}
};
Q_FileBase( g_path, g_path, sizeof( g_path ) );
Q_DefaultExtension( g_path, pMDLMakeFile ? ".dmx" : ".qc", sizeof( g_path ) );
if (!g_quiet)
{
printf( "Working on \"%s\"\n", g_path );
}
// Turn on checking for special single character tokens while parsing
SetCheckSingleCharTokens( true );
SetSingleCharTokenList( "{}()," );
// Set up script loading callback, discarding default callback
( void ) SetScriptLoadedCallback( StudioMdl_ScriptLoadedCallback );
// load the script
if ( !pMDLMakeFile )
{
LoadScriptFile(g_path);
}
V_strcpy_safe( fullpath, g_path );
V_strcpy_safe( fullpath, ExpandPath( fullpath ) );
V_strcpy_safe( fullpath, ExpandArg( fullpath ) );
// default to having one entry in the LOD list that doesn't do anything so
// that we don't have to do any special cases for the first LOD.
g_ScriptLODs.Purge();
g_ScriptLODs.AddToTail(); // add an empty one
g_ScriptLODs[0].switchValue = 0.0f;
//
// parse it
//
ClearModel();
// V_strcpy_safe( g_pPlatformName, "" );
if ( pMDLMakeFile )
{
ParseMDLMakeFile( pMDLMakeFile );
}
else
{
ParseScript();
}
if ( !g_bCreateMakefile )
{
SetSkinValues();
SimplifyModel();
ConsistencyCheckSurfaceProp();
ConsistencyCheckContents();
CollisionModel_Build();
// ValidateSharedAnimationGroups();
WriteModelFiles();
}
if ( pMDLMakeFile )
{
DestroyElement( pMDLMakeFile );
pMDLMakeFile = NULL;
}
if ( g_bCreateMakefile )
{
CreateMakefile_OutputMakefile();
}
else if ( g_bMakeVsi )
{
Q_snprintf( g_path, ARRAYSIZE( g_path ), "%smodels/%s", gamedir, outname );
Main_MakeVsi();
}
if (!g_quiet)
{
printf("\nCompleted \"%s\"\n", g_path);
}
g_pDataModel->UnloadFile( DMFILEID_INVALID );
return 0;
}
//
// WriteFileToDisk
// Equivalent to g_pFullFileSystem->WriteFile( pFileName, pPath, buf ), but works
// for relative paths.
//
bool WriteFileToDisk( const char *pFileName, const char *pPath, CUtlBuffer &buf )
{
// For some reason calling full filesystem will write into hl2 root dir
// return g_pFullFileSystem->WriteFile( pFileName, pPath, buf );
FILE *f = fopen( pFileName, "wb" );
if ( !f )
return false;
fwrite( buf.Base(), 1, buf.TellPut(), f );
fclose( f );
return true;
}
//
// WriteBufferToFile
// Helper to concatenate file base and extension.
//
bool WriteBufferToFile( CUtlBuffer &buf, const char *szFilebase, const char *szExt )
{
char szFilename[ 1024 ];
Q_snprintf( szFilename, ARRAYSIZE( szFilename ), "%s%s", szFilebase, szExt );
return WriteFileToDisk( szFilename, NULL, buf );
}
//
// LoadBufferFromFile
// Loads the buffer from file, return true on success, false otherwise.
// If bError is true prints an error upon failure.
//
bool LoadBufferFromFile( CUtlBuffer &buffer, char const *szFilebase, char const *szExt, bool bError = true )
{
char szFilename[1024];
Q_snprintf( szFilename, ARRAYSIZE( szFilename ), "%s%s", szFilebase, szExt );
if ( g_pFullFileSystem->ReadFile( szFilename, NULL, buffer ) )
return true;
if ( bError )
MdlError( "Failed to open '%s'!\n", szFilename );
return false;
}
bool Load3ModelBuffers( CUtlBuffer &bufMDL, CUtlBuffer &bufVVD, CUtlBuffer &bufVTX, char const *szFilebase )
{
// Load up the mdl file
if ( !LoadBufferFromFile( bufMDL, szFilebase, ".mdl" ) )
return false;
// Load up the vvd file
if ( !LoadBufferFromFile( bufVVD, szFilebase, ".vvd" ) )
return false;
// Load up the dx90.vtx file
if ( !LoadBufferFromFile( bufVTX, szFilebase, ".dx90.vtx" ) )
return false;
return true;
}
//////////////////////////////////////////////////////////////////////////
//
// Studiomdl hooks to call the stripping routines:
// Main_StripVhv
// Main_StripModel
//
//////////////////////////////////////////////////////////////////////////
int CStudioMDLApp::Main_StripVhv()
{
if ( !g_quiet )
{
printf( "Stripping vhv data...\n" );
}
if ( !mdllib )
{
printf( "ERROR: mdllib is not available!\n" );
return 1;
}
Q_StripExtension( g_path, g_path, sizeof( g_path ) );
char *pExt = g_path + strlen( g_path );
*pExt = 0;
//
// ====== Load files
//
// Load up the vhv file
CUtlBuffer bufVHV;
if ( !LoadBufferFromFile( bufVHV, g_path, ".vhv" ) )
return 1;
// Load up the info.strip file
CUtlBuffer bufRemapping;
if ( !LoadBufferFromFile( bufRemapping, g_path, ".info.strip", false ) &&
!LoadBufferFromFile( bufRemapping, g_path, ".vsi" ) )
return 1;
//
// ====== Process file contents
//
bool bResult = false;
{
SpewActivate( "mdllib", 3 );
IMdlStripInfo *pMdlStripInfo = NULL;
if ( mdllib->CreateNewStripInfo( &pMdlStripInfo ) )
{
pMdlStripInfo->UnSerialize( bufRemapping );
bResult = pMdlStripInfo->StripHardwareVertsBuffer( bufVHV );
}
if ( pMdlStripInfo )
pMdlStripInfo->DeleteThis();
}
if ( !bResult )
{
printf( "ERROR: stripping failed!\n" );
return 1;
}
//
// ====== Save out processed data
//
// Save vhv
if ( !WriteBufferToFile( bufVHV, g_path, ".vhv.strip" ) )
{
printf( "ERROR: Failed to save '%s'!\n", g_path );
return 1;
}
return 0;
}
int CStudioMDLApp::Main_MakeVsi()
{
if ( !mdllib )
{
printf( "ERROR: mdllib is not available!\n" );
return 1;
}
Q_StripExtension( g_path, g_path, sizeof( g_path ) );
char *pExt = g_path + strlen( g_path );
*pExt = 0;
// Load up the files
CUtlBuffer bufMDL;
CUtlBuffer bufVVD;
CUtlBuffer bufVTX;
if ( !Load3ModelBuffers( bufMDL, bufVVD, bufVTX, g_path ) )
return 1;
//
// ====== Process file contents
//
CUtlBuffer bufMappingTable;
bool bResult = false;
{
if ( !g_quiet )
{
printf( "---------------------\n" );
printf( "Generating .vsi stripping information...\n" );
SpewActivate( "mdllib", 3 );
}
IMdlStripInfo *pMdlStripInfo = NULL;
bResult =
mdllib->StripModelBuffers( bufMDL, bufVVD, bufVTX, &pMdlStripInfo ) &&
pMdlStripInfo->Serialize( bufMappingTable );
if ( pMdlStripInfo )
pMdlStripInfo->DeleteThis();
}
if ( !bResult )
{
printf( "ERROR: stripping failed!\n" );
return 1;
}
//
// ====== Save out processed data
//
// Save remapping data using "P4 edit -> save -> P4 add" approach
sprintf( pExt, ".vsi" );
CP4AutoEditAddFile _auto_edit_vsi( g_path );
if ( !WriteFileToDisk( g_path, NULL, bufMappingTable ) )
{
printf( "ERROR: Failed to save '%s'!\n", g_path );
return 1;
}
else if ( !g_quiet )
{
printf( "Generated .vsi stripping information.\n" );
}
return 0;
}
int CStudioMDLApp::Main_StripModel()
{
if ( !g_quiet )
{
printf( "Stripping binary model files...\n" );
}
if ( !mdllib )
{
printf( "ERROR: mdllib is not available!\n" );
return 1;
}
Q_FileBase( g_path, g_path, sizeof( g_path ) );
char *pExt = g_path + strlen( g_path );
*pExt = 0;
// Load up the files
CUtlBuffer bufMDL;
CUtlBuffer bufVVD;
CUtlBuffer bufVTX;
if ( !Load3ModelBuffers( bufMDL, bufVVD, bufVTX, g_path ) )
return 1;
//
// ====== Process file contents
//
CUtlBuffer bufMappingTable;
bool bResult = false;
{
SpewActivate( "mdllib", 3 );
IMdlStripInfo *pMdlStripInfo = NULL;
bResult =
mdllib->StripModelBuffers( bufMDL, bufVVD, bufVTX, &pMdlStripInfo ) &&
pMdlStripInfo->Serialize( bufMappingTable );
if ( pMdlStripInfo )
pMdlStripInfo->DeleteThis();
}
if ( !bResult )
{
printf( "ERROR: stripping failed!\n" );
return 1;
}
//
// ====== Save out processed data
//
// Save mdl
sprintf( pExt, ".mdl.strip" );
if ( !WriteFileToDisk( g_path, NULL, bufMDL ) )
{
printf( "ERROR: Failed to save '%s'!\n", g_path );
return 1;
}
// Save vvd
sprintf( pExt, ".vvd.strip" );
if ( !WriteFileToDisk( g_path, NULL, bufVVD ) )
{
printf( "ERROR: Failed to save '%s'!\n", g_path );
return 1;
}
// Save vtx
sprintf( pExt, ".vtx.strip" );
if ( !WriteFileToDisk( g_path, NULL, bufVTX ) )
{
printf( "ERROR: Failed to save '%s'!\n", g_path );
return 1;
}
// Save remapping data
sprintf( pExt, ".info.strip" );
if ( !WriteFileToDisk( g_path, NULL, bufMappingTable ) )
{
printf( "ERROR: Failed to save '%s'!\n", g_path );
return 1;
}
return 0;
}