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.
521 Commits
25 Branches
6 Tags
221 MiB
Tree: b9cf6b2c7e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b9cf6b2c7e'
${ noResults }
source-engine/utils/itemtest_controls/itemtest_controls.cpp

1759 lines
48 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//=============================================================================
//
//=============================================================================
// Standard includes
#define WIN32_LEAN_AND_MEAN
#include <direct.h>
#include <Windows.h>
// Valve includes
#include "itemtest/itemtest_controls.h"
#include "vgui/IVGui.h"
#include "vgui/IInput.h"
#include "vgui/ISystem.h"
#include "vgui/IPanel.h"
#include "vgui_controls/CheckButton.h"
#include "vgui_controls/ComboBox.h"
#include "vgui_controls/FileOpenDialog.h"
#include "vgui_controls/Menu.h"
#include "vgui_controls/MenuItem.h"
#include "vgui_controls/MessageBox.h"
#include "vgui_controls/PanelListPanel.h"
#include "vgui_controls/ScrollBar.h"
#include "vgui_controls/TextImage.h"
#include "tier1/fmtstr.h"
// Local includes
#include "dualpanellist.h"
// Last include
#include <tier0/memdbgon.h>
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CItemUploadDialog *g_pItemUploadDialog = NULL;
//=============================================================================
//
//=============================================================================
CStatusLabel::CStatusLabel( vgui::Panel *pPanel, const char *pszName, bool bValid /* = false */ )
: BaseClass( pPanel, pszName, "" )
, m_bValid( bValid )
, m_cValid( 0, 192, 0, 255 )
, m_cInvalid( 192, 0, 0, 255 )
{
SetText( m_bValid ? "#valid" : "#invalid" );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CStatusLabel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
SetContentAlignment( vgui::Label::a_center );
m_cValid = pScheme->GetColor( "StatusLabel.ValidColor", m_cValid );
m_cInvalid = pScheme->GetColor( "StatusLabel.InvalidColor", m_cInvalid );
UpdateColors();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CStatusLabel::SetValid( bool bValid )
{
if ( bValid == m_bValid )
return;
m_bValid = bValid;
SetText( m_bValid ? "#valid" : "#invalid" );
UpdateColors();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CStatusLabel::GetValid() const
{
return m_bValid;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CStatusLabel::UpdateColors()
{
// TODO: Set valid/invalid colors in scheme .res file...
if ( GetValid() )
{
SetBgColor( m_cValid );
}
else
{
SetBgColor( m_cInvalid );
}
}
//=============================================================================
//
//=============================================================================
CItemUploadSubPanel::CItemUploadSubPanel( vgui::Panel *pParent, const char *pszName, const char *pszNextName )
: BaseClass( pParent, pszName )
, m_sNextName( pszNextName )
{
// Set the Wizard panel if the parent is a Wizard panel (it should be)
vgui::WizardPanel *pWizardPanel = dynamic_cast< vgui::WizardPanel * >( pParent );
if ( pWizardPanel )
{
SetWizardPanel( pWizardPanel );
}
CFmtStr sTmp;
// Create the two standard widgets
if ( CItemUpload::GetDevMode() )
{
sTmp.sprintf( "#itemtest_wizard_%s_info_dev", GetName() );
const char *pszCheck = g_pVGuiLocalize->FindAsUTF8( sTmp );
if ( pszCheck == sTmp.Access() )
{
sTmp.Clear();
}
}
if ( sTmp.Length() <= 0 )
{
sTmp.sprintf( "#itemtest_wizard_%s_info", GetName() );
}
m_pLabel = new vgui::Label( this, "info", sTmp );
m_pPanelListPanel = new vgui::PanelListPanel( this, "list" );
m_pStatusLabel = new CStatusLabel( this, "statusLabel", false );
m_pStatusText = new vgui::Label( this, "statusText", "wonk" );
sTmp.sprintf( "itemtest_wizard_%s.res", GetName() );
LoadControlSettings( sTmp );
m_pLabel->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_RIGHT, 0, 0, 0, 0 );
m_pLabel->SizeToContents(); // Supposedly doesn't work until layout but kind of does...
m_pLabel->SetWrap( true );
m_pStatusLabel->SetAutoResize( PIN_BOTTOMLEFT, AUTORESIZE_NO, 0, 0, 0, 0 );
if ( GetWizardPanel() && pszNextName == NULL )
{
GetWizardPanel()->SetFinishButtonEnabled( false );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadSubPanel::PerformLayout()
{
BaseClass::PerformLayout();
int nOldWide = m_pLabel->GetWide();
m_pLabel->SizeToContents();
m_pLabel->SetWide( nOldWide );
int nX = 0;
int nY = 0;
m_pLabel->GetPos( nX, nY );
int nX1 = 0;
int nY1 = 0;
m_pStatusLabel->GetPos( nX1, nY1 );
m_pPanelListPanel->SetBounds( nX, nY + m_pLabel->GetTall() + 10, m_pLabel->GetWide(), nY1 - nY - m_pLabel->GetTall() - 20 );
bool bDone = false;
for ( int i = 1; i < m_pPanelListPanel->GetItemCount(); i += 2 )
{
vgui::Panel *pPanelA0 = m_pPanelListPanel->GetItemLabel( i - 1 );
vgui::Panel *pPanelA1 = m_pPanelListPanel->GetItemPanel( i - 1 );
vgui::Panel *pPanelB0 = m_pPanelListPanel->GetItemLabel( i );
vgui::Panel *pPanelB1 = m_pPanelListPanel->GetItemPanel( i );
pPanelA0->SetTall( pPanelA1->GetTall() );
pPanelB1->SetTall( pPanelB0->GetTall() );
if ( !bDone )
{
bDone = true;
m_pStatusLabel->SetSize( pPanelA0->GetWide(), pPanelB0->GetTall() );
}
}
m_pStatusLabel->GetPos( nX, nY );
m_pStatusText->SetPos( nX + m_pStatusLabel->GetWide() + 5, nY );
m_pStatusText->SetWide( m_pLabel->GetWide() - nX );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadSubPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
if ( dynamic_cast< CGlobalSubPanel * >( this ) )
return;
if ( dynamic_cast< CGeometrySubPanel * >( this ) )
return;
/*
#ifdef _DEBUG
m_pLabel->SetBgColor( Color( 255, 127, 0, 255 ) );
m_pPanelListPanel->SetBgColor( Color( 0, 127, 0 ) );
for ( int i = 1; i < m_pPanelListPanel->GetItemCount(); i += 2 )
{
vgui::Panel *pPanel = m_pPanelListPanel->GetItemPanel( i );
if ( pPanel )
{
pPanel->SetBgColor( Color( 0, 0, 255 ) );
}
}
#endif // _DEBUG
*/
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadSubPanel::OnDisplay()
{
UpdateGUI();
// UpdateStatus();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
vgui::WizardSubPanel *CItemUploadSubPanel::GetNextSubPanel()
{
return dynamic_cast< WizardSubPanel * >( GetWizardPanel()->FindChildByName( m_sNextName.Get() ) );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUploadSubPanel::UpdateStatus()
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return false;
if ( pItemUploadWizard->GetCurrentItemUploadSubPanel() != this )
return false;
CAsset &asset = pItemUploadWizard->Asset();
CFmtStr sTmp;
sTmp.sprintf( "#itemtest_wizard_%s_title", GetName() );
CUtlString sRelativeDir;
asset.GetRelativeDir( sRelativeDir, NULL );
const char *pszTitle = g_pVGuiLocalize->FindAsUTF8( sTmp );
CUtlString sStatusMsg;
if ( asset.IsOk( sStatusMsg ) && !sRelativeDir.IsEmpty() && pszTitle )
{
sTmp.sprintf( "%s : %s", pszTitle, sRelativeDir.Get() );
}
else if ( !sStatusMsg.IsEmpty() )
{
}
pItemUploadWizard->SetTitle( sTmp, true );
bool bValid = true;
for ( int i = 1; bValid && i < m_pPanelListPanel->GetItemCount(); i += 2 )
{
CStatusLabel *pStatusLabel = dynamic_cast< CStatusLabel * >( m_pPanelListPanel->GetItemLabel( i ) );
if ( !pStatusLabel )
continue;
bValid = bValid && pStatusLabel->GetValid();
}
m_pStatusLabel->SetValid( bValid );
sTmp.sprintf( "#itemtest_wizard_%s_%s", GetName(), bValid ? "valid" : "invalid" );
m_pStatusText->SetText( sTmp );
pItemUploadWizard->SetNextButtonEnabled( bValid );
if ( pItemUploadWizard->GetCurrentSubPanel() == this )
{
pItemUploadWizard->SetFinishButtonEnabled( m_sNextName.IsEmpty() ? true : false );
}
return bValid;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadSubPanel::AddStatusPanels( const char *pszPrefix )
{
CFmtStr sTmp;
sTmp.sprintf( "%sStatusLabel", pszPrefix );
CStatusLabel *pStatusLabel = new CStatusLabel( this, sTmp );
sTmp.sprintf( "%sStatusText", pszPrefix );
vgui::Label *pStatusText = new vgui::Label( this, sTmp, "" );
m_pPanelListPanel->AddItem( pStatusLabel, pStatusText );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadSubPanel::SetStatus( bool bValid, const char *pszPrefix, const char *pszMessage /* = NULL */, bool bHide /* = false */ )
{
CFmtStr sTmp;
sTmp.sprintf( "%sStatusLabel", pszPrefix );
CStatusLabel *pStatusLabel = dynamic_cast< CStatusLabel * >( m_pPanelListPanel->FindChildByName( sTmp, true ) );
if ( pStatusLabel )
{
pStatusLabel->SetValid( bValid );
pStatusLabel->SetVisible( !bHide );
}
sTmp.sprintf( "%sStatusText", pszPrefix );
vgui::Label *pStatusText = dynamic_cast< vgui::Label * >( m_pPanelListPanel->FindChildByName( sTmp, true ) );
if ( pStatusText )
{
if ( pszMessage )
{
pStatusText->SetText( pszMessage );
}
else
{
sTmp.sprintf( "#%s%s", pszPrefix, bValid ? "Valid" : "Invalid" );
pStatusText->SetText( sTmp );
}
pStatusText->SetVisible( !bHide );
}
}
//=============================================================================
//
//=============================================================================
class CFileLocationPanel : public vgui::Panel
{
DECLARE_CLASS_SIMPLE( CFileLocationPanel, vgui::Panel );
public:
CFileLocationPanel( vgui::Panel *pParent, int nLodIndex )
: BaseClass( pParent )
{
m_pButtonBrowse = new vgui::Button( this, "BrowseButton", "#BrowseButton", pParent );
m_pButtonBrowse->SetCommand( new KeyValues( "Open" ) );
m_pButtonBrowse->AddActionSignalTarget( pParent );
m_pLabel = new vgui::Label( this, "FileLabel", "" );
}
virtual void PerformLayout()
{
BaseClass::PerformLayout();
int w = 0;
int h = 0;
GetSize( w, h );
m_pButtonBrowse->SizeToContents();
SetTall( m_pButtonBrowse->GetTall() );
m_pButtonBrowse->SetPos( w - m_pButtonBrowse->GetWide(), 0 );
m_pLabel->SetSize( w - m_pButtonBrowse->GetWide(), m_pButtonBrowse->GetTall() );
m_pLabel->SetPos( 0, 0 );
}
vgui::Button *m_pButtonBrowse;
vgui::Label *m_pLabel;
};
//=============================================================================
//
//=============================================================================
class CLODFileLocationPanel : public vgui::Panel
{
DECLARE_CLASS_SIMPLE( CLODFileLocationPanel, vgui::Panel );
public:
CLODFileLocationPanel( vgui::Panel *pParent, int nLodIndex )
: BaseClass( pParent )
{
CFmtStr sButtonDelete;
sButtonDelete.sprintf( "#LOD%dDelete", nLodIndex );
m_pButtonDelete = new vgui::Button( this, sButtonDelete, sButtonDelete );
m_pButtonDelete->SetCommand( new KeyValues( "Delete", "nLODIndex", nLodIndex ) );
m_pButtonDelete->AddActionSignalTarget( pParent );
CFmtStr sButton;
sButton.sprintf( "#LOD%dButton", nLodIndex );
m_pButtonBrowse = new vgui::Button( this, sButton, sButton, pParent );
m_pButtonBrowse->SetCommand( new KeyValues( "Open", "nLODIndex", nLodIndex ) );
m_pButtonBrowse->AddActionSignalTarget( pParent );
CFmtStr sTextEntry;
sTextEntry.sprintf( "#LOD%dTextEntry", nLodIndex );
m_pLabel = new vgui::Label( this, sTextEntry, "" );
}
virtual void PerformLayout()
{
BaseClass::PerformLayout();
int w = 0;
int h = 0;
GetSize( w, h );
m_pButtonDelete->SizeToContents();
m_pButtonBrowse->SizeToContents();
SetTall( m_pButtonBrowse->GetTall() );
m_pButtonDelete->SetPos( w - m_pButtonDelete->GetWide(), 0 );
m_pButtonBrowse->SetPos( w - ( m_pButtonDelete->GetWide() + m_pButtonBrowse->GetWide() ), 0 );
m_pLabel->SetSize( w - ( m_pButtonDelete->GetWide() + m_pButtonBrowse->GetWide() ), m_pButtonBrowse->GetTall() );
m_pLabel->SetPos( 0, 0 );
}
vgui::Button *m_pButtonBrowse;
vgui::Button *m_pButtonDelete;
vgui::Label *m_pLabel;
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CGeometrySubPanel::CGeometrySubPanel( vgui::Panel *pParent, const char *pszName, const char *pszNextName )
: BaseClass( pParent, pszName, pszNextName )
{
m_pFileOpenStateMachine = new vgui::FileOpenStateMachine( this, this );
m_pFileOpenStateMachine->AddActionSignalTarget( this );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGeometrySubPanel::UpdateGUI()
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return;
CAsset &asset = pItemUploadWizard->Asset();
int nGeometryCount = m_pPanelListPanel->GetItemCount() / 2;
for ( int i = 0; i < asset.TargetDMXCount(); ++i )
{
if ( i >= nGeometryCount )
{
AddGeometry();
nGeometryCount = m_pPanelListPanel->GetItemCount() / 2;
}
if ( i >= nGeometryCount )
break; // unrecoverable error
CLODFileLocationPanel *pFileLocationPanel = dynamic_cast< CLODFileLocationPanel * >( m_pPanelListPanel->GetItemPanel( i * 2 ) );
if ( !pFileLocationPanel )
continue;
vgui::Label *pLabel = pFileLocationPanel->m_pLabel;
if ( !pLabel )
continue;
CSmartPtr< CTargetDMX > pTargetDmx = asset.GetTargetDMX( i );
if ( !pTargetDmx )
continue;
pLabel->SetText( pTargetDmx->GetInputFile().Get() );
}
// Ensure an empty blank one at the end
if ( nGeometryCount == asset.TargetDMXCount() )
{
AddGeometry();
}
else
{
// Remove superfluous
while ( m_pPanelListPanel->GetItemCount() / 2 > ( asset.TargetDMXCount() + 1 ) )
{
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
}
// Set last one to empty
if ( ( m_pPanelListPanel->GetItemCount() / 2 ) == ( asset.TargetDMXCount() + 1 ) )
{
CLODFileLocationPanel *pFileLocationPanel = dynamic_cast< CLODFileLocationPanel * >( m_pPanelListPanel->GetItemPanel( m_pPanelListPanel->GetItemCount() - 2 ) );
if ( pFileLocationPanel )
{
vgui::Label *pLabel = pFileLocationPanel->m_pLabel;
if ( pLabel )
{
pLabel->SetText( "" );
}
}
}
}
UpdateStatus();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CGeometrySubPanel::UpdateStatus()
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return false;
CAsset &asset = pItemUploadWizard->Asset();
CFmtStr sTmp;
CFmtStr sErrString;
int nLODIndex = 0;
int nThisPolyCount = 0;
int nLastPolyCount = 0;
for ( int i = 0; i < m_pPanelListPanel->GetItemCount(); i += 2, ++nLODIndex )
{
CLODFileLocationPanel *pFileLocationPanel = dynamic_cast< CLODFileLocationPanel * >( m_pPanelListPanel->GetItemPanel( i ) );
if ( !pFileLocationPanel )
continue;
vgui::Label *pLabel = pFileLocationPanel->m_pLabel;
if ( !pLabel )
continue;
if ( i == ( m_pPanelListPanel->GetItemCount() - 4 ) )
{
pFileLocationPanel->m_pButtonDelete->SetEnabled( true );
}
else
{
pFileLocationPanel->m_pButtonDelete->SetEnabled( false );
}
sTmp.sprintf( "LOD%d", nLODIndex );
if ( i < ( m_pPanelListPanel->GetItemCount() - 2 ) )
{
CSmartPtr< CTargetDMX > pTargetDMX = asset.GetTargetDMX( nLODIndex );
if ( !pTargetDMX )
{
sErrString.sprintf( "Invalid Geometry: LOD %d is NULL", nLODIndex );
SetStatus( false, sTmp, sErrString );
continue;
}
CUtlString sStatusMsg;
if ( !pTargetDMX->IsOk( sStatusMsg ) )
{
SetStatus( false, sStatusMsg.Get() );
continue;
}
nLastPolyCount = nThisPolyCount;
nThisPolyCount = pTargetDMX->GetPolyCount();
if ( nThisPolyCount <= 0 )
{
sErrString.sprintf( "LOD %d has bad polygon count: %d", i, nThisPolyCount );
SetStatus( false, sTmp, sErrString );
continue;
}
if ( ( i > 0 ) && ( nThisPolyCount == nLastPolyCount ) )
{
sErrString.sprintf( "LOD %d (%d polys) has the same number of polygons as previous LOD %d (%d polys)",
nLODIndex, nThisPolyCount, nLODIndex - 1, nLastPolyCount );
SetStatus( false, sTmp, sErrString );
continue;
}
if ( ( i > 0 ) && ( nThisPolyCount >= nLastPolyCount ) )
{
sErrString.sprintf( "LOD %d (%d polys) has more polygons than previous LOD %d (%d polys)",
nLODIndex, nThisPolyCount, nLODIndex - 1, nLastPolyCount );
SetStatus( false, sTmp, sErrString );
continue;
}
SetStatus( true, sTmp );
}
else
{
SetStatus( true, sTmp, NULL, true );
}
}
bool bValid = BaseClass::UpdateStatus();
// In this case there are more validation checks to be performed
// Ensure each LOD is non-empty
if ( bValid )
{
sErrString.Clear();
// Ensure at least two LODs
if ( CItemUpload::GetDevMode() )
{
if ( asset.TargetDMXCount() < 1 )
{
bValid = false;
sErrString.sprintf( "At least 1 LOD is required" );
}
}
else if ( asset.TargetDMXCount() < 2 )
{
bValid = false;
sErrString.sprintf( "At least 2 LODs are required" );
}
// Any other overall checks can go here
m_pStatusLabel->SetValid( bValid );
if ( !bValid )
{
// Not sure how to translate this message with parameters, etc...
m_pStatusText->SetText( sErrString );
}
pItemUploadWizard->SetNextButtonEnabled( bValid );
}
return bValid;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGeometrySubPanel::SetupFileOpenDialog(
vgui::FileOpenDialog *pDialog,
bool bOpenFile,
const char *pszFileName,
KeyValues *pContextKeyValues )
{
char pszStartingDir[ MAX_PATH ];
if ( !vgui::system()->GetRegistryString(
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\geometry\\opendir",
pszStartingDir, sizeof( pszStartingDir ) ) )
{
_getcwd( pszStartingDir, ARRAYSIZE( pszStartingDir ));
CUtlString sVMod;
CUtlString sContentDir;
if ( CItemUpload::GetVMod( sVMod ) && !sVMod.IsEmpty() && CItemUpload::GetContentDir( sContentDir ) && !sContentDir.IsEmpty() && CItemUpload::FileExists( sContentDir.Get() ) )
{
sContentDir += "/";
sContentDir += sVMod;
sContentDir += "/models";
CUtlString sTmp = sContentDir;
sTmp += "/player";
if ( CItemUpload::FileExists( sTmp.Get() ) )
{
sContentDir = sTmp;
sTmp += "/items";
if ( CItemUpload::FileExists( sTmp.Get() ) )
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( pItemUploadWizard )
{
CAsset &asset = pItemUploadWizard->Asset();
sContentDir = sTmp;
sTmp += "/";
sTmp += asset.GetClass();
}
// TODO: Add steam id?
V_FixupPathName( pszStartingDir, ARRAYSIZE( pszStartingDir ), sTmp.Get() );
}
}
}
}
pDialog->SetStartDirectoryContext( "itemtest_geometry_browser", pszStartingDir );
if ( bOpenFile )
{
pDialog->AddFilter( "*.obj", "OBJ File (*.obj)", true, "obj" );
pDialog->AddFilter( "*.smd", "Valve SMD File (*.smd)", false, "smd" );
pDialog->AddFilter( "*.dmx", "Valve DMX File (*.dmx)", false, "dmx" );
pDialog->AddFilter( "*.*", "All Files (*.*)", false, "geometry" );
pDialog->SetTitle( "Open Geometry ( OBJ/SMD/DMX ) File", true );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CGeometrySubPanel::OnReadFileFromDisk(
const char *pszFileName,
const char *pszFileFormat,
KeyValues *pContextKeyValues )
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return false;
const int nLODIndex = pContextKeyValues->GetInt( "nLODIndex", -1 );
if ( nLODIndex < 0 )
return false;
char szBuf0[ MAX_PATH ];
char szBuf1[ MAX_PATH ];
// Extract path and save to registry to open browser there next time
{
V_strncpy( szBuf0, pszFileName, sizeof( szBuf0 ) );
V_FixSlashes( szBuf0 );
V_StripFilename( szBuf0 );
_fullpath( szBuf1, szBuf0, ARRAYSIZE( szBuf1 ) );
vgui::system()->SetRegistryString(
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\geometry\\opendir",
szBuf1 );
}
// Get the full path
_fullpath( szBuf1, pszFileName, ARRAYSIZE( szBuf1 ) );
CAsset &asset = pItemUploadWizard->Asset();
for ( int i = 0; i < asset.TargetDMXCount(); ++i )
{
CSmartPtr< CTargetDMX > pTargetDMX = asset.GetTargetDMX( i );
if ( !pTargetDMX )
continue;
if ( !V_strcmp( pTargetDMX->GetInputFile().Get(), szBuf1 ) )
{
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "#duplicate_file_title", "#duplicate_file_text", this );
if ( pMessageBox )
{
pMessageBox->SetSize( 640, 480 );
pMessageBox->SetMinimumSize( 320, 120 );
pMessageBox->DoModal();
}
return false;
}
}
bool bRet = false;
if ( nLODIndex < asset.TargetDMXCount() )
{
bRet = asset.SetTargetDMX( nLODIndex, szBuf1 );
}
else if ( nLODIndex == asset.TargetDMXCount() )
{
const int nCheck = asset.AddTargetDMX( szBuf1 );
Assert( nCheck == nLODIndex );
bRet = ( nCheck >= 0 );
}
UpdateGUI();
return bRet;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CGeometrySubPanel::OnWriteFileToDisk(
const char *pszFileName,
const char *pszFileFormat,
KeyValues *pContextKeyValues )
{
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGeometrySubPanel::OnOpen( int nLodIndex )
{
KeyValues *pContextKeyValues = new KeyValues( "FileOpen", "nLODIndex", nLodIndex );
m_pFileOpenStateMachine->OpenFile( "geometry", pContextKeyValues );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGeometrySubPanel::OnDelete( int nLodIndex )
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return;
CAsset &asset = pItemUploadWizard->Asset();
asset.RemoveTargetDMX( nLodIndex );
UpdateGUI();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGeometrySubPanel::AddGeometry()
{
const int nLodIndex = m_pPanelListPanel->GetItemCount() / 2;
CFmtStr sLabel;
sLabel.sprintf( "#LOD%dLabel", nLodIndex );
vgui::Label *pLabel = new vgui::Label( this, sLabel, sLabel );
pLabel->SetContentAlignment( vgui::Label::a_center );
CLODFileLocationPanel *pFileLocationPanel = new CLODFileLocationPanel( this, nLodIndex );
m_pPanelListPanel->AddItem( pLabel, pFileLocationPanel );
pFileLocationPanel->m_pLabel->AddActionSignalTarget( this );
pFileLocationPanel->m_pButtonBrowse->AddActionSignalTarget( this );
sLabel.sprintf( "lod%d", nLodIndex );
AddStatusPanels( sLabel );
}
//=============================================================================
//
//=============================================================================
class CVmtEntry : public CDualPanelList
{
DECLARE_CLASS_SIMPLE( CVmtEntry, CDualPanelList );
public:
MESSAGE_FUNC_PTR( OnTextChanged, "TextChanged", panel );
MESSAGE_FUNC_PTR( OnOpen, "Open", panel );
CVmtEntry( CMaterialSubPanel *pMaterialSubPanel, const char *pszName, int nVmtIndex )
: CDualPanelList( pMaterialSubPanel, pszName )
, m_pMaterialSubPanel( pMaterialSubPanel )
, m_nVmtIndex( nVmtIndex )
{
{
vgui::Label *pMaterialLabel = new vgui::Label( this, "MaterialLabel", "#MaterialLabel" );
m_pMaterialName = new vgui::Label( this, "MaterialName", "#MaterialName" );
AddItem( pMaterialLabel, m_pMaterialName );
}
{
vgui::Label *pMaterialTypeLabel = new vgui::Label( this, "MaterialTypeLabel", "#MaterialTypeLabel" );
m_pMaterialType = new vgui::ComboBox( this, "MaterialTypeComboBox", 0, false );
m_pMaterialType->AddItem( "#Invalid", new KeyValues( "Invalid" ) );
m_pMaterialType->AddItem( "#Primary", new KeyValues( "Primary" ) );
m_pMaterialType->AddItem( "#Secondary", new KeyValues( "Secondary" ) );
m_pMaterialType->AddItem( "#DuplicateOfPrimary", new KeyValues( "DuplicateOfPrimary" ) );
m_pMaterialType->AddItem( "#DuplicateOfSecondary", new KeyValues( "DuplicateOfSecondary" ) );
m_pMaterialType->AddActionSignalTarget( this );
AddItem( pMaterialTypeLabel, m_pMaterialType );
}
{
vgui::Label *pRedBlueLabel = new vgui::Label( this, "CommonRedBlueLabel", "#CommonRedBlueLabel" );
m_pCommonRedBlue = new vgui::ComboBox( this, "CommonRedBlue", 0, false );
m_pCommonRedBlue->AddItem( "#Common", new KeyValues( "Common" ) );
m_pCommonRedBlue->AddItem( "#RedAndBlue", new KeyValues( "RedAndBlue" ) );
m_pCommonRedBlue->AddActionSignalTarget( this );
m_nCommonRedBlueId = AddItem( pRedBlueLabel, m_pCommonRedBlue );
}
{
vgui::Label *pCommonTextureLabel = new vgui::Label( this, "CommonTextureLabel", "#CommonTextureLabel" );
m_pCommonTextureFileLocation = new CFileLocationPanel( this, 0 );
m_nCommonId = AddItem( pCommonTextureLabel, m_pCommonTextureFileLocation );
}
{
vgui::Label *pRedTextureLabel = new vgui::Label( this, "RedTextureLabel", "#RedTextureLabel" );
m_pRedTextureFileLocation = new CFileLocationPanel( this, 1 );
m_nRedId = AddItem( pRedTextureLabel, m_pRedTextureFileLocation );
}
{
vgui::Label *pBlueTextureLabel = new vgui::Label( this, "BlueTextureLabel", "#BlueTextureLabel" );
m_pBlueTextureFileLocation = new CFileLocationPanel( this, 1 );
m_nBlueId = AddItem( pBlueTextureLabel, m_pBlueTextureFileLocation );
}
{
vgui::Label *pColorAlphaLabel = new vgui::Label( this, "ColorAlphaLabel", "#ColorAlphaLabel" );
m_pColorAlpha = new vgui::ComboBox( this, "ColorAlphaComboBox", 0, false );
m_pColorAlpha->AddItem( "#Nothing", new KeyValues( "None" ) );
m_pColorAlpha->AddItem( "#Transparency", new KeyValues( "Transparency" ) );
m_pColorAlpha->AddItem( "#Paintable", new KeyValues( "Paintable" ) );
m_pColorAlpha->AddItem( "#SpecPhong", new KeyValues( "SpecPhong" ) );
m_pColorAlpha->AddActionSignalTarget( this );
m_nColorAlphaId = AddItem( pColorAlphaLabel, m_pColorAlpha );
}
{
vgui::Label *pNormalMapLabel = new vgui::Label( this, "NormalMapLabel", "#NormalMapLabel" );
m_pNormalTextureFileLocation = new CFileLocationPanel( this, 2 );
m_nNormalId = AddItem( pNormalMapLabel, m_pNormalTextureFileLocation );
}
{
vgui::Label *pNormalAlphaLabel = new vgui::Label( this, "NormalAlphaLabel", "#NormalAlphaLabel" );
m_pNormalAlpha = new vgui::ComboBox( this, "NormalAlphaComboBox", 0, false );
m_pNormalAlpha->AddItem( "#Nothing", new KeyValues( "None" ) );
m_pNormalAlpha->AddItem( "#SpecPhong", new KeyValues( "SpecPhong" ) );
m_pNormalAlpha->AddActionSignalTarget( this );
m_nNormalAlphaId = AddItem( pNormalAlphaLabel, m_pNormalAlpha );
}
m_pCommonRedBlue->ActivateItem( 0 );
SetItemVisible( m_nColorAlphaId, false );
m_pColorAlpha->SilentActivateItem( 0 );
SetItemVisible( m_nNormalAlphaId, false );
m_pNormalAlpha->SilentActivateItem( 0 );
}
int m_nCommonRedBlueId;
int m_nCommonId;
int m_nRedId;
int m_nBlueId;
int m_nColorAlphaId;
int m_nNormalId;
int m_nNormalAlphaId;
vgui::Label *m_pMaterialName;
vgui::ComboBox *m_pMaterialType;
vgui::ComboBox *m_pCommonRedBlue;
CFileLocationPanel *m_pCommonTextureFileLocation;
CFileLocationPanel *m_pRedTextureFileLocation;
CFileLocationPanel *m_pBlueTextureFileLocation;
vgui::ComboBox *m_pColorAlpha;
CFileLocationPanel *m_pNormalTextureFileLocation;
vgui::ComboBox *m_pNormalAlpha;
CMaterialSubPanel *m_pMaterialSubPanel;
int m_nVmtIndex;
void SetMaterialId( const char *pszMaterialName )
{
if ( !m_pMaterialName )
return;
m_pMaterialName->SetText( pszMaterialName );
}
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CVmtEntry::OnTextChanged( vgui::Panel *pPanel )
{
CTargetVMT *pTargetVMT = m_pMaterialSubPanel->GetTargetVMT( m_nVmtIndex );
if ( !pTargetVMT )
return;
bool bUpdate = false;
if ( pPanel == m_pMaterialType )
{
KeyValues *pUserData = m_pMaterialType->GetActiveItemUserData();
if ( pUserData )
{
if ( !V_strcmp( "Invalid", pUserData->GetName() ) )
{
pTargetVMT->SetMaterialType( CTargetVMT::kInvalidMaterialType );
}
else if ( !V_strcmp( "Primary", pUserData->GetName() ) )
{
pTargetVMT->SetMaterialType( CTargetVMT::kPrimary );
}
else if ( !V_strcmp( "Secondary", pUserData->GetName() ) )
{
pTargetVMT->SetMaterialType( CTargetVMT::kSecondary );
}
else if ( !V_strcmp( "DuplicateOfPrimary", pUserData->GetName() ) )
{
pTargetVMT->SetDuplicate( CTargetVMT::kPrimary );
}
else if ( !V_strcmp( "DuplicateOfSecondary", pUserData->GetName() ) )
{
pTargetVMT->SetDuplicate( CTargetVMT::kSecondary );
}
else
{
AssertMsg1( 0, "Unknown Material Type: %s\n", pUserData->GetName() );
}
bUpdate = true;
}
}
else if ( pPanel == m_pCommonRedBlue )
{
KeyValues *pUserData = m_pCommonRedBlue->GetActiveItemUserData();
if ( pUserData )
{
const bool bCommon = !V_strcmp( "Common", pUserData->GetName() );
pTargetVMT->SetColorMapCommon( bCommon );
bUpdate = true;
}
}
else if ( pPanel == m_pColorAlpha )
{
KeyValues *pUserData = m_pColorAlpha->GetActiveItemUserData();
if ( pUserData )
{
const char *pszUserData = pUserData->GetName();
if ( StringHasPrefix( pszUserData, "T" ) )
{
pTargetVMT->SetColorAlphaType( CTargetVMT::kTransparency );
}
else if ( StringHasPrefix( pszUserData, "P" ) )
{
pTargetVMT->SetColorAlphaType( CTargetVMT::kPaintable );
}
else if ( StringHasPrefix( pszUserData, "S" ) )
{
pTargetVMT->SetColorAlphaType( CTargetVMT::kColorSpecPhong );
}
else
{
pTargetVMT->SetColorAlphaType( CTargetVMT::kNoColorAlpha );
}
bUpdate = true;
}
}
else if ( pPanel == m_pNormalAlpha )
{
KeyValues *pUserData = m_pNormalAlpha->GetActiveItemUserData();
if ( pUserData )
{
const char *pszUserData = pUserData->GetName();
if ( StringHasPrefix( pszUserData, "S" ) )
{
pTargetVMT->SetNormalAlphaType( CTargetVMT::kNormalSpecPhong );
}
else
{
pTargetVMT->SetNormalAlphaType( CTargetVMT::kNoNormalAlpha );
}
bUpdate = true;
}
}
if ( bUpdate )
{
InvalidateLayout();
m_pMaterialSubPanel->InvalidateLayout();
m_pMaterialSubPanel->UpdateGUI();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CVmtEntry::OnOpen( vgui::Panel *pPanel )
{
if ( !m_pMaterialSubPanel )
return;
if ( pPanel == m_pCommonTextureFileLocation->m_pButtonBrowse )
{
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kCommon );
}
else if ( pPanel == m_pRedTextureFileLocation->m_pButtonBrowse )
{
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kRed );
}
else if ( pPanel == m_pBlueTextureFileLocation->m_pButtonBrowse )
{
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kBlue );
}
else if ( pPanel == m_pNormalTextureFileLocation->m_pButtonBrowse )
{
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kNormal );
}
}
//=============================================================================
//
//=============================================================================
CMaterialSubPanel::CMaterialSubPanel( vgui::Panel *pParent, const char *pszName, const char *pszNextName )
: BaseClass( pParent, pszName, pszNextName )
{
m_pFileOpenStateMachine = new vgui::FileOpenStateMachine( this, this );
m_pFileOpenStateMachine->AddActionSignalTarget( this );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSubPanel::InvalidateLayout()
{
BaseClass::InvalidateLayout();
m_pPanelListPanel->InvalidateLayout();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSubPanel::UpdateGUI()
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return;
CAsset &asset = pItemUploadWizard->Asset();
int nMaterialCount = m_pPanelListPanel->GetItemCount() / 2;
CFmtStr sTmp;
// Add new gui elements & update existing
for ( int i = 0; i < asset.GetTargetVMTCount(); ++i )
{
if ( i >= nMaterialCount )
{
AddMaterial();
nMaterialCount = m_pPanelListPanel->GetItemCount() / 2;
}
if ( i >= nMaterialCount )
break; // unrecoverable error
CTargetVMT *pTargetVmt = asset.GetTargetVMT( i );
Assert( pTargetVmt );
if ( !pTargetVmt )
continue;
CVmtEntry *pVmtEntry = dynamic_cast< CVmtEntry * >( m_pPanelListPanel->GetItemPanel( i * 2 ) );
if ( !pVmtEntry )
continue;
CUtlString sMaterialId;
pTargetVmt->GetMaterialId( sMaterialId );
pVmtEntry->SetMaterialId( sMaterialId.Get() );
const bool bCommon = pTargetVmt->GetColorMapCommon();
pVmtEntry->m_pCommonRedBlue->SilentActivateItemByRow( bCommon ? 0 : 1 );
bool bVisible = true;
if ( pTargetVmt->GetDuplicate() )
{
bVisible = false;
switch ( pTargetVmt->GetMaterialType() )
{
case CTargetVMT::kInvalidMaterialType:
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 0 );
break;
case CTargetVMT::kPrimary:
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 3 );
break;
case CTargetVMT::kSecondary:
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 4 );
break;
default:
pVmtEntry->m_pMaterialType->ActivateItem( 0 );
break;
}
}
else
{
switch ( pTargetVmt->GetMaterialType() )
{
case CTargetVMT::kInvalidMaterialType:
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 0 );
break;
case CTargetVMT::kPrimary:
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 1 );
break;
case CTargetVMT::kSecondary:
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 2 );
break;
default:
pVmtEntry->m_pMaterialType->ActivateItem( 0 );
break;
}
}
pVmtEntry->SetItemVisible( pVmtEntry->m_nCommonRedBlueId, bVisible );
pVmtEntry->SetItemVisible( pVmtEntry->m_nCommonId, bVisible && bCommon );
pVmtEntry->SetItemVisible( pVmtEntry->m_nRedId, bVisible && !bCommon );
pVmtEntry->SetItemVisible( pVmtEntry->m_nBlueId, bVisible && !bCommon );
pVmtEntry->SetItemVisible( pVmtEntry->m_nNormalId, bVisible );
bool bColorVisible = false;
CSmartPtr< CTargetVTF > pCommonTargetVTF = pTargetVmt->GetCommonTargetVTF();
if ( pCommonTargetVTF.IsValid() )
{
pVmtEntry->m_pCommonTextureFileLocation->m_pLabel->SetText( pCommonTargetVTF->GetInputFile() );
if ( pTargetVmt->GetColorMapCommon() && pCommonTargetVTF->HasAlpha() )
{
bColorVisible = true;
}
}
else
{
pVmtEntry->m_pCommonTextureFileLocation->m_pLabel->SetText( "" );
bColorVisible = false;
}
switch ( pTargetVmt->GetColorAlphaType() )
{
case CTargetVMT::kNoColorAlpha:
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kNoColorAlpha );
break;
case CTargetVMT::kTransparency:
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kTransparency );
break;
case CTargetVMT::kPaintable:
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kPaintable );
break;
case CTargetVMT::kColorSpecPhong:
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kColorSpecPhong );
break;
default:
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kNoColorAlpha );
break;
}
CSmartPtr< CTargetVTF > pRedTargetVTF = pTargetVmt->GetRedTargetVTF();
CSmartPtr< CTargetVTF > pBlueTargetVTF = pTargetVmt->GetBlueTargetVTF();
if ( pRedTargetVTF.IsValid() )
{
pVmtEntry->m_pRedTextureFileLocation->m_pLabel->SetText( pRedTargetVTF->GetInputFile() );
}
else
{
pVmtEntry->m_pRedTextureFileLocation->m_pLabel->SetText( "" );
}
if ( pBlueTargetVTF.IsValid() )
{
pVmtEntry->m_pBlueTextureFileLocation->m_pLabel->SetText( pBlueTargetVTF->GetInputFile() );
}
else
{
pVmtEntry->m_pBlueTextureFileLocation->m_pLabel->SetText( "" );
}
if ( !pTargetVmt->GetColorMapCommon() && pRedTargetVTF.IsValid() && pBlueTargetVTF.IsValid() )
{
if ( pRedTargetVTF->HasAlpha() && pBlueTargetVTF->HasAlpha() )
{
bColorVisible = true;
}
}
pVmtEntry->SetItemVisible( pVmtEntry->m_nColorAlphaId, bVisible && bColorVisible );
bool bNormalVisible = false;
CSmartPtr< CTargetVTF > pNormalTargetVTF = pTargetVmt->GetNormalTargetVTF();
if ( pNormalTargetVTF.IsValid() )
{
pVmtEntry->m_pNormalTextureFileLocation->m_pLabel->SetText( pNormalTargetVTF->GetInputFile() );
if ( pNormalTargetVTF->HasAlpha() )
{
bNormalVisible = true;
}
}
switch ( pTargetVmt->GetNormalAlphaType() )
{
case CTargetVMT::kNoNormalAlpha:
pVmtEntry->m_pNormalAlpha->SilentActivateItemByRow( CTargetVMT::kNoNormalAlpha );
break;
case CTargetVMT::kNormalSpecPhong:
pVmtEntry->m_pNormalAlpha->SilentActivateItemByRow( CTargetVMT::kNormalSpecPhong );
break;
default:
pVmtEntry->m_pNormalAlpha->SilentActivateItemByRow( CTargetVMT::kNoNormalAlpha );
break;
}
pVmtEntry->SetItemVisible( pVmtEntry->m_nNormalAlphaId, bVisible && bNormalVisible );
pVmtEntry->InvalidateLayout();
}
// Remove superfluous
while ( ( m_pPanelListPanel->GetItemCount() / 2 ) > asset.GetTargetVMTCount() )
{
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
}
InvalidateLayout();
UpdateStatus();
}
//-----------------------------------------------------------------------------
// TODO: Set status
//-----------------------------------------------------------------------------
bool CMaterialSubPanel::UpdateStatus()
{
CFmtStr sTmp;
int nIndex = 0;
for ( int i = 0; i < m_pPanelListPanel->GetItemCount(); i += 2, ++nIndex )
{
CVmtEntry *pVmtEntry = dynamic_cast< CVmtEntry * >( m_pPanelListPanel->GetItemPanel( i ) );
if ( !pVmtEntry )
continue;
CTargetVMT *pTargetVMT = GetTargetVMT( pVmtEntry->m_nVmtIndex );
Assert( pTargetVMT );
if ( !pTargetVMT )
continue;
sTmp.sprintf( "VMT%d", nIndex );
CUtlString sMsg;
if ( pTargetVMT->IsOk( sMsg ) )
{
SetStatus( true, sTmp );
continue;
}
if ( sMsg.IsEmpty() )
{
SetStatus( false, sTmp, "VMT is not valid\n" );
}
else
{
SetStatus( false, sTmp, sMsg.Get() );
}
}
bool bValid = BaseClass::UpdateStatus();
return bValid;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSubPanel::SetupFileOpenDialog(
vgui::FileOpenDialog *pDialog,
bool bOpenFile,
const char *pszFileName,
KeyValues *pContextKeyValues )
{
char pszStartingDir[ MAX_PATH ];
if ( !vgui::system()->GetRegistryString(
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\texture\\opendir",
pszStartingDir, sizeof( pszStartingDir ) ) )
{
_getcwd( pszStartingDir, ARRAYSIZE( pszStartingDir ));
CUtlString sVMod;
CUtlString sContentDir;
if ( CItemUpload::GetVMod( sVMod ) && !sVMod.IsEmpty() && CItemUpload::GetContentDir( sContentDir ) && !sContentDir.IsEmpty() && CItemUpload::FileExists( sContentDir.Get() ) )
{
sContentDir += "/";
sContentDir += sVMod;
sContentDir += "/materialsrc/models";
CUtlString sTmp = sContentDir;
sTmp += "/player";
if ( CItemUpload::FileExists( sTmp.Get() ) )
{
sContentDir = sTmp;
sTmp += "/items";
if ( CItemUpload::FileExists( sTmp.Get() ) )
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( pItemUploadWizard )
{
CAsset &asset = pItemUploadWizard->Asset();
sContentDir = sTmp;
sTmp += "/";
sTmp += asset.GetClass();
}
// TODO: Add steam id?
V_FixupPathName( pszStartingDir, ARRAYSIZE( pszStartingDir ), sTmp.Get() );
}
}
}
}
pDialog->SetStartDirectoryContext( "itemtest_texture_browser", pszStartingDir );
// TODO: Remember the mask the user likes
if ( bOpenFile )
{
pDialog->AddFilter( "*.tga", "Targa TrueVision File (*.tga)", true, "tga" );
pDialog->AddFilter( "*.psd", "Photoshop Document (*.psd)", false, "psd" );
pDialog->SetTitle( "Open Texture File", true );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CMaterialSubPanel::OnReadFileFromDisk(
const char *pszFileName,
const char *pszFileFormat,
KeyValues *pContextKeyValues )
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return false;
char szBuf0[ MAX_PATH ];
char szBuf1[ MAX_PATH ];
// Extract path and save to registry to open browser there next time
{
V_strncpy( szBuf0, pszFileName, sizeof( szBuf0 ) );
V_FixSlashes( szBuf0 );
V_StripFilename( szBuf0 );
_fullpath( szBuf1, szBuf0, ARRAYSIZE( szBuf1 ) );
vgui::system()->SetRegistryString(
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\texture\\opendir",
szBuf1 );
}
// Get the full path
_fullpath( szBuf1, pszFileName, ARRAYSIZE( szBuf1 ) );
CAsset &asset = pItemUploadWizard->Asset();
CVmtEntry *pVmtEntry = reinterpret_cast< CVmtEntry * >( pContextKeyValues->GetPtr( "pVmtEntry" ) );
const Browse_t nBrowseType = static_cast< Browse_t >( pContextKeyValues->GetInt( "nBrowseType" ) );
bool bReturnVal = false;
for ( int i = 0; i < m_pPanelListPanel->GetItemCount(); i += 2 )
{
if ( pVmtEntry == dynamic_cast< CVmtEntry * >( m_pPanelListPanel->GetItemPanel( i ) ) )
{
const int nVmtIndex = i / 2;
CTargetVMT *pTargetVMT = asset.GetTargetVMT( nVmtIndex );
if ( pTargetVMT )
{
bReturnVal = true;
switch( nBrowseType )
{
case CMaterialSubPanel::kCommon:
pTargetVMT->SetCommonTargetVTF( szBuf1 );
break;
case CMaterialSubPanel::kRed:
pTargetVMT->SetRedTargetVTF( szBuf1 );
break;
case CMaterialSubPanel::kBlue:
pTargetVMT->SetBlueTargetVTF( szBuf1 );
break;
case CMaterialSubPanel::kNormal:
pTargetVMT->SetNormalTargetVTF( szBuf1 );
break;
default:
bReturnVal = false;
break;
}
}
break;
}
}
UpdateGUI();
return bReturnVal;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CMaterialSubPanel::OnWriteFileToDisk(
const char *pszFileName,
const char *pszFileFormat,
KeyValues *pContextKeyValues )
{
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSubPanel::Browse( CVmtEntry *pVmtEntry, Browse_t nBrowseType )
{
if ( !pVmtEntry )
return;
KeyValues *pContextKeyValues = new KeyValues( "FileOpen", "nBrowseType", nBrowseType );
pContextKeyValues->SetPtr( "pVmtEntry", pVmtEntry );
m_pFileOpenStateMachine->OpenFile( "geometry", pContextKeyValues );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CTargetVMT *CMaterialSubPanel::GetTargetVMT( int nTargetVMTIndex )
{
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
if ( !pItemUploadWizard )
return NULL;
return pItemUploadWizard->Asset().GetTargetVMT( nTargetVMTIndex );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSubPanel::AddMaterial()
{
const int nIndex = m_pPanelListPanel->GetItemCount() / 2;
CFmtStr sLabel;
sLabel.sprintf( "#VMT%dLabel", nIndex );
vgui::Label *pLabel = new vgui::Label( this, sLabel, sLabel );
pLabel->SetContentAlignment( vgui::Label::a_center );
sLabel.sprintf( "#VMT%dLabel2", nIndex );
CVmtEntry *pVmtEntry = new CVmtEntry( this, sLabel, nIndex );
pVmtEntry->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_RIGHT, 0, 0, 0, 0 );
m_pPanelListPanel->AddItem( pLabel, pVmtEntry );
sLabel.sprintf( "vmt%d", nIndex );
AddStatusPanels( sLabel );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CItemUploadWizard::CItemUploadWizard(
vgui::Panel *pParent,
const char *pszName )
: BaseClass( pParent, pszName )
{
SetSize( 1024, 768 );
SetMinimumSize( 640, 480 );
vgui::WizardSubPanel *pSubPanel = NULL;
vgui::DHANDLE< vgui::WizardSubPanel > hSubPanel;
pSubPanel = new CGlobalSubPanel( this, "global", "geometry" );
pSubPanel->SetVisible( false );
hSubPanel = pSubPanel;
m_hSubPanelList.AddToTail( hSubPanel );
pSubPanel = new CGeometrySubPanel( this, "geometry", "texture" );
pSubPanel->SetVisible( false );
hSubPanel = pSubPanel;
m_hSubPanelList.AddToTail( hSubPanel );
pSubPanel = new CMaterialSubPanel( this, "texture", "final" );
pSubPanel->SetVisible( false );
hSubPanel = pSubPanel;
m_hSubPanelList.AddToTail( hSubPanel );
m_pFinalSubPanel = new CFinalSubPanel( this, "final", NULL );
pSubPanel = m_pFinalSubPanel;
pSubPanel->SetVisible( false );
hSubPanel = pSubPanel;
m_hSubPanelList.AddToTail( hSubPanel );
Run();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CItemUploadWizard::~CItemUploadWizard()
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadWizard::Run()
{
vgui::WizardSubPanel *pStartPanel = dynamic_cast< vgui::WizardSubPanel * >( FindChildByName( "global" ) );
if ( !pStartPanel )
{
Error( "Missing CItemUploadWizard global Panel" );
}
BaseClass::Run( pStartPanel );
MoveToCenterOfScreen();
Activate();
vgui::input()->SetAppModalSurface( GetVPanel() );
CGlobalSubPanel *pGlobalSubPanel = dynamic_cast< CGlobalSubPanel * >( pStartPanel );
if ( pGlobalSubPanel )
{
pGlobalSubPanel->UpdateStatus();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadWizard::UpdateGUI()
{
for ( int i = 0; i < m_hSubPanelList.Count(); ++i )
{
CItemUploadSubPanel *pSubPanel = dynamic_cast< CItemUploadSubPanel * >( m_hSubPanelList.Element( i ).Get() );
if ( !pSubPanel )
continue;
pSubPanel->UpdateGUI();
}
CItemUploadSubPanel *pItemUploadSubPanel = dynamic_cast< CItemUploadSubPanel * >( GetCurrentSubPanel() );
if ( pItemUploadSubPanel )
{
pItemUploadSubPanel->UpdateStatus();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemUploadWizard::OnFinishButton()
{
m_pFinalSubPanel->OnZip();
}