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

738 lines
21 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "importkeyvaluebase.h"
#include "dmserializers.h"
#include "datamodel/idatamodel.h"
#include "datamodel/dmelement.h"
#include "tier1/KeyValues.h"
#include "tier1/utlbuffer.h"
#include "datamodel/dmattribute.h"
#include "filesystem.h"
#include "tier2/tier2.h"
//-----------------------------------------------------------------------------
// Serialization class for Key Values
//-----------------------------------------------------------------------------
class CImportVMT : public CImportKeyValueBase
{
public:
virtual const char *GetName() const { return "vmt"; }
virtual const char *GetDescription() const { return "Valve Material File"; }
virtual int GetCurrentVersion() const { return 0; } // doesn't store a version
bool Serialize( CUtlBuffer &outBuf, CDmElement *pRoot );
CDmElement* UnserializeFromKeyValues( KeyValues *pKeyValues );
private:
// Unserialize fallbacks
bool UnserializeFallbacks( CDmElement *pRoot, KeyValues *pFallbackKeyValues );
// Unserialize proxies
bool UnserializeProxies( CDmElement *pRoot, KeyValues *pKeyValues );
// Creates a shader parameter from a key value
bool UnserializeShaderParam( CDmElement *pRoot, KeyValues* pKeyValue );
// Creates a matrix material var
bool CreateMatrixMaterialVarFromKeyValue( CDmElement *pRoot, const char *pParamName, const char *pString );
// Creates a vector shader parameter
bool CreateVectorMaterialVarFromKeyValue( CDmElement *pRoot, const char *pParamName, const char *pString );
// Writes out a single shader parameter
bool SerializeShaderParameter( CUtlBuffer &buf, CDmAttribute *pAttribute );
// Writes out all shader parameters
bool SerializeShaderParameters( CUtlBuffer &buf, CDmElement *pRoot );
// Writes out all shader fallbacks
bool SerializeFallbacks( CUtlBuffer &buf, CDmElement *pRoot );
// Writes out all material proxies
bool SerializeProxies( CUtlBuffer &buf, CDmElement *pRoot );
// Handle patch files
void ExpandPatchFile( KeyValues *pKeyValues );
};
//-----------------------------------------------------------------------------
// Singleton instance
//-----------------------------------------------------------------------------
static CImportVMT s_ImportVMT;
void InstallVMTImporter( IDataModel *pFactory )
{
pFactory->AddSerializer( &s_ImportVMT );
}
//-----------------------------------------------------------------------------
// Writes out a single shader parameter
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeShaderParameter( CUtlBuffer &buf, CDmAttribute *pAttribute )
{
// We have a shader parameter at this point.
switch ( pAttribute->GetType() )
{
case AT_INT:
buf.Printf( "\"%s\" \"%d\"\n", pAttribute->GetName(), pAttribute->GetValue<int>( ) );
break;
case AT_BOOL:
buf.Printf( "\"%s\" \"%d\"\n", pAttribute->GetName(), pAttribute->GetValue<bool>( ) );
break;
case AT_FLOAT:
buf.Printf( "\"%s\" \"%f\"\n", pAttribute->GetName(), pAttribute->GetValue<float>( ) );
break;
case AT_STRING:
buf.Printf( "\"%s\" \"%s\"\n", pAttribute->GetName(), pAttribute->GetValue<CUtlString>( ).Get() );
break;
case AT_VECTOR2:
{
const Vector2D &vec = pAttribute->GetValue<Vector2D>( );
buf.Printf( "\"%s\" \"[ %f %f ]\"\n", pAttribute->GetName(), vec.x, vec.y );
}
break;
case AT_VECTOR3:
{
const Vector &vec = pAttribute->GetValue<Vector>( );
buf.Printf( "\"%s\" \"[ %f %f %f ]\"\n", pAttribute->GetName(), vec.x, vec.y, vec.z );
}
break;
case AT_VECTOR4:
{
const Vector4D &vec = pAttribute->GetValue<Vector4D>( );
buf.Printf( "\"%s\" \"[ %f %f %f %f ]\"\n", pAttribute->GetName(), vec.x, vec.y, vec.z, vec.w );
}
break;
case AT_COLOR:
{
// NOTE: VMTs only support 3 component color (no alpha)
const Color &color = pAttribute->GetValue<Color>( );
buf.Printf( "\"%s\" \"{ %d %d %d }\"\n", pAttribute->GetName(), color.r(), color.g(), color.b() );
}
break;
case AT_VMATRIX:
{
const VMatrix &mat = pAttribute->GetValue<VMatrix>( );
buf.Printf( "\"%s\" \"[ %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f ]\"\n", pAttribute->GetName(),
mat[0][0], mat[0][1], mat[0][2], mat[0][3],
mat[1][0], mat[1][1], mat[1][2], mat[1][3],
mat[2][0], mat[2][1], mat[2][2], mat[2][3],
mat[3][0], mat[3][1], mat[3][2], mat[3][3] );
}
break;
default:
Warning( "Attempted to serialize an unsupported shader parameter type %s (%s)\n",
pAttribute->GetName(), g_pDataModel->GetAttributeNameForType( pAttribute->GetType() ) );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Writes out all shader parameters
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeShaderParameters( CUtlBuffer &buf, CDmElement *pRoot )
{
for ( CDmAttribute *pAttribute = pRoot->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() )
{
// Skip the standard attributes
if ( pAttribute->IsFlagSet( FATTRIB_STANDARD ) )
continue;
// Skip the shader name
const char *pName = pAttribute->GetName();
if ( !Q_stricmp( pAttribute->GetName(), "shader" ) )
continue;
// Names that don't start with a $ or a % are not shader parameters
if ( pName[0] != '$' && pName[0] != '%' )
continue;
// Skip element array children; we'll handle them separately.
if ( pAttribute->GetType() == AT_ELEMENT_ARRAY )
continue;
// Write out the shader parameter
if ( !SerializeShaderParameter( buf, pAttribute ) )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Writes out all shader fallbacks
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeFallbacks( CUtlBuffer &buf, CDmElement *pRoot )
{
if ( !pRoot->HasAttribute( "fallbacks" ) )
return true;
CDmAttribute *pFallbacks = pRoot->GetAttribute( "fallbacks" );
if ( pFallbacks->GetType() != AT_ELEMENT_ARRAY )
return false;
CDmrElementArray<> array( pFallbacks );
int nCount = array.Count();
for ( int i = 0; i < nCount; ++i )
{
CDmElement *pFallback = array[i];
Assert( pFallback );
PrintStringAttribute( pFallback, buf, "shader", false, true );
buf.Printf( "{\n" );
buf.PushTab();
if ( !SerializeShaderParameters( buf, pFallback ) )
return false;
buf.PopTab();
buf.Printf( "}\n" );
}
return true;
}
//-----------------------------------------------------------------------------
// Writes out all material proxies
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeProxies( CUtlBuffer &buf, CDmElement *pRoot )
{
if ( !pRoot->HasAttribute( "proxies" ) )
return true;
CDmAttribute *pProxies = pRoot->GetAttribute( "proxies" );
if ( pProxies->GetType() != AT_ELEMENT_ARRAY )
return false;
CDmrElementArray<> array( pProxies );
int nCount = array.Count();
if ( nCount == 0 )
return true;
buf.Printf( "\"Proxies\"\n" );
buf.Printf( "{\n" );
buf.PushTab();
for ( int i = 0; i < nCount; ++i )
{
CDmElement *pProxy = array[i];
Assert( pProxy );
PrintStringAttribute( pProxy, buf, "proxyType", false, true );
buf.Printf( "{\n" );
buf.PushTab();
if ( !SerializeShaderParameters( buf, pProxy ) )
return false;
buf.PopTab();
buf.Printf( "}\n" );
}
buf.PopTab();
buf.Printf( "}\n" );
return true;
}
//-----------------------------------------------------------------------------
// Writes out a new vmt file
//-----------------------------------------------------------------------------
bool CImportVMT::Serialize( CUtlBuffer &buf, CDmElement *pRoot )
{
PrintStringAttribute( pRoot, buf, "shader", false, true );
buf.Printf( "{\n" );
buf.PushTab();
if ( !SerializeShaderParameters( buf, pRoot ) )
return false;
if ( !SerializeFallbacks( buf, pRoot ) )
return false;
if ( !SerializeProxies( buf, pRoot ) )
return false;
buf.PopTab();
buf.Printf( "}\n" );
return true;
}
//-----------------------------------------------------------------------------
// Parser utilities
//-----------------------------------------------------------------------------
static inline bool IsWhitespace( char c )
{
return c == ' ' || c == '\t';
}
static inline bool IsEndline( char c )
{
return c == '\n' || c == '\0';
}
static inline bool IsVector( char const* v )
{
while (IsWhitespace(*v))
{
++v;
if (IsEndline(*v))
return false;
}
return *v == '[' || *v == '{';
}
//-----------------------------------------------------------------------------
// Creates a vector material var
//-----------------------------------------------------------------------------
int ParseVectorFromKeyValueString( const char *pParamName, const char* pScan, const char *pMaterialName, float vecVal[4] )
{
bool divideBy255 = false;
// skip whitespace
while( IsWhitespace(*pScan) )
{
++pScan;
}
if( *pScan == '{' )
{
divideBy255 = true;
}
else
{
Assert( *pScan == '[' );
}
// skip the '['
++pScan;
int i;
for( i = 0; i < 4; i++ )
{
// skip whitespace
while( IsWhitespace(*pScan) )
{
++pScan;
}
if( IsEndline(*pScan) || *pScan == ']' || *pScan == '}' )
{
if (*pScan != ']' && *pScan != '}')
{
Warning( "Warning in .VMT file (%s): no ']' or '}' found in vector key \"%s\".\n"
"Did you forget to surround the vector with \"s?\n", pMaterialName, pParamName );
}
// allow for vec2's, etc.
vecVal[i] = 0.0f;
break;
}
char* pEnd;
vecVal[i] = strtod( pScan, &pEnd );
if (pScan == pEnd)
{
Warning( "Error in .VMT file: error parsing vector element \"%s\" in \"%s\"\n", pParamName, pMaterialName );
return 0;
}
pScan = pEnd;
}
if( divideBy255 )
{
vecVal[0] *= ( 1.0f / 255.0f );
vecVal[1] *= ( 1.0f / 255.0f );
vecVal[2] *= ( 1.0f / 255.0f );
vecVal[3] *= ( 1.0f / 255.0f );
}
return i;
}
//-----------------------------------------------------------------------------
// Sets shader parameter attributes
//-----------------------------------------------------------------------------
template< class T >
inline bool SetShaderParamAttribute( CDmElement *pElement, const char *pAttributeName, const T &value )
{
if ( !pElement )
return false;
if ( !pElement->SetValue( pAttributeName, value ) )
return false;
CDmAttribute *pAttribute = pElement->GetAttribute( pAttributeName );
pAttribute->AddFlag( FATTRIB_USERDEFINED );
return true;
}
inline bool SetShaderParamAttribute( CDmElement *pElement, const char *pAttributeName, const char *value )
{
if ( !pElement )
return false;
if ( !pElement->SetValue( pAttributeName, value ) )
return false;
CDmAttribute *pAttribute = pElement->GetAttribute( pAttributeName );
pAttribute->AddFlag( FATTRIB_USERDEFINED );
return true;
}
//-----------------------------------------------------------------------------
// Creates a vector shader parameter
//-----------------------------------------------------------------------------
bool CImportVMT::CreateVectorMaterialVarFromKeyValue( CDmElement *pElement, const char *pParamName, const char *pString )
{
Vector4D vecVal;
int nDim = ParseVectorFromKeyValueString( pParamName, pString, FileName(), vecVal.Base() );
if ( nDim == 0 )
return false;
// Create the variable!
switch ( nDim )
{
case 1:
return SetShaderParamAttribute( pElement, pParamName, vecVal[0] );
case 2:
return SetShaderParamAttribute( pElement, pParamName, vecVal.AsVector2D() );
case 3:
return SetShaderParamAttribute( pElement, pParamName, vecVal.AsVector3D() );
case 4:
return SetShaderParamAttribute( pElement, pParamName, vecVal );
}
return false;
}
//-----------------------------------------------------------------------------
// Creates a matrix shader parameter
//-----------------------------------------------------------------------------
bool CImportVMT::CreateMatrixMaterialVarFromKeyValue( CDmElement *pElement, const char *pParamName, const char *pScan )
{
// Matrices can be specified one of two ways:
// [ # # # # # # # # # # # # # # # # ]
// or
// center # # scale # # rotate # translate # #
VMatrix mat;
int count = sscanf( pScan, " [ %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f ]",
&mat.m[0][0], &mat.m[0][1], &mat.m[0][2], &mat.m[0][3],
&mat.m[1][0], &mat.m[1][1], &mat.m[1][2], &mat.m[1][3],
&mat.m[2][0], &mat.m[2][1], &mat.m[2][2], &mat.m[2][3],
&mat.m[3][0], &mat.m[3][1], &mat.m[3][2], &mat.m[3][3] );
if (count == 16)
{
return SetShaderParamAttribute( pElement, pParamName, mat );
}
Vector2D scale, center;
float angle;
Vector2D translation;
count = sscanf( pScan, " center %f %f scale %f %f rotate %f translate %f %f",
&center.x, &center.y, &scale.x, &scale.y, &angle, &translation.x, &translation.y );
if (count != 7)
return false;
VMatrix temp;
MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
MatrixMultiply( temp, mat, mat );
MatrixBuildRotateZ( temp, angle );
MatrixMultiply( temp, mat, mat );
MatrixBuildTranslation( temp, center.x + translation.x, center.y + translation.y, 0.0f );
MatrixMultiply( temp, mat, mat );
// Create the variable!
return SetShaderParamAttribute( pElement, pParamName, mat );
}
//-----------------------------------------------------------------------------
// Creates a shader parameter from a key value
//-----------------------------------------------------------------------------
bool CImportVMT::UnserializeShaderParam( CDmElement *pRoot, KeyValues* pKeyValues )
{
char pParamName[512];
Q_strncpy( pParamName, pKeyValues->GetName(), sizeof(pParamName) );
Q_strlower( pParamName );
switch( pKeyValues->GetDataType() )
{
case KeyValues::TYPE_INT:
return SetShaderParamAttribute( pRoot, pParamName, pKeyValues->GetInt() );
case KeyValues::TYPE_FLOAT:
return SetShaderParamAttribute( pRoot, pParamName, pKeyValues->GetFloat() );
case KeyValues::TYPE_STRING:
{
char const* pString = pKeyValues->GetString();
// Only valid if it's a texture attribute
if ( !pString || !pString[0] )
return SetShaderParamAttribute( pRoot, pParamName, pString );
// Look for matrices
if ( CreateMatrixMaterialVarFromKeyValue( pRoot, pParamName, pString ) )
return true;
// Look for vectors
if ( !IsVector( pString ) )
return SetShaderParamAttribute( pRoot, pParamName, pString );
// Parse the string as a vector...
return CreateVectorMaterialVarFromKeyValue( pRoot, pParamName, pString );
}
}
return false;
}
//-----------------------------------------------------------------------------
// Unserialize proxies
//-----------------------------------------------------------------------------
bool CImportVMT::UnserializeProxies( CDmElement *pElement, KeyValues *pKeyValues )
{
// Create a child element array to contain all material proxies
CDmAttribute *pProxies = pElement->AddAttribute( "proxies", AT_ELEMENT_ARRAY );
if ( !pProxies )
return false;
CDmrElementArray<> array( pProxies );
// Proxies are a list of sub-keys, the name is the proxy name, subkeys are values
for ( KeyValues *pProxy = pKeyValues->GetFirstTrueSubKey(); pProxy != NULL; pProxy = pProxy->GetNextTrueSubKey() )
{
CDmElement *pProxyElement = CreateDmElement( "DmElement", pProxy->GetName(), NULL );
array.AddToTail( pProxyElement );
pProxyElement->SetValue( "proxyType", pKeyValues->GetName() );
pProxyElement->SetValue( "editorType", "vmtProxy" );
// Normal keys are proxy parameters
for ( KeyValues *pProxyParam = pProxy->GetFirstValue(); pProxyParam != NULL; pProxyParam = pProxyParam->GetNextValue() )
{
switch( pProxyParam->GetDataType() )
{
case KeyValues::TYPE_INT:
pProxyElement->SetValue( pProxyParam->GetName(), pProxyParam->GetInt() );
return true;
case KeyValues::TYPE_FLOAT:
pProxyElement->SetValue( pProxyParam->GetName(), pProxyParam->GetFloat() );
return true;
case KeyValues::TYPE_STRING:
pProxyElement->SetValue( pProxyParam->GetName(), pProxyParam->GetString() );
return true;
default:
Warning( "Unhandled proxy keyvalues type (proxy %s var %s)\n", pProxy->GetName(), pProxyParam->GetName() );
return false;
}
}
}
return true;
}
//-----------------------------------------------------------------------------
// Unserialize fallbacks
//-----------------------------------------------------------------------------
bool CImportVMT::UnserializeFallbacks( CDmElement *pElement, KeyValues *pFallbackKeyValues )
{
// Create a child element array to contain all material proxies
CDmAttribute *pFallbacks = pElement->AddAttribute( "fallbacks", AT_ELEMENT_ARRAY );
if ( !pFallbacks )
return false;
CDmrElementArray<> array( pFallbacks );
CDmElement *pFallback = CreateDmElement( "DmElement", pFallbackKeyValues->GetName(), NULL );
array.AddToTail( pFallback );
pFallback->SetValue( "editorType", "vmtFallback" );
// Normal keys are shader parameters
for ( KeyValues *pShaderParam = pFallbackKeyValues->GetFirstValue(); pShaderParam != NULL; pShaderParam = pShaderParam->GetNextValue() )
{
if ( !UnserializeShaderParam( pFallback, pShaderParam ) )
{
Warning( "Error importing vmt shader parameter %s\n", pShaderParam->GetName() );
return NULL;
}
}
return true;
}
//-----------------------------------------------------------------------------
// VMT parser
//-----------------------------------------------------------------------------
void InsertKeyValues( KeyValues& dst, KeyValues& src, bool bCheckForExistence )
{
KeyValues *pSrcVar = src.GetFirstSubKey();
while( pSrcVar )
{
if ( !bCheckForExistence || dst.FindKey( pSrcVar->GetName() ) )
{
switch( pSrcVar->GetDataType() )
{
case KeyValues::TYPE_STRING:
dst.SetString( pSrcVar->GetName(), pSrcVar->GetString() );
break;
case KeyValues::TYPE_INT:
dst.SetInt( pSrcVar->GetName(), pSrcVar->GetInt() );
break;
case KeyValues::TYPE_FLOAT:
dst.SetFloat( pSrcVar->GetName(), pSrcVar->GetFloat() );
break;
case KeyValues::TYPE_PTR:
dst.SetPtr( pSrcVar->GetName(), pSrcVar->GetPtr() );
break;
}
}
pSrcVar = pSrcVar->GetNextKey();
}
if( bCheckForExistence )
{
for( KeyValues *pScan = dst.GetFirstTrueSubKey(); pScan; pScan = pScan->GetNextTrueSubKey() )
{
KeyValues *pTmp = src.FindKey( pScan->GetName() );
if( !pTmp )
continue;
// make sure that this is a subkey.
if( pTmp->GetDataType() != KeyValues::TYPE_NONE )
continue;
InsertKeyValues( *pScan, *pTmp, bCheckForExistence );
}
}
}
//-----------------------------------------------------------------------------
// Handle patch files
//-----------------------------------------------------------------------------
void CImportVMT::ExpandPatchFile( KeyValues *pKeyValues )
{
int count = 0;
while( count < 10 && stricmp( pKeyValues->GetName(), "patch" ) == 0 )
{
// WriteKeyValuesToFile( "patch.txt", keyValues );
const char *pIncludeFileName = pKeyValues->GetString( "include" );
if( pIncludeFileName )
{
KeyValues * includeKeyValues = new KeyValues( "vmt" );
bool success = includeKeyValues->LoadFromFile( g_pFullFileSystem, pIncludeFileName, IsX360() ? "GAME" : NULL );
if( success )
{
KeyValues *pInsertSection = pKeyValues->FindKey( "insert" );
if( pInsertSection )
{
InsertKeyValues( *includeKeyValues, *pInsertSection, false );
}
KeyValues *pReplaceSection = pKeyValues->FindKey( "replace" );
if( pReplaceSection )
{
InsertKeyValues( *includeKeyValues, *pReplaceSection, true );
}
*pKeyValues = *includeKeyValues;
includeKeyValues->deleteThis();
// Could add other commands here, like "delete", "rename", etc.
}
else
{
includeKeyValues->deleteThis();
return;
}
}
else
{
return;
}
count++;
}
if( count >= 10 )
{
Warning( "Infinite recursion in patch file?\n" );
}
}
//-----------------------------------------------------------------------------
// Main entry point for the unserialization
//-----------------------------------------------------------------------------
CDmElement* CImportVMT::UnserializeFromKeyValues( KeyValues *pKeyValues )
{
ExpandPatchFile( pKeyValues );
// Create the main element
CDmElement *pRoot = CreateDmElement( "DmElement", "VMT", NULL );
if ( !pRoot )
return NULL;
// Each material needs to have an editortype associated with it so it displays nicely in editors
pRoot->SetValue( "editorType", "vmt" );
// Each material needs a proxy list and a fallback list
if ( !pRoot->AddAttribute( "proxies", AT_ELEMENT_ARRAY ) )
return NULL;
if ( !pRoot->AddAttribute( "fallbacks", AT_ELEMENT_ARRAY ) )
return NULL;
// The keyvalues name is the shader name
pRoot->SetValue( "shader", pKeyValues->GetName() );
// Normal keys are shader parameters
for ( KeyValues *pShaderParam = pKeyValues->GetFirstValue(); pShaderParam != NULL; pShaderParam = pShaderParam->GetNextValue() )
{
if ( !UnserializeShaderParam( pRoot, pShaderParam ) )
{
Warning( "Error importing vmt shader parameter %s\n", pShaderParam->GetName() );
return NULL;
}
}
// Subkeys are either proxies or fallbacks
for ( KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); pSubKey != NULL; pSubKey = pSubKey->GetNextTrueSubKey() )
{
if ( !Q_stricmp( pSubKey->GetName(), "Proxies" ) )
{
UnserializeProxies( pRoot, pSubKey );
}
else
{
UnserializeFallbacks( pRoot, pSubKey );
}
}
// Resolve all element references recursively
RecursivelyResolveElement( pRoot );
return pRoot;
}