You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
971 lines
22 KiB
971 lines
22 KiB
//============================================================================= |
|
// |
|
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// The contents may be used and/or copied only with the written permission of |
|
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in |
|
// the agreement/contract under which the contents have been supplied. |
|
// |
|
// $Header: $ |
|
// $NoKeywords: $ |
|
// |
|
// Converts from any one DMX file format to another |
|
// Can also output SMD or a QCI header from DMX input |
|
// |
|
//============================================================================= |
|
|
|
#ifndef DMXEDIT_H |
|
#define DMXEDIT_H |
|
|
|
|
|
// Valve includes |
|
#include "movieobjects/dmemesh.h" |
|
#include "tier1/utlstring.h" |
|
#include "tier1/utlvector.h" |
|
#include "tier1/UtlStringMap.h" |
|
|
|
// Lua includes |
|
#include <lua.h> |
|
|
|
|
|
class CDmxEditProxy; |
|
|
|
//============================================================================= |
|
// CDmxEdit declaration |
|
//============================================================================= |
|
class CDmxEdit |
|
{ |
|
public: |
|
void SetScriptFilename( const char *pFilename ); |
|
|
|
class delta : public CUtlString |
|
{ |
|
public: |
|
delta() {}; |
|
delta( const char *pString ) : CUtlString( pString ) {} |
|
delta( const CUtlString &string ) : CUtlString( string ) {} |
|
}; |
|
|
|
class CFalloffType |
|
{ |
|
public: |
|
CFalloffType( CDmeMesh::Falloff_t falloffType ) |
|
: m_falloffType( falloffType ) |
|
{ |
|
} |
|
|
|
CDmeMesh::Falloff_t StringToFalloff( const char *pFalloffTypeString ) |
|
{ |
|
if ( !Q_strnicmp( pFalloffTypeString, "L", 1 ) ) |
|
return CDmeMesh::LINEAR; |
|
|
|
if ( !Q_strnicmp( pFalloffTypeString, "ST", 2 ) ) |
|
return CDmeMesh::STRAIGHT; |
|
|
|
if ( !Q_strnicmp( pFalloffTypeString, "B", 1 ) ) |
|
return CDmeMesh::BELL; |
|
|
|
if ( !Q_strnicmp( pFalloffTypeString, "SM", 2 ) ) |
|
return CDmeMesh::SMOOTH; |
|
|
|
if ( !Q_strnicmp( pFalloffTypeString, "SP", 2 ) ) |
|
return CDmeMesh::SPIKE; |
|
|
|
if ( !Q_strnicmp( pFalloffTypeString, "D", 1 ) ) |
|
return CDmeMesh::DOME; |
|
|
|
Msg( "// ERROR: Can't Figure Out Which Falloff Type Is Meant By \"%s\", Assuming STRAIGHT\n", pFalloffTypeString ); |
|
|
|
return CDmeMesh::STRAIGHT; |
|
} |
|
|
|
CFalloffType( const char *pFalloffTypeString ) |
|
: m_falloffType( StringToFalloff( pFalloffTypeString ) ) |
|
{ |
|
} |
|
|
|
CDmeMesh::Falloff_t operator()() const { return m_falloffType; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_falloffType ) |
|
{ |
|
case CDmeMesh::LINEAR: |
|
return "STRAIGHT"; |
|
case CDmeMesh::BELL: |
|
return "BELL"; |
|
case CDmeMesh::SPIKE: |
|
return "SPIKE"; |
|
case CDmeMesh::DOME: |
|
return "DOME"; |
|
default: |
|
break; |
|
} |
|
|
|
return "STRAIGHT"; |
|
} |
|
|
|
protected: |
|
const CDmeMesh::Falloff_t m_falloffType; |
|
}; |
|
|
|
static const CFalloffType STRAIGHT; |
|
static const CFalloffType LINEAR; |
|
static const CFalloffType BELL; |
|
static const CFalloffType SMOOTH; |
|
static const CFalloffType SPIKE; |
|
static const CFalloffType DOME; |
|
|
|
class CSelectOp |
|
{ |
|
public: |
|
enum SelectOp_t |
|
{ |
|
kAdd, |
|
kSubtract, |
|
kToggle, |
|
kIntersect, |
|
kReplace |
|
}; |
|
|
|
CSelectOp( SelectOp_t selectOp ) |
|
: m_selectOp( selectOp ) |
|
{ |
|
} |
|
|
|
SelectOp_t StringToSelectOp( const char *pSelectOpString ) |
|
{ |
|
if ( !Q_strnicmp( pSelectOpString, "A", 1 ) ) |
|
return kAdd; |
|
|
|
if ( !Q_strnicmp( pSelectOpString, "S", 1 ) ) |
|
return kSubtract; |
|
|
|
if ( !Q_strnicmp( pSelectOpString, "T", 1 ) ) |
|
return kToggle; |
|
|
|
if ( !Q_strnicmp( pSelectOpString, "I", 1 ) ) |
|
return kIntersect; |
|
|
|
if ( !Q_strnicmp( pSelectOpString, "R", 1 ) ) |
|
return kReplace; |
|
|
|
Msg( "// ERROR: Can't Figure Out Which Select Operation Type Is Meant By \"%s\", Assuming REPLACE\n", pSelectOpString ); |
|
|
|
return kReplace; |
|
} |
|
|
|
CSelectOp( const char *pSelectOp ) |
|
: m_selectOp( StringToSelectOp( pSelectOp ) ) |
|
{ |
|
} |
|
|
|
SelectOp_t operator()() const { return m_selectOp; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_selectOp ) |
|
{ |
|
case kAdd: |
|
return "ADD"; |
|
case kSubtract: |
|
return "SUBTRACT"; |
|
case kToggle: |
|
return "TOGGLE"; |
|
case kIntersect: |
|
return "INTERSECT"; |
|
default: |
|
break; |
|
} |
|
|
|
return "REPLACE"; |
|
} |
|
|
|
protected: |
|
const SelectOp_t m_selectOp; |
|
}; |
|
|
|
static const CSelectOp ADD; |
|
static const CSelectOp SUBTRACT; |
|
static const CSelectOp TOGGLE; |
|
static const CSelectOp INTERSECT; |
|
static const CSelectOp REPLACE; |
|
|
|
class CSelectType |
|
{ |
|
public: |
|
enum Select_t |
|
{ |
|
kNone, |
|
kAll, |
|
kDelta |
|
}; |
|
|
|
CSelectType( Select_t selectType ) |
|
: m_selectType( selectType ) |
|
{ |
|
} |
|
|
|
Select_t SelectTypeStringToType( const char *pSelectString ) |
|
{ |
|
if ( !Q_stricmp( pSelectString, "NONE" ) ) |
|
return kNone; |
|
|
|
if ( !Q_stricmp( pSelectString, "ALL" ) ) |
|
return kAll; |
|
|
|
return kDelta; |
|
} |
|
|
|
CSelectType( const char *pSelectTypeString ) |
|
: m_selectType( SelectTypeStringToType( pSelectTypeString ) ) |
|
{ |
|
} |
|
|
|
Select_t operator()() const { return m_selectType; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_selectType ) |
|
{ |
|
case kNone: |
|
return "NONE"; |
|
case kAll: |
|
return "ALL"; |
|
default: |
|
break; |
|
} |
|
|
|
return "DELTA"; |
|
} |
|
|
|
protected: |
|
const Select_t m_selectType; |
|
}; |
|
|
|
static const CSelectType ALL; |
|
static const CSelectType NONE; |
|
|
|
//============================================================================= |
|
// |
|
//============================================================================= |
|
class CObjType |
|
{ |
|
public: |
|
enum Obj_t |
|
{ |
|
kAbsolute, |
|
kRelative |
|
}; |
|
|
|
CObjType( Obj_t objType ) |
|
: m_objType( objType ) |
|
{ |
|
} |
|
|
|
CObjType &operator=( const CObjType &rhs ) |
|
{ |
|
m_objType = rhs.m_objType; |
|
return *this; |
|
} |
|
|
|
Obj_t ObjTypeStringToType( const char *pObjString ) |
|
{ |
|
if ( pObjString && ( *pObjString == 'r' || *pObjString == 'R' ) ) |
|
return kRelative; |
|
|
|
return kAbsolute; |
|
} |
|
|
|
CObjType( const char *pObjTypeString ) |
|
: m_objType( ObjTypeStringToType( pObjTypeString ) ) |
|
{ |
|
} |
|
|
|
Obj_t operator()() const { return m_objType; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_objType ) |
|
{ |
|
case kRelative: |
|
return "RELATIVE"; |
|
default: |
|
break; |
|
} |
|
|
|
return "ABSOLUTE"; |
|
} |
|
|
|
|
|
|
|
protected: |
|
Obj_t m_objType; |
|
}; |
|
|
|
static const CObjType ABSOLUTE; |
|
static const CObjType RELATIVE; |
|
|
|
|
|
//============================================================================= |
|
// |
|
//============================================================================= |
|
class CDistanceType |
|
{ |
|
public: |
|
CDistanceType( CDmeMesh::Distance_t distanceType ) |
|
: m_distanceType( distanceType ) |
|
{ |
|
} |
|
|
|
CDmeMesh::Distance_t DistanceTypeStringToType( const char *pDistanceTypeString ) |
|
{ |
|
if ( pDistanceTypeString && ( *pDistanceTypeString == 'a' || *pDistanceTypeString == 'A' ) ) |
|
return CDmeMesh::DIST_ABSOLUTE; |
|
|
|
if ( pDistanceTypeString && ( *pDistanceTypeString == 'r' || *pDistanceTypeString == 'R' ) ) |
|
return CDmeMesh::DIST_RELATIVE; |
|
|
|
return CDmeMesh::DIST_DEFAULT; |
|
} |
|
|
|
CDistanceType( const char *pDistanceTypeString ) |
|
: m_distanceType( DistanceTypeStringToType( pDistanceTypeString ) ) |
|
{ |
|
} |
|
|
|
CDmeMesh::Distance_t operator()() const { return m_distanceType; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_distanceType ) |
|
{ |
|
case CDmeMesh::DIST_ABSOLUTE: |
|
return "ABSOLUTE"; |
|
case CDmeMesh::DIST_RELATIVE: |
|
return "RELATIVE"; |
|
default: |
|
break; |
|
} |
|
|
|
return "DEFAULT"; |
|
} |
|
|
|
protected: |
|
CDmeMesh::Distance_t m_distanceType; |
|
}; |
|
|
|
static const CDistanceType DIST_ABSOLUTE; |
|
static const CDistanceType DIST_RELATIVE; |
|
static const CDistanceType DIST_DEFAULT; |
|
|
|
class CAxisType |
|
{ |
|
public: |
|
enum Axis_t |
|
{ |
|
kXAxis, |
|
kYAxis, |
|
kZAxis |
|
}; |
|
|
|
CAxisType( Axis_t axisType ) |
|
: m_axisType( axisType ) |
|
{ |
|
} |
|
|
|
Axis_t AxisTypeStringToType( const char *pAxisString ) |
|
{ |
|
if ( pAxisString && ( *pAxisString == 'y' || *pAxisString == 'Y' ) ) |
|
return kYAxis; |
|
|
|
if ( pAxisString && ( *pAxisString == 'z' || *pAxisString == 'Z' ) ) |
|
return kZAxis; |
|
|
|
return kXAxis; |
|
} |
|
|
|
CAxisType( const char *pAxisTypeString ) |
|
: m_axisType( AxisTypeStringToType( pAxisTypeString ) ) |
|
{ |
|
} |
|
|
|
Axis_t operator()() const { return m_axisType; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_axisType ) |
|
{ |
|
case kYAxis: |
|
return "YAXIS"; |
|
case kZAxis: |
|
return "ZAXIS"; |
|
default: |
|
break; |
|
} |
|
|
|
return "XAXIS"; |
|
} |
|
|
|
protected: |
|
const Axis_t m_axisType; |
|
}; |
|
|
|
static const CAxisType XAXIS; |
|
static const CAxisType YAXIS; |
|
static const CAxisType ZAXIS; |
|
|
|
class CHalfType |
|
{ |
|
public: |
|
enum Half_t |
|
{ |
|
kLeft, |
|
kRight |
|
}; |
|
|
|
CHalfType( Half_t halfType ) |
|
: m_halfType( halfType ) |
|
{ |
|
} |
|
|
|
Half_t HalfTypeStringToType( const char *pHalfString ) |
|
{ |
|
if ( pHalfString && ( *pHalfString == 'l' || *pHalfString == 'L' ) ) |
|
return kLeft; |
|
|
|
if ( pHalfString && ( *pHalfString == 'r' || *pHalfString == 'R' ) ) |
|
return kRight; |
|
|
|
return kLeft; |
|
} |
|
|
|
CHalfType( const char *pHalfTypeString ) |
|
: m_halfType( HalfTypeStringToType( pHalfTypeString ) ) |
|
{ |
|
} |
|
|
|
Half_t operator()() const { return m_halfType; } |
|
|
|
operator char *() const |
|
{ |
|
switch ( m_halfType ) |
|
{ |
|
case kLeft: |
|
return "LEFT"; |
|
case kRight: |
|
return "RIGHT"; |
|
default: |
|
break; |
|
} |
|
|
|
return "LEFT"; |
|
} |
|
|
|
protected: |
|
const Half_t m_halfType; |
|
}; |
|
|
|
static const CHalfType LEFT; |
|
static const CHalfType RIGHT; |
|
|
|
CDmxEdit(); |
|
|
|
virtual ~CDmxEdit() {}; |
|
|
|
bool Load( const char *pFilename, const CObjType &loadType = ABSOLUTE ); |
|
|
|
bool Import( const char *pFilename, const char *pParentName = NULL ); |
|
|
|
operator bool() const { return m_pMesh != NULL; } |
|
|
|
void DoIt(); |
|
|
|
bool ListDeltas(); |
|
|
|
int DeltaCount(); |
|
|
|
const char *DeltaName( int nDeltaIndex ); |
|
|
|
void Unload(); |
|
|
|
bool ImportComboRules( const char *pFilename, bool bOverwrite = true, bool bPurgeDeltas = true ); |
|
|
|
bool ResetState(); |
|
|
|
bool SetState( const char *pDeltaName ); |
|
|
|
bool Select( const char *selectString, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool Select( const CSelectType &selectType, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool Select( const CSelectOp &selectOp, const char *pSelectTypeString, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool Select( const CSelectOp &selectOp, const CSelectType &selectType, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool SelectHalf( const CSelectOp &selectOp, const CHalfType &halfType, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool SelectHalf( const CHalfType &halfType, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool GrowSelection( int nSize = 1 ); |
|
|
|
bool ShrinkSelection( int nSize = 1 ); |
|
|
|
enum AddType { kRaw, kCorrected }; |
|
|
|
bool Add( |
|
AddType addType, |
|
const CDmxEditProxy &e, |
|
float weight = 1.0f, |
|
float featherDistance = 0.0f, |
|
const CFalloffType &falloffType = STRAIGHT, |
|
const CDistanceType &distanceType = DIST_DEFAULT ); |
|
|
|
bool Add( |
|
const CDmxEditProxy &e, |
|
float weight = 1.0f, |
|
float featherDistance = 0.0f, |
|
const CFalloffType &falloffType = STRAIGHT, |
|
const CDistanceType &distanceType = DIST_DEFAULT ) |
|
{ |
|
return Add( kRaw, e, weight, featherDistance, falloffType, distanceType ); |
|
} |
|
|
|
bool Add( |
|
AddType addType, |
|
const char *pDeltaName, |
|
float weight = 1.0f, |
|
float featherDistance = 0.0f, |
|
const CFalloffType &falloffType = STRAIGHT, |
|
const CDistanceType &distanceType = DIST_DEFAULT ); |
|
|
|
bool Add( |
|
const char *pDeltaName, |
|
float weight = 1.0f, |
|
float featherDistance = 0.0f, |
|
const CFalloffType &falloffType = STRAIGHT, |
|
const CDistanceType &distanceType = DIST_DEFAULT ) |
|
{ |
|
return Add( kRaw, pDeltaName, weight, featherDistance, falloffType, distanceType ); |
|
} |
|
|
|
bool Interp( const CDmxEditProxy &e, float weight = 1.0f, float featherDistance = 0.0f, const CFalloffType &falloffType = STRAIGHT, const CDistanceType &distanceType = DIST_DEFAULT ); |
|
|
|
bool Interp( const char *pDeltaName, float weight = 1.0f, float featherDistance = 0.0f, const CFalloffType &falloffType = STRAIGHT, const CDistanceType &distanceType = DIST_DEFAULT ); |
|
|
|
bool SaveDelta( const char *pDeltaName ); |
|
|
|
bool DeleteDelta( const delta &d ); |
|
|
|
bool Save( const char *pFilename, const CObjType &saveType = ABSOLUTE, const char *pDeltaName = NULL ); |
|
|
|
bool Save() { return Save( m_filename ); } |
|
|
|
void CleanupWork(); |
|
|
|
void CreateWork(); |
|
bool Merge( const char *pInFilename, const char *pOutFilename ); |
|
|
|
bool RemapMaterial( int nMaterialIndex, const char *pNewMaterialName ); |
|
|
|
bool RemapMaterial( const char *pOldMaterialName, const char *pNewMaterialName ); |
|
|
|
bool RemoveFacesWithMaterial( const char *pMaterialName ); |
|
|
|
bool RemoveFacesWithMoreThanNVerts( int nVertexCount ); |
|
|
|
bool Mirror( CAxisType = XAXIS ); |
|
|
|
bool ComputeNormals(); |
|
|
|
bool CreateDeltasFromPresets( const char *pPresetFilename, bool bDeleteNonPresetDeltas = true, const CUtlVector< CUtlString > *pPurgeAllButThese = NULL, const char *pExpressionFilename = NULL ); |
|
|
|
bool CachePreset( const char *pPresetFilename, const char *pExpressionFilename = NULL ); |
|
|
|
bool ClearPresetCache(); |
|
|
|
bool CreateDeltasFromCachedPresets( bool bDeleteNonPresetDeltas = true, const CUtlVector< CUtlString > *pPurgeAllButThese = NULL ) const; |
|
|
|
bool CreateExpressionFileFromPresets( const char *pPresetFilename, const char *pExpressionFilename ); |
|
|
|
bool CreateExpressionFilesFromCachedPresets() const; |
|
|
|
bool ComputeWrinkles( bool bOverwrite ); |
|
|
|
bool ComputeWrinkle( const char *pDeltaName, float scale, const char *pOperation ); |
|
|
|
bool Scale( float sx, float sy, float sz ); |
|
|
|
bool SetDistanceType( const CDistanceType &distanceType ); |
|
|
|
bool Translate( |
|
Vector t, |
|
float featherDistance = 0.0f, |
|
const CFalloffType &falloffType = STRAIGHT, |
|
const CDistanceType &distanceType = DIST_DEFAULT, |
|
CDmeMesh *pPassedMesh = NULL, |
|
CDmeVertexData *pPassedBase = NULL, |
|
CDmeSingleIndexedComponent *pPassedSelection = NULL ); |
|
|
|
bool Translate( Vector t, float featherDistance, const CFalloffType &falloffType = STRAIGHT ) |
|
{ |
|
return Translate( t, featherDistance, falloffType, m_distanceType ); |
|
} |
|
|
|
bool Rotate( |
|
Vector r, |
|
Vector o, |
|
float featherDistance = 0.0f, |
|
const CFalloffType &falloffType = STRAIGHT, |
|
const CDistanceType &passedDistanceType = DIST_DEFAULT, |
|
CDmeMesh *pPassedMesh = NULL, |
|
CDmeVertexData *pPassedBase = NULL, |
|
CDmeSingleIndexedComponent *pPassedSelection = NULL ); |
|
|
|
bool FixPresetFile( const char *pPresetFilename ); |
|
|
|
bool GroupControls( const char *pGroupName, CUtlVector< const char * > &rawControlNames ); |
|
|
|
bool ReorderControls( CUtlVector< CUtlString > &controlNames ); |
|
|
|
bool AddDominationRule( CUtlVector< CUtlString > &dominators, CUtlVector< CUtlString > &supressed ); |
|
|
|
bool SetStereoControl( const char *pControlName, bool bStereo ); |
|
|
|
bool SetEyelidControl( const char *pControlName, bool bEyelid ); |
|
|
|
float MaxDeltaDistance( const char *pDeltaName ); |
|
|
|
float DeltaRadius( const char *pDeltaName ); |
|
|
|
float SelectionRadius(); |
|
|
|
bool SetWrinkleScale( const char *pControlName, const char *pRawControlName, float flScale ); |
|
|
|
bool ErrorState() { |
|
return m_errorState; |
|
} |
|
|
|
void Error( PRINTF_FORMAT_STRING const tchar *pMsgFormat, ... ); |
|
|
|
const CUtlString &SetFuncString( lua_State *pLuaState ); |
|
|
|
const CUtlString &GetFuncString() const { return m_funcString; } |
|
|
|
int GetLineNumber() const { return m_lineNo; } |
|
|
|
const CUtlString &GetSourceFile() const { return m_sourceFile; } |
|
|
|
const CUtlString &GetErrorString() const { return m_errorString; } |
|
|
|
int LuaOk( lua_State *pLuaState ) |
|
{ |
|
Msg( "// %s\n", GetFuncString().Get() ); |
|
|
|
lua_pushboolean( pLuaState, true ); |
|
return 1; |
|
} |
|
|
|
int LuaError( lua_State *pLuaState ) |
|
{ |
|
if ( GetLineNumber() >= 0 ) |
|
{ |
|
Error( "// ERROR: %s:%d: %s - %s\n", |
|
GetSourceFile().Get(), |
|
GetLineNumber(), |
|
GetFuncString().Get(), |
|
GetErrorString().Get() ); |
|
} |
|
else |
|
{ |
|
Error( "// ERROR: %s - %s\n", |
|
GetFuncString().Get(), |
|
GetErrorString().Get() ); |
|
} |
|
|
|
lua_pushboolean( pLuaState, false ); |
|
return 1; |
|
} |
|
|
|
int LuaError( lua_State *pLuaState, PRINTF_FORMAT_STRING const char *pFormat, ... ) |
|
{ |
|
char tmpBuf[ 4096 ]; |
|
|
|
va_list marker; |
|
|
|
va_start( marker, pFormat ); |
|
#ifdef _WIN32 |
|
int len = _vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker ); |
|
#elif LINUX |
|
int len = vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker ); |
|
#else |
|
#error "define vsnprintf type." |
|
#endif |
|
va_end( marker ); |
|
|
|
// Len < 0 represents an overflow |
|
if( len < 0 ) |
|
{ |
|
len = sizeof( tmpBuf ) - 1; |
|
tmpBuf[sizeof( tmpBuf ) - 1] = 0; |
|
} |
|
|
|
if ( GetLineNumber() >= 0 ) |
|
{ |
|
Error( "// ERROR: %s:%d: %s - %s\n", |
|
GetSourceFile().Get(), |
|
GetLineNumber(), |
|
GetFuncString().Get(), |
|
tmpBuf ); |
|
} |
|
else |
|
{ |
|
Error( "// ERROR: %s - %s\n", |
|
GetFuncString().Get(), |
|
tmpBuf ); |
|
} |
|
|
|
lua_pushboolean( pLuaState, false ); |
|
return 1; |
|
} |
|
|
|
void LuaWarning( PRINTF_FORMAT_STRING const char *pFormat, ... ) |
|
{ |
|
char tmpBuf[ 4096 ]; |
|
|
|
va_list marker; |
|
|
|
va_start( marker, pFormat ); |
|
#ifdef _WIN32 |
|
int len = _vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker ); |
|
#elif LINUX |
|
int len = vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker ); |
|
#else |
|
#error "define vsnprintf type." |
|
#endif |
|
va_end( marker ); |
|
|
|
// Len < 0 represents an overflow |
|
if( len < 0 ) |
|
{ |
|
len = sizeof( tmpBuf ) - 1; |
|
tmpBuf[sizeof( tmpBuf ) - 1] = 0; |
|
} |
|
|
|
if ( GetLineNumber() >= 0 ) |
|
{ |
|
Warning( "// WARNING: %s:%d: %s - %s\n", |
|
GetSourceFile().Get(), |
|
GetLineNumber(), |
|
GetFuncString().Get(), |
|
tmpBuf ); |
|
} |
|
else |
|
{ |
|
Warning( "// WARNING: %s - %s\n", |
|
GetFuncString().Get(), |
|
tmpBuf ); |
|
} |
|
} |
|
|
|
bool SetErrorString( PRINTF_FORMAT_STRING const char *pFormat, ... ) |
|
{ |
|
char tmpBuf[ 4096 ]; |
|
|
|
va_list marker; |
|
|
|
va_start( marker, pFormat ); |
|
#ifdef _WIN32 |
|
int len = _vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker ); |
|
#elif LINUX |
|
int len = vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker ); |
|
#else |
|
#error "define vsnprintf type." |
|
#endif |
|
va_end( marker ); |
|
|
|
// Len < 0 represents an overflow |
|
if( len < 0 ) |
|
{ |
|
len = sizeof( tmpBuf ) - 1; |
|
tmpBuf[sizeof( tmpBuf ) - 1] = 0; |
|
} |
|
|
|
m_errorString = tmpBuf; |
|
|
|
return false; |
|
} |
|
|
|
protected: |
|
CUtlString m_filename; |
|
CDmElement *m_pRoot; |
|
CDmeMesh *m_pMesh; |
|
CDmeSingleIndexedComponent *m_pCurrentSelection; |
|
bool m_errorState; |
|
CDistanceType m_distanceType; |
|
|
|
CUtlStringMap< CUtlString > m_presetCache; |
|
|
|
CUtlString m_scriptFilename; |
|
|
|
bool Select( CDmeVertexDeltaData *pDelta, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
bool Select( const CSelectOp &selectOp, CDmeSingleIndexedComponent *pOriginal, const CDmeSingleIndexedComponent *pNew ); |
|
|
|
bool Select( const CSelectOp &selectOp, CDmeVertexDeltaData *pDelta, CDmeSingleIndexedComponent *pPassedSelection = NULL, CDmeMesh *pPassedMesh = NULL ); |
|
|
|
void ImportCombinationControls( CDmeCombinationOperator *pSrcComboOp, CDmeCombinationOperator *pDstComboOp, bool bOverwrite ); |
|
|
|
void ImportDominationRules( CDmeCombinationOperator *pDestComboOp, CDmeCombinationOperator *pSrcComboOp, bool bOverwrite ); |
|
|
|
CDmeMesh *GetMesh( CDmeMesh *pPassedMesh ) |
|
{ |
|
return pPassedMesh ? pPassedMesh : m_pMesh; |
|
} |
|
|
|
void SetErrorState() |
|
{ |
|
m_errorState = true; |
|
} |
|
|
|
void ResetErrorState() |
|
{ |
|
m_errorState = false; |
|
} |
|
|
|
CDmeSingleIndexedComponent *GetSelection( CDmeSingleIndexedComponent *pPassedSelection ) |
|
{ |
|
return pPassedSelection ? pPassedSelection : m_pCurrentSelection; |
|
} |
|
|
|
CDmeVertexDeltaData *FindDeltaState( const char *pDeltaName, const CDmeMesh *pPassedMesh = NULL ) const |
|
{ |
|
const CDmeMesh *pMesh = pPassedMesh ? pPassedMesh : m_pMesh; |
|
if ( !pMesh ) |
|
return NULL; |
|
|
|
return pMesh->FindDeltaState( pDeltaName ); |
|
} |
|
|
|
CDmeVertexData *GetBindState( const CDmeMesh *pPassedMesh = NULL ) const |
|
{ |
|
const CDmeMesh *pMesh = pPassedMesh ? pPassedMesh : m_pMesh; |
|
if ( !pMesh ) |
|
return NULL; |
|
|
|
return pMesh->FindBaseState( "bind" ); |
|
} |
|
|
|
void GetFuncArg( lua_State *pLuaState, int nIndex, CUtlString &funcString ); |
|
|
|
CUtlString m_funcString; |
|
|
|
int m_lineNo; |
|
|
|
CUtlString m_sourceFile; |
|
|
|
CUtlString m_errorString; |
|
|
|
void UpdateMakefile( CDmElement *pRoot ); |
|
void AddExportTags( CDmElement *pRoot, const char *pFilename ); |
|
void RemoveExportTags( CDmElement *pRoot, const char *pExportTagsName ); |
|
}; |
|
|
|
|
|
//============================================================================= |
|
// |
|
//============================================================================= |
|
typedef int ( * LuaFunc_t ) ( lua_State * ); |
|
|
|
|
|
//============================================================================= |
|
// |
|
//============================================================================= |
|
struct LuaFunc_s |
|
{ |
|
LuaFunc_s( const char *pName, LuaFunc_t pFunc, const char *pProto, const char *pDoc ) |
|
: m_pFuncName( pName ) |
|
, m_pFunc( pFunc ) |
|
, m_pFuncPrototype( pProto ) |
|
, m_pFuncDesc( pDoc ) |
|
{ |
|
m_pNextFunc = s_pFirstFunc; |
|
s_pFirstFunc = this; |
|
} |
|
|
|
const char *m_pFuncName; |
|
LuaFunc_t m_pFunc; |
|
const char *m_pFuncPrototype; |
|
const char *m_pFuncDesc; |
|
|
|
static LuaFunc_s *s_pFirstFunc; |
|
LuaFunc_s *m_pNextFunc; |
|
|
|
static CDmxEdit m_dmxEdit; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Macro to install a valve lua command |
|
// |
|
// Use like this: |
|
// |
|
// LUA_COMMAND( blah, "blah prototype", "blah documentation" ) |
|
// { |
|
// // ... blah implementation ... |
|
// // ... Function is passed single struct of lua_State *pLuaState ... |
|
// // ... Function returns an int ... |
|
// |
|
// // Example usage: |
|
// |
|
// const char *pArg = luaL_checkstring( pLuaState, 1 ); |
|
// return 0; |
|
// } |
|
//----------------------------------------------------------------------------- |
|
#define LUA_COMMAND( _name, _proto, _doc ) \ |
|
static int _name##_luaFunc( lua_State *pLuaState ); \ |
|
static LuaFunc_s _name##_LuaFunc_s( #_name, _name##_luaFunc, _proto, _doc ); \ |
|
static int _name##_luaFunc( lua_State *pLuaState ) |
|
|
|
|
|
//============================================================================= |
|
// |
|
//============================================================================= |
|
class CDmxEditLua |
|
{ |
|
public: |
|
CDmxEditLua(); |
|
|
|
bool DoIt( const char *pFilename ); |
|
|
|
void SetVar( const CUtlString &var, const CUtlString &val ); |
|
|
|
void SetGame( const CUtlString &game ); |
|
|
|
static int FileExists( lua_State *pLuaState ); |
|
|
|
protected: |
|
lua_State *m_pLuaState; |
|
}; |
|
|
|
|
|
|
|
//============================================================================= |
|
// |
|
//============================================================================= |
|
class CDmxEditProxy |
|
{ |
|
public: |
|
CDmxEditProxy( CDmxEdit &dmxEdit ) |
|
: m_dmxEdit( dmxEdit ) |
|
{} |
|
|
|
CDmxEditProxy &operator=( const char *pFilename ) { m_dmxEdit.Load( pFilename ); return *this; } |
|
|
|
operator bool() const { m_dmxEdit; } |
|
|
|
protected: |
|
CDmxEdit &m_dmxEdit; |
|
}; |
|
|
|
|
|
#endif // DMXEDIT_H
|