1

dmserializers/importvmt.cpp

@@ -0,0 +1,738 @@
+//========= 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;
+}