diff options
Diffstat (limited to 'utils/studiomdl/studiomdl.cpp')
| -rw-r--r-- | utils/studiomdl/studiomdl.cpp | 10448 |
1 files changed, 10448 insertions, 0 deletions
diff --git a/utils/studiomdl/studiomdl.cpp b/utils/studiomdl/studiomdl.cpp new file mode 100644 index 0000000..4441617 --- /dev/null +++ b/utils/studiomdl/studiomdl.cpp @@ -0,0 +1,10448 @@ +//========= 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; +} |