Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

971 lines
22 KiB

5 years ago
//=============================================================================
//
//========= 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