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.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
source-engine/tools/vmt/vmtdoc.cpp

1078 lines
32 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "vmtdoc.h"
#include "tier1/KeyValues.h"
#include "tier1/utlbuffer.h"
#include "datamodel/dmelement.h"
#include "vmttool.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/ishader.h"
#include "toolutils/enginetools_int.h"
#include "filesystem.h"
//-----------------------------------------------------------------------------
// Standard properties
//-----------------------------------------------------------------------------
struct StandardParam_t
{
const char *m_pParamName;
ShaderParamType_t m_ParamType;
const char *m_pDefaultValue;
const char *m_pWidgetType;
const char *m_pTextType;
};
// NOTE: All entries in here must have all-lowercase param names!
static StandardParam_t g_pStandardParams[] =
{
{ "$surfaceprop", SHADER_PARAM_TYPE_STRING, "default", "surfacepropertypicker", "surfacePropertyName" },
{ "%detailtype", SHADER_PARAM_TYPE_STRING, "", "detailtypepicker", "detailTypeName" },
{ "%compilesky", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilehint", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileskip", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileorigin", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileclip", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%playerclip", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilenpcclip", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilenochop", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compiletrigger", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilenolight", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileplayercontrolclip", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileladder", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilewet", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilenodraw", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileinvisible", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilenonsolid", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compiledetail", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compilewater", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ "%compileslime", SHADER_PARAM_TYPE_BOOL, "0", NULL, NULL },
{ NULL, SHADER_PARAM_TYPE_BOOL, NULL, NULL, NULL }
};
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CVMTDoc::CVMTDoc( IVMTDocCallback *pCallback ) : m_pCallback( pCallback )
{
m_hRoot = NULL;
m_pFileName[0] = 0;
m_bDirty = false;
m_pCurrentIShader = NULL;
KeyValues *pKeyValues = new KeyValues( "Wireframe" );
m_pScratchMaterial.Init( "VMT Preview", pKeyValues );
g_pDataModel->InstallNotificationCallback( this );
}
CVMTDoc::~CVMTDoc()
{
if ( m_hRoot.Get() )
{
RemoveAllShaderParams( m_hRoot );
}
g_pDataModel->RemoveNotificationCallback( this );
}
//-----------------------------------------------------------------------------
// Inherited from INotifyUI
//-----------------------------------------------------------------------------
void CVMTDoc::NotifyDataChanged( const char *pReason, int nNotifySource, int nNotifyFlags )
{
OnDataChanged( pReason, nNotifySource, nNotifyFlags );
}
//-----------------------------------------------------------------------------
// Gets the file name
//-----------------------------------------------------------------------------
const char *CVMTDoc::GetFileName()
{
return m_pFileName;
}
void CVMTDoc::SetFileName( const char *pFileName )
{
Q_strncpy( m_pFileName, pFileName, sizeof( m_pFileName ) );
Q_FixSlashes( m_pFileName );
SetDirty( true );
}
//-----------------------------------------------------------------------------
// Dirty bits
//-----------------------------------------------------------------------------
void CVMTDoc::SetDirty( bool bDirty )
{
m_bDirty = bDirty;
}
bool CVMTDoc::IsDirty() const
{
return m_bDirty;
}
//-----------------------------------------------------------------------------
// Creates the root element
//-----------------------------------------------------------------------------
bool CVMTDoc::CreateRootElement()
{
Assert( !m_hRoot.Get() );
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( GetFileName() );
// Create the main element
m_hRoot = g_pDataModel->CreateElement( "DmElement", GetFileName(), fileid );
if ( m_hRoot == DMELEMENT_HANDLE_INVALID )
return false;
g_pDataModel->SetFileRoot( fileid, m_hRoot );
// Each VMT list needs to have an editortype associated with it so it displays nicely in editors
m_hRoot->SetValue( "editorType", "vmt" );
m_hRoot->AddAttribute( "proxies", AT_ELEMENT_ARRAY );
m_hRoot->AddAttribute( "fallbacks", AT_ELEMENT_ARRAY );
m_pCallback->RemoveAllToolParameters();
// Add standard parameters
for ( int i = 0; g_pStandardParams[i].m_pParamName; ++i )
{
AddNewShaderParam( m_hRoot, g_pStandardParams[i].m_pParamName, g_pStandardParams[i].m_ParamType,
g_pStandardParams[i].m_pDefaultValue );
if ( g_pStandardParams[i].m_pParamName[0] == '%' )
{
m_pCallback->AddToolParameter( g_pStandardParams[i].m_pParamName, g_pStandardParams[i].m_pWidgetType, g_pStandardParams[i].m_pTextType );
}
else if ( g_pStandardParams[i].m_pWidgetType || g_pStandardParams[i].m_pTextType )
{
m_pCallback->RemoveShaderParameter( g_pStandardParams[i].m_pParamName );
m_pCallback->AddShaderParameter( g_pStandardParams[i].m_pParamName, g_pStandardParams[i].m_pWidgetType, g_pStandardParams[i].m_pTextType );
}
}
return true;
}
//-----------------------------------------------------------------------------
// Creates a new VMT
//-----------------------------------------------------------------------------
void CVMTDoc::CreateNew()
{
Assert( !m_hRoot.Get() );
// This is not undoable
CAppDisableUndoScopeGuard guard( "CVMTDoc::CreateNew", NOTIFY_CHANGE_OTHER );
Q_strncpy( m_pFileName, "untitled", sizeof( m_pFileName ) );
// Create the main element
if ( !CreateRootElement() )
return;
m_pPreviewMaterial.Init( m_pScratchMaterial );
SetShader( "wireframe" );
SetDirty( false );
}
//-----------------------------------------------------------------------------
// Copies VMT parameters into the root
//-----------------------------------------------------------------------------
void CVMTDoc::CopyParamsFromVMT( CDmElement *pVMT )
{
// First, set the shader parameters
SetShader( pVMT->GetValueString( "shader" ) );
// Now, copy the shader parameters over
CDmAttribute* pSrc;
CDmAttribute* pDst;
for ( pSrc = pVMT->FirstAttribute(); pSrc; pSrc = pSrc->NextAttribute() )
{
// Only copy shader parameters
if ( !IsShaderParam( pSrc ) )
continue;
// Adds the attribute if it doesn't exist
const char *pSrcName = pSrc->GetName();
if ( !m_hRoot->HasAttribute( pSrcName ) )
{
m_hRoot->AddAttribute( pSrcName, pSrc->GetType() );
}
pDst = m_hRoot->GetAttribute( pSrcName );
pDst->AddFlag( FATTRIB_USERDEFINED );
DmAttributeType_t srcType = pSrc->GetType();
DmAttributeType_t dstType = pDst->GetType();
if ( dstType == srcType )
{
pDst->SetValue( pSrc );
continue;
}
// Certain type conversions are allowed
switch( dstType )
{
case AT_BOOL:
if ( srcType == AT_INT )
{
pDst->SetValue( pSrc );
}
break;
case AT_INT:
if ( srcType == AT_BOOL )
{
pDst->SetValue( pSrc );
}
break;
case AT_COLOR:
if ( srcType == AT_VECTOR3 )
{
Color c;
int r, g, b;
Vector v = pSrc->GetValue<Vector>( );
v *= 255.0f;
r = clamp( v[0], 0, 255 );
g = clamp( v[1], 0, 255 );
b = clamp( v[2], 0, 255 );
c.SetColor( r, g, b, 255 );
pDst->SetValue( c );
}
break;
}
}
// Any shader parameter that isn't in the VMT make undefined
for ( pDst = m_hRoot->FirstAttribute(); pDst; pDst = pDst->NextAttribute() )
{
if ( !IsShaderParam( pDst ) )
continue;
if ( !pVMT->HasAttribute( pDst->GetName() ) )
{
// Special hack for alpha + colors
if ( !Q_stricmp( pDst->GetName(), "$alpha" ) )
{
pDst->SetValue( 1.0f );
}
else if ( pDst->GetType() == AT_COLOR )
{
Color c( 255, 255, 255, 255 );
pDst->SetValue( c );
}
else
{
pDst->SetToDefaultValue();
}
}
}
}
//-----------------------------------------------------------------------------
// Hooks the preview to an existing material, if there is one
//-----------------------------------------------------------------------------
void CVMTDoc::SetupPreviewMaterial( )
{
// Extract a material name from the material
char pLocalName[MAX_PATH];
// relative paths can be passed in for in-game material picking
if ( !g_pFileSystem->FullPathToRelativePath( m_pFileName, pLocalName, sizeof(pLocalName) ) )
{
Q_strcpy( pLocalName, m_pFileName );
}
if ( Q_strnicmp( pLocalName, "materials", 9 ) )
goto noMaterialConnection;
// Skip the '/' also
char pMaterialName[MAX_PATH];
Q_StripExtension( pLocalName + 10, pMaterialName, sizeof(pMaterialName) );
IMaterial *pMaterial = g_pMaterialSystem->FindMaterial( pMaterialName, "Editable material", false );
if ( !pMaterial || pMaterial->IsErrorMaterial() )
goto noMaterialConnection;
m_pPreviewMaterial.Init( pMaterial );
return;
noMaterialConnection:
m_pPreviewMaterial.Init( m_pScratchMaterial );
}
//-----------------------------------------------------------------------------
// Saves/loads from file
//-----------------------------------------------------------------------------
bool CVMTDoc::LoadFromFile( const char *pFileName )
{
Assert( !m_hRoot.Get() );
SetDirty( false );
Q_strncpy( m_pFileName, pFileName, sizeof( m_pFileName ) );
if ( !m_pFileName[0] )
return false;
// This is not undoable
CAppDisableUndoScopeGuard guard( "CVMTDoc::LoadFromFile", NOTIFY_CHANGE_OTHER );
// Create the main element
if ( !CreateRootElement() )
return false;
// change the filename of all the elements under the root, so we can unload the imported elements later
DmFileId_t rootFileId = g_pDataModel->GetFileId( m_pFileName );
g_pDataModel->SetFileName( rootFileId, "<temp>" );
// This will allow us to edit in context!
SetupPreviewMaterial( );
CDmElement *pIVMT = NULL;
g_pDataModel->RestoreFromFile( m_pFileName, NULL, "vmt", &pIVMT );
CDmElement *pVMT = CastElement< CDmElement >( pIVMT );
if ( !pVMT )
return false;
// FIXME: This is necessary so that all shader parameters appear in
// the same order, with the same type, as what you'd get using File->New.
// If we added a dependency to the material system into dmserializers,
// we could avoid this work here (I think!).
CopyParamsFromVMT( pVMT );
// unload the imported elements and change the root's filename back
DmFileId_t vmtFileId = g_pDataModel->GetFileId( m_pFileName );
g_pDataModel->RemoveFileId( vmtFileId );
g_pDataModel->SetFileName( rootFileId, m_pFileName );
SetDirty( false );
return true;
}
//-----------------------------------------------------------------------------
// Prior to saving to disk, extract all shader parameters which == the default
//-----------------------------------------------------------------------------
CDmElement* CVMTDoc::ExtractDefaultParameters( )
{
CDmElement *pMaterial = m_hRoot->Copy( );
CDmAttribute* pAttribute = pMaterial->FirstAttribute();
CDmAttribute* pNextAttribute = NULL;
for ( ; pAttribute; pAttribute = pNextAttribute )
{
pNextAttribute = pAttribute->NextAttribute();
const char *pShaderParam = pAttribute->GetName();
// Check for standard params
int i;
for ( i = 0; g_pStandardParams[i].m_pParamName != NULL; ++i )
{
if ( !Q_stricmp( g_pStandardParams[i].m_pParamName, pShaderParam ) )
{
char temp[512];
CUtlBuffer buf( temp, sizeof(temp), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
pAttribute->Serialize( buf );
if ( !Q_stricmp( (char*)buf.Base(), g_pStandardParams[i].m_pDefaultValue ) )
{
// Buffers match! Therefore it's still using the default parameter
pMaterial->RemoveAttributeByPtr( pAttribute );
}
break;
}
}
// Standard attribute found, continue
if ( g_pStandardParams[i].m_pParamName )
continue;
// Only remove shader parameters
if ( !IsShaderParam( pAttribute ) )
continue;
// Remove flags whose value is 0
int nCount = g_pMaterialSystem->ShaderFlagCount();
for ( i = 0; i < nCount; ++i )
{
const char *pFlagName = g_pMaterialSystem->ShaderFlagName( i );
if ( !Q_stricmp( pShaderParam, pFlagName ) )
break;
}
// It's a flag! Remove the attribute if its value is 0
if ( i != nCount )
{
if ( pAttribute->GetValue<bool>( ) == 0 )
{
pMaterial->RemoveAttributeByPtr( pAttribute );
}
continue;
}
// FIXME: We can't do this.. the defaults in the strings need to be changed to
// make it so they actually match the true defaults
continue;
// Remove parameters which match the default value
nCount = m_pCurrentIShader->GetNumParams();
for ( i = 0; i < nCount; ++i )
{
// FIXME: Check type matches
if ( Q_stricmp( pShaderParam, m_pCurrentIShader->GetParamName( i ) ) )
continue;
// NOTE: This isn't particularly efficient. Too bad!
// It's hard to do efficiently owing to all the import conversion
char temp[512];
char temp2[512];
CUtlBuffer buf( temp, sizeof(temp), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
CUtlBuffer buf2( temp2, sizeof(temp2), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
pAttribute->Serialize( buf );
SetAttributeValueFromDefault( pMaterial, pAttribute, m_pCurrentIShader->GetParamDefault( i ) );
pAttribute->Serialize( buf2 );
if ( ( buf.TellMaxPut() == buf2.TellMaxPut() ) && !memcmp( buf.Base(), buf2.Base(), buf.TellMaxPut() ) )
{
// Buffers match! Therefore it's still using the default parameter
pMaterial->RemoveAttributeByPtr( pAttribute );
}
else
{
// Restore the actual value
pAttribute->Unserialize( buf );
}
break;
}
}
return pMaterial;
}
//-----------------------------------------------------------------------------
// Saves to disk
//-----------------------------------------------------------------------------
bool CVMTDoc::SaveToFile( )
{
if ( m_hRoot.Get() && m_pFileName && m_pFileName[0] )
{
CDisableUndoScopeGuard guard;
CDmElement *pSaveRoot = ExtractDefaultParameters();
bool bOk = g_pDataModel->SaveToFile( m_pFileName, NULL, "keyvalues", "vmt", pSaveRoot );
DestroyElement( pSaveRoot, TD_DEEP );
if ( !bOk )
return false;
}
SetDirty( false );
return true;
}
//-----------------------------------------------------------------------------
// Finds a shader
//-----------------------------------------------------------------------------
IShader *CVMTDoc::FindShader( const char *pShaderName )
{
int nCount = g_pMaterialSystem->ShaderCount();
IShader **ppShaderList = (IShader**)_alloca( nCount * sizeof(IShader*) );
g_pMaterialSystem->GetShaders( 0, nCount, ppShaderList );
for ( int i = 0; i < nCount; ++i )
{
if ( !Q_stricmp( pShaderName, ppShaderList[i]->GetName() ) )
return ppShaderList[i];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Is this attribute a shader parameter?
//-----------------------------------------------------------------------------
bool CVMTDoc::IsShaderParam( CDmAttribute* pAttribute )
{
const char *pName = pAttribute->GetName();
// Shader params start with a $ or %
if ( pName[0] != '$' && pName[0] != '%' )
return false;
// Don't remove name, type, or id
if ( pAttribute->IsFlagSet( FATTRIB_STANDARD ) )
return false;
// All shader params have USERDEFINED set
if ( !pAttribute->IsFlagSet( FATTRIB_USERDEFINED ) )
return false;
// Don't remove arrays... those aren't shader parameters
if ( pAttribute->GetType() == AT_ELEMENT_ARRAY )
return false;
// Standard params aren't counted here
for ( int i = 0; g_pStandardParams[i].m_pParamName; ++i )
{
if ( !Q_stricmp( g_pStandardParams[i].m_pParamName, pName ) )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Remove all shader parameters
//-----------------------------------------------------------------------------
void CVMTDoc::RemoveAllShaderParams( CDmElement *pMaterial )
{
CDmAttribute* pAttribute;
CDmAttribute* pNextAttribute = NULL;
for ( pAttribute = pMaterial->FirstAttribute(); pAttribute; pAttribute = pNextAttribute )
{
pNextAttribute = pAttribute->NextAttribute();
// Only remove shader parameters
if ( !IsShaderParam( pAttribute ) )
continue;
m_pCallback->RemoveShaderParameter( pAttribute->GetName() );
pMaterial->RemoveAttributeByPtr( pAttribute );
}
}
//-----------------------------------------------------------------------------
// Remove all shader parameters that don't exist in the new shader
//-----------------------------------------------------------------------------
void CVMTDoc::RemoveUnusedShaderParams( CDmElement *pMaterial, IShader *pShader, IShader *pOldShader )
{
CDmAttribute* pAttribute = pMaterial->FirstAttribute();
CDmAttribute* pNextAttribute = NULL;
for ( ; pAttribute; pAttribute = pNextAttribute )
{
pNextAttribute = pAttribute->NextAttribute();
// Only remove shader parameters
if ( !IsShaderParam( pAttribute ) )
continue;
// Don't remove flags
int nCount = g_pMaterialSystem->ShaderFlagCount();
int i;
for ( i = 0; i < nCount; ++i )
{
const char *pFlagName = g_pMaterialSystem->ShaderFlagName( i );
if ( !Q_stricmp( pAttribute->GetName(), pFlagName ) )
break;
}
if ( i != nCount )
continue;
const char *pShaderParam = pAttribute->GetName();
// Remove parameters we've currently got but which don't exist in the new shader
nCount = pShader->GetNumParams();
for ( i = 0; i < nCount; ++i )
{
// FIXME: Check type matches
if ( !Q_stricmp( pShaderParam, pShader->GetParamName( i ) ) )
break;
}
// No match? Remove it!
if ( i == nCount )
{
m_pCallback->RemoveShaderParameter( pAttribute->GetName() );
pMaterial->RemoveAttributeByPtr( pAttribute );
continue;
}
// Remove parameters from the old shader which match the default value
// This will make the default values update to the new shader's defaults
if ( pOldShader )
{
nCount = pOldShader->GetNumParams();
for ( i = 0; i < nCount; ++i )
{
// FIXME: Check type matches
if ( Q_stricmp( pShaderParam, pOldShader->GetParamName( i ) ) )
continue;
// NOTE: This isn't particularly efficient. Too bad!
// It's hard to do efficiently owing to all the import conversion
char temp1[512];
char temp2[512];
CUtlBuffer buf1( temp1, sizeof(temp1), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
CUtlBuffer buf2( temp2, sizeof(temp2), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
pAttribute->Serialize( buf1 );
SetAttributeValueFromDefault( pMaterial, pAttribute, pOldShader->GetParamDefault( i ) );
pAttribute->Serialize( buf2 );
if ( ( buf1.TellMaxPut() == buf2.TellMaxPut() ) && !memcmp( buf1.Base(), buf2.Base(), buf1.TellMaxPut() ) )
{
// Buffers match! Therefore it's still using the default parameter
m_pCallback->RemoveShaderParameter( pAttribute->GetName() );
pMaterial->RemoveAttributeByPtr( pAttribute );
}
else
{
pAttribute->Unserialize( buf1 );
}
break;
}
}
}
}
//-----------------------------------------------------------------------------
// Add attribute for shader parameter
//-----------------------------------------------------------------------------
CDmAttribute* CVMTDoc::AddAttributeForShaderParameter( CDmElement *pMaterial, const char *pParamName, ShaderParamType_t paramType )
{
CDmAttribute *pAttribute = NULL;
switch ( paramType )
{
case SHADER_PARAM_TYPE_INTEGER:
pAttribute = pMaterial->AddAttribute( pParamName, AT_INT );
break;
case SHADER_PARAM_TYPE_BOOL:
pAttribute = pMaterial->AddAttribute( pParamName, AT_BOOL );
break;
case SHADER_PARAM_TYPE_FLOAT:
pAttribute = pMaterial->AddAttribute( pParamName, AT_FLOAT );
break;
case SHADER_PARAM_TYPE_STRING:
pAttribute = pMaterial->AddAttribute( pParamName, AT_STRING );
break;
case SHADER_PARAM_TYPE_COLOR:
pAttribute = pMaterial->AddAttribute( pParamName, AT_COLOR );
break;
case SHADER_PARAM_TYPE_VEC2:
pAttribute = pMaterial->AddAttribute( pParamName, AT_VECTOR2 );
break;
case SHADER_PARAM_TYPE_VEC3:
pAttribute = pMaterial->AddAttribute( pParamName, AT_VECTOR3 );
break;
case SHADER_PARAM_TYPE_VEC4:
pAttribute = pMaterial->AddAttribute( pParamName, AT_VECTOR4 );
break;
case SHADER_PARAM_TYPE_FOURCC:
Assert( 0 );
break;
case SHADER_PARAM_TYPE_MATRIX:
pAttribute = pMaterial->AddAttribute( pParamName, AT_VMATRIX );
break;
case SHADER_PARAM_TYPE_TEXTURE:
pAttribute = pMaterial->AddAttribute( pParamName, AT_STRING );
m_pCallback->AddShaderParameter( pParamName, "vtfpicker", "vtfName" );
break;
case SHADER_PARAM_TYPE_MATERIAL:
pAttribute = pMaterial->AddAttribute( pParamName, AT_STRING );
m_pCallback->AddShaderParameter( pParamName, "vmtpicker", "vmtName" );
break;
default:
break;
}
if ( pAttribute )
{
pAttribute->AddFlag( FATTRIB_USERDEFINED );
}
return pAttribute;
}
//-----------------------------------------------------------------------------
// A couple methods to set vmatrix param values from strings (OLD METHOD!)
//-----------------------------------------------------------------------------
bool CVMTDoc::SetVMatrixParamValue( CDmAttribute *pAttribute, const char *pValue )
{
// FIXME: Change default strings to match DME?
// Then we could remove this crap
VMatrix mat;
int count = sscanf( pValue, " [ %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)
{
pAttribute->SetValue( mat );
return true;
}
Vector2D scale, center;
float angle;
Vector2D translation;
count = sscanf( pValue, " 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 );
pAttribute->SetValue( mat );
return true;
}
//-----------------------------------------------------------------------------
// A couple methods to set vmatrix param values from strings (OLD METHOD!)
//-----------------------------------------------------------------------------
bool CVMTDoc::SetVector2DParamValue( CDmAttribute *pAttribute, const char *pValue )
{
Vector2D vec;
int count = sscanf( pValue, " [ %f %f ]", &vec[0], &vec[1] );
if ( count == 2 )
{
pAttribute->SetValue( vec );
return true;
}
count = sscanf( pValue, " { %f %f }", &vec[0], &vec[1] );
if ( count == 2 )
{
vec /= 255.0f;
pAttribute->SetValue( vec );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// A couple methods to set vmatrix param values from strings (OLD METHOD!)
//-----------------------------------------------------------------------------
bool CVMTDoc::SetVector3DParamValue( CDmAttribute *pAttribute, const char *pValue )
{
Vector vec;
int count = sscanf( pValue, " [ %f %f %f ]", &vec[0], &vec[1], &vec[2] );
if ( count == 3 )
{
pAttribute->SetValue( vec );
return true;
}
count = sscanf( pValue, " { %f %f %f }", &vec[0], &vec[1], &vec[2] );
if ( count == 3 )
{
vec /= 255.0f;
pAttribute->SetValue( vec );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// A couple methods to set vmatrix param values from strings (OLD METHOD!)
//-----------------------------------------------------------------------------
bool CVMTDoc::SetVector4DParamValue( CDmAttribute *pAttribute, const char *pValue )
{
Vector4D vec;
int count = sscanf( pValue, " [ %f %f %f %f ]", &vec[0], &vec[1], &vec[2], &vec[3] );
if ( count == 4 )
{
pAttribute->SetValue( vec );
return true;
}
count = sscanf( pValue, " { %f %f %f %f }", &vec[0], &vec[1], &vec[2], &vec[3] );
if ( count == 4 )
{
vec /= 255.0f;
pAttribute->SetValue( vec );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// A couple methods to set vmatrix param values from strings (OLD METHOD!)
//-----------------------------------------------------------------------------
bool CVMTDoc::SetColorParamValue( CDmAttribute *pAttribute, const char *pValue )
{
Color c;
int r, g, b;
Vector vec;
int count = sscanf( pValue, " [ %f %f %f ]", &vec[0], &vec[1], &vec[2] );
if ( count == 3 )
{
vec *= 255.0f;
r = clamp( vec[0], 0, 255 );
g = clamp( vec[1], 0, 255 );
b = clamp( vec[2], 0, 255 );
c.SetColor( r, g, b, 255 );
pAttribute->SetValue( c );
return true;
}
count = sscanf( pValue, " { %d %d %d }", &r, &g, &b );
if ( count == 3 )
{
c.SetColor( r, g, b, 255 );
pAttribute->SetValue( c );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Sets an attribute value from the shader param default
//-----------------------------------------------------------------------------
void CVMTDoc::SetAttributeValueFromDefault( CDmElement *pMaterial, CDmAttribute *pAttribute, const char *pValue )
{
// FIXME: Change default strings to match DME?
// Then we could remove this crap
switch ( pAttribute->GetType() )
{
case AT_VMATRIX:
if ( SetVMatrixParamValue( pAttribute, pValue ) )
return;
break;
case AT_COLOR:
if ( SetColorParamValue( pAttribute, pValue ) )
return;
break;
case AT_VECTOR2:
if ( SetVector2DParamValue( pAttribute, pValue ) )
return;
break;
case AT_VECTOR3:
if ( SetVector3DParamValue( pAttribute, pValue ) )
return;
break;
case AT_VECTOR4:
if ( SetVector4DParamValue( pAttribute, pValue ) )
return;
break;
}
pMaterial->SetValueFromString( pAttribute->GetName(), pValue );
}
//-----------------------------------------------------------------------------
// Add a single shader parameter if it doesn't exist
//-----------------------------------------------------------------------------
void CVMTDoc::AddNewShaderParam( CDmElement *pMaterial, const char *pParamName, ShaderParamType_t paramType, const char *pValue )
{
char temp[512];
Q_strncpy( temp, pParamName, sizeof(temp) );
Q_strlower( temp );
pParamName = temp;
CDmAttribute* pAttribute = NULL;
for ( pAttribute = pMaterial->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() )
{
// Don't bother testing against name, type, or id
if ( pAttribute->IsFlagSet( FATTRIB_STANDARD ) )
continue;
const char *pAttributeName = pAttribute->GetName();
if ( !Q_stricmp( pAttributeName, pParamName ) )
return;
}
// No match? Add it!
pAttribute = AddAttributeForShaderParameter( pMaterial, pParamName, paramType );
if ( pAttribute )
{
SetAttributeValueFromDefault( pMaterial, pAttribute, pValue );
}
}
//-----------------------------------------------------------------------------
// Add all shader parameters that don't currently exist
//-----------------------------------------------------------------------------
void CVMTDoc::AddNewShaderParams( CDmElement *pMaterial, IShader *pShader )
{
// First add all flags
m_pCallback->RemoveAllFlagParameters();
int nCount = g_pMaterialSystem->ShaderFlagCount();
int i;
for ( i = 0; i < nCount; ++i )
{
const char *pParamName = g_pMaterialSystem->ShaderFlagName( i );
AddNewShaderParam( pMaterial, pParamName, SHADER_PARAM_TYPE_BOOL, "0" );
m_pCallback->AddFlagParameter( pParamName );
}
// Next add all shader-specific parameters
nCount = pShader->GetNumParams();
for ( i = 0; i < nCount; ++i )
{
const char *pParamName = pShader->GetParamName( i );
// Don't add parameters that don't want to be editable
if ( pShader->GetParamFlags( i ) & SHADER_PARAM_NOT_EDITABLE )
continue;
ShaderParamType_t paramType = pShader->GetParamType( i );
const char *pDefault = pShader->GetParamDefault( i );
AddNewShaderParam( pMaterial, pParamName, paramType, pDefault );
}
}
//-----------------------------------------------------------------------------
// Sets shader parameters to the default for that shader
//-----------------------------------------------------------------------------
void CVMTDoc::SetParamsToDefault()
{
// This is undoable
CAppUndoScopeGuard guard( 0, "Set Params to Default", "Set Params to Default" );
// Next add all shader-specific parameters
int nCount = m_pCurrentIShader->GetNumParams();
for ( int i = 0; i < nCount; ++i )
{
const char *pParamName = m_pCurrentIShader->GetParamName( i );
// Don't set parameters that don't want to be editable
if ( m_pCurrentIShader->GetParamFlags( i ) & SHADER_PARAM_NOT_EDITABLE )
continue;
char pAttributeName[512];
Q_strncpy( pAttributeName, pParamName, sizeof(pAttributeName) );
Q_strlower( pAttributeName );
if ( !m_hRoot->HasAttribute( pAttributeName ) )
continue;
CDmAttribute *pAttribute = m_hRoot->GetAttribute( pAttributeName );
const char *pDefault = m_pCurrentIShader->GetParamDefault( i );
SetAttributeValueFromDefault( m_hRoot, pAttribute, pDefault );
}
}
//-----------------------------------------------------------------------------
// Sets the shader in the material
//-----------------------------------------------------------------------------
void CVMTDoc::SetShader( const char *pShaderName )
{
// No change? don't bother
if ( !Q_stricmp( m_CurrentShader, pShaderName ) )
return;
m_CurrentShader = pShaderName;
// This is undoable
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Set Shader", "Set Shader" );
char pActualShaderName[512];
g_pMaterialSystem->GetShaderFallback( pShaderName, pActualShaderName, sizeof(pActualShaderName) );
m_hRoot->SetValue( "shader", pShaderName );
// First, find the shader
IShader *pShader = FindShader( pActualShaderName );
// Remove all shader parameters that don't exist in the new shader
// And also remove shader parameters that do match the default value
RemoveUnusedShaderParams( m_hRoot, pShader, m_pCurrentIShader );
// Add all shader parameters that don't currently exist
AddNewShaderParams( m_hRoot, pShader );
m_pCurrentIShader = pShader;
}
//-----------------------------------------------------------------------------
// Gets the preview material
//-----------------------------------------------------------------------------
IMaterial *CVMTDoc::GetPreviewMaterial()
{
return m_pPreviewMaterial;
}
//-----------------------------------------------------------------------------
// Updates the preview material
//-----------------------------------------------------------------------------
void CVMTDoc::UpdatePreviewMaterial()
{
if ( !m_hRoot.Get() )
return;
// Update all shader parameters
SetShader( m_hRoot->GetValueString( "shader" ) );
// Use the file conversion to write to a text format
char buf[1024];
CUtlBuffer vmtBuf( buf, sizeof(buf), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
g_pDataModel->Serialize( vmtBuf, "vmt", "vmt", m_hRoot );
// Now use the text format to create a keyvalues
KeyValues *pVMTKeyValues = new KeyValues( "ShaderName" );
pVMTKeyValues->LoadFromBuffer( "VMT Preview", vmtBuf, g_pFileSystem, "GAME" );
// Finally, hook the keyvalues into the material.
m_pPreviewMaterial->SetShaderAndParams( pVMTKeyValues );
pVMTKeyValues->deleteThis();
}
//-----------------------------------------------------------------------------
// Returns the root object
//-----------------------------------------------------------------------------
CDmElement *CVMTDoc::GetRootObject()
{
return m_hRoot;
}
//-----------------------------------------------------------------------------
// Called when data changes
//-----------------------------------------------------------------------------
void CVMTDoc::OnDataChanged( const char *pReason, int nNotifySource, int nNotifyFlags )
{
SetDirty( nNotifyFlags & NOTIFY_SETDIRTYFLAG ? true : false );
UpdatePreviewMaterial();
m_pCallback->OnDocChanged( pReason, nNotifySource, nNotifyFlags );
}