971 lines
22 KiB
C++
971 lines
22 KiB
C++
//=============================================================================
|
|
//
|
|
//========= 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
|