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/vgui2/matsys_controls/mdlpicker.cpp

1742 lines
54 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "matsys_controls/mdlpicker.h"
#include "tier1/KeyValues.h"
#include "tier1/utldict.h"
#include "filesystem.h"
#include "studio.h"
#include "matsys_controls/matsyscontrols.h"
#include "matsys_controls/mdlpanel.h"
#include "vgui_controls/Splitter.h"
#include "vgui_controls/ComboBox.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/PropertySheet.h"
#include "vgui_controls/MessageBox.h"
#include "vgui_controls/PropertyPage.h"
#include "vgui_controls/CheckButton.h"
#include "vgui_controls/DirectorySelectDialog.h"
#include "vgui/IVGui.h"
#include "vgui/IInput.h"
#include "vgui/ISurface.h"
#include "vgui/Cursor.h"
#include "matsys_controls/assetpicker.h"
#include "matsys_controls/colorpickerpanel.h"
#include "dmxloader/dmxloader.h"
#include "tier1/utlbuffer.h"
#include "bitmap/tgawriter.h"
#include "tier3/tier3.h"
#include "istudiorender.h"
#include "../vgui2/src/VPanel.h"
#include "tier2/p4helpers.h"
#include "ivtex.h"
#include "bitmap/tgaloader.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace vgui;
static bool SaveTgaAndAddToP4( unsigned char *pImage, ImageFormat imageFormat, int Width, int Height, const char *szDestFilename )
{
// allocate a buffer to write the tga into
int iMaxTGASize = 1024 + (Width * Height * 4);
void *pTGA = malloc( iMaxTGASize );
CUtlBuffer buffer( pTGA, iMaxTGASize );
if( !TGAWriter::WriteToBuffer( pImage, buffer, Width, Height, imageFormat, IMAGE_FORMAT_BGRA8888 ) )
{
Error( "Couldn't write bitmap data snapshot.\n" );
return false;
}
CP4AutoEditAddFile autop4( szDestFilename );
// async write to disk (this will take ownership of the memory)
char szDirName[ _MAX_PATH ];
strcpy( szDirName, szDestFilename );
V_StripFilename( szDirName );
g_pFullFileSystem->CreateDirHierarchy( szDirName, "" );
g_pFullFileSystem->AsyncWrite( szDestFilename, buffer.Base(), buffer.TellPut(), true );
return true;
}
//-----------------------------------------------------------------------------
//
// MDL Picker
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Sort by MDL name
//-----------------------------------------------------------------------------
static int __cdecl MDLBrowserSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
{
const char *string1 = item1.kv->GetString("mdl");
const char *string2 = item2.kv->GetString("mdl");
return stricmp( string1, string2 );
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CMDLPicker::CMDLPicker( vgui::Panel *pParent, int nFlags ) :
BaseClass( pParent, "MDL Files", "mdl", "models", "mdlName" )
{
for( int i = 0; i < MAX_SELECTED_MODELS; i++ )
{
m_hSelectedMDL[ i ] = MDLHANDLE_INVALID;
}
m_nFlags = nFlags; // remember what we show and what not
m_pRenderPage = NULL;
m_pSequencesPage = NULL;
m_pActivitiesPage = NULL;
m_pSkinsPage = NULL;
m_pInfoPage = NULL;
m_pScreenCapsPage = NULL;
m_pSequencesList = NULL;
m_pActivitiesList = NULL;
m_hDirectorySelectDialog = NULL;
// Horizontal splitter for mdls
m_pFileBrowserSplitter = new Splitter( this, "FileBrowserSplitter", SPLITTER_MODE_VERTICAL, 1 );
float flFractions[] = { 0.33f, 0.67f };
m_pFileBrowserSplitter->RespaceSplitters( flFractions );
vgui::Panel *pSplitterLeftSide = m_pFileBrowserSplitter->GetChild( 0 );
vgui::Panel *pSplitterRightSide = m_pFileBrowserSplitter->GetChild( 1 );
// Standard browser controls
pSplitterLeftSide->RequestFocus();
CreateStandardControls( pSplitterLeftSide, false );
// property sheet - revisions, changes, etc.
m_pPreviewSplitter = new Splitter( pSplitterRightSide, "PreviewSplitter", SPLITTER_MODE_HORIZONTAL, 1 );
vgui::Panel *pSplitterTopSide = m_pPreviewSplitter->GetChild( 0 );
vgui::Panel *pSplitterBottomSide = m_pPreviewSplitter->GetChild( 1 );
// MDL preview
m_pMDLPreview = new CMDLPanel( pSplitterTopSide, "MDLPreview" );
SetSkipChildDuringPainting( m_pMDLPreview );
m_pViewsSheet = new vgui::PropertySheet( pSplitterBottomSide, "ViewsSheet" );
m_pViewsSheet->AddActionSignalTarget( this );
// now add wanted features
if ( nFlags & PAGE_RENDER )
{
m_pRenderPage = new vgui::PropertyPage( m_pViewsSheet, "RenderPage" );
m_pRenderPage->AddActionSignalTarget( this );
m_pRenderPage->LoadControlSettingsAndUserConfig( "resource/mdlpickerrender.res" );
RefreshRenderSettings();
// ground
Button *pSelectProbe = (Button*)m_pRenderPage->FindChildByName( "ChooseLightProbe" );
pSelectProbe->AddActionSignalTarget( this );
}
if ( nFlags & PAGE_SEQUENCES )
{
m_pSequencesPage = new vgui::PropertyPage( m_pViewsSheet, "SequencesPage" );
m_pSequencesList = new vgui::ListPanel( m_pSequencesPage, "SequencesList" );
m_pSequencesList->AddColumnHeader( 0, "sequence", "sequence", 52, 0 );
m_pSequencesList->AddActionSignalTarget( this );
m_pSequencesList->SetSelectIndividualCells( true );
m_pSequencesList->SetEmptyListText("No .MDL file currently selected.");
m_pSequencesList->SetDragEnabled( true );
m_pSequencesList->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_DOWNANDRIGHT, 6, 6, -6, -6 );
}
if ( nFlags & PAGE_ACTIVITIES )
{
m_pActivitiesPage = new vgui::PropertyPage( m_pViewsSheet, "ActivitiesPage" );
m_pActivitiesList = new vgui::ListPanel( m_pActivitiesPage, "ActivitiesList" );
m_pActivitiesList->AddColumnHeader( 0, "activity", "activity", 52, 0 );
m_pActivitiesList->AddActionSignalTarget( this );
m_pActivitiesList->SetSelectIndividualCells( true );
m_pActivitiesList->SetEmptyListText( "No .MDL file currently selected." );
m_pActivitiesList->SetDragEnabled( true );
m_pActivitiesList->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_DOWNANDRIGHT, 6, 6, -6, -6 );
}
if ( nFlags & PAGE_SKINS )
{
m_pSkinsPage = new vgui::PropertyPage( m_pViewsSheet, "SkinsPage" );
m_pSkinsList = new vgui::ListPanel( m_pSkinsPage, "SkinsList" );
m_pSkinsList->AddColumnHeader( 0, "skin", "skin", 52, 0 );
m_pSkinsList->AddActionSignalTarget( this );
m_pSkinsList->SetSelectIndividualCells( true );
m_pSkinsList->SetEmptyListText( "No .MDL file currently selected." );
m_pSkinsList->SetDragEnabled( true );
m_pSkinsList->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_DOWNANDRIGHT, 6, 6, -6, -6 );
}
if ( nFlags & PAGE_INFO )
{
m_pInfoPage = new vgui::PropertyPage( m_pViewsSheet, "InfoPage" );
m_pInfoPage->AddActionSignalTarget( this );
m_pInfoPage->LoadControlSettingsAndUserConfig( "resource/mdlpickerinfo.res" );
CheckButton * pTempCheck = (CheckButton *)m_pInfoPage->FindChildByName( "PhysicsObject" );
pTempCheck->SetDisabledFgColor1( pTempCheck->GetFgColor());
pTempCheck->SetDisabledFgColor2( pTempCheck->GetFgColor());
pTempCheck = (CheckButton *)m_pInfoPage->FindChildByName( "StaticObject" );
pTempCheck->SetDisabledFgColor1( pTempCheck->GetFgColor());
pTempCheck->SetDisabledFgColor2( pTempCheck->GetFgColor());
pTempCheck = (CheckButton *)m_pInfoPage->FindChildByName( "DynamicObject" );
pTempCheck->SetDisabledFgColor1( pTempCheck->GetFgColor());
pTempCheck->SetDisabledFgColor2( pTempCheck->GetFgColor());
m_pPropDataList = new vgui::ListPanel( m_pInfoPage, "PropData" );
m_pPropDataList->AddColumnHeader( 0, "key", "key", 250, ListPanel::COLUMN_FIXEDSIZE );
m_pPropDataList->AddColumnHeader( 1, "value", "value", 52, 0 );
m_pPropDataList->AddActionSignalTarget( this );
m_pPropDataList->SetSelectIndividualCells( false );
m_pPropDataList->SetEmptyListText( "No prop_data available." );
m_pPropDataList->SetDragEnabled( true );
m_pPropDataList->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_DOWNANDRIGHT, 6, 72, -6, -6 );
RefreshRenderSettings();
}
if ( nFlags & PAGE_SCREEN_CAPS )
{
m_pScreenCapsPage = new vgui::PropertyPage( m_pViewsSheet, "ScreenCapsPage" );
// not sure why we have to do this for the color picker
CColorPickerButton *m_pBackgroundColor;
m_pBackgroundColor = new CColorPickerButton( m_pScreenCapsPage, "BackgroundColor", this );
m_pScreenCapsPage->LoadControlSettingsAndUserConfig( "resource/mdlpickerscreencaps.res" );
TextEntry *pTempValue;
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "WidthText" );
pTempValue->SetText( "256" );
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "HeightText" );
pTempValue->SetText( "256" );
// not sure why this doesn't work
// m_pBackgroundColor = ( CColorPickerButton * )m_pScreenCapsPage->FindChildByName( "BackgroundColor" );
m_pBackgroundColor->SetColor( 255, 0, 0, 255 );
Label *m_pOutputDirectory;
m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->SetText( "c:\\" );
Button *pSelectProbe = ( Button * )m_pScreenCapsPage->FindChildByName( "Capture" );
pSelectProbe->AddActionSignalTarget( this );
pSelectProbe = ( Button * )m_pScreenCapsPage->FindChildByName( "OutputDirectorySelect" );
pSelectProbe->AddActionSignalTarget( this );
pSelectProbe = ( Button * )m_pScreenCapsPage->FindChildByName( "SaveCaps" );
pSelectProbe->AddActionSignalTarget( this );
pSelectProbe = ( Button * )m_pScreenCapsPage->FindChildByName( "RestoreCaps" );
pSelectProbe->AddActionSignalTarget( this );
pSelectProbe = ( Button * )m_pScreenCapsPage->FindChildByName( "GenerateBackpackIcons" );
pSelectProbe->AddActionSignalTarget( this );
}
// Load layout settings; has to happen before pinning occurs in code
LoadControlSettingsAndUserConfig( "resource/mdlpicker.res" );
// Pages must be added after control settings are set up
if ( m_pRenderPage )
{
m_pViewsSheet->AddPage( m_pRenderPage, "Render" );
}
if ( m_pSequencesPage )
{
m_pViewsSheet->AddPage( m_pSequencesPage, "Sequences" );
}
if ( m_pActivitiesPage )
{
m_pViewsSheet->AddPage( m_pActivitiesPage, "Activities" );
}
if ( m_pSkinsPage )
{
m_pViewsSheet->AddPage( m_pSkinsPage, "Skins" );
}
if ( m_pInfoPage )
{
m_pViewsSheet->AddPage( m_pInfoPage, "Info" );
}
if ( m_pScreenCapsPage )
{
m_pViewsSheet->AddPage( m_pScreenCapsPage, "Screen Caps" );
}
}
void CMDLPicker::RefreshRenderSettings()
{
vgui::CheckButton *pToggle;
if ( !m_pRenderPage )
return;
// ground
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName("NoGround");
pToggle->AddActionSignalTarget( this );
m_pMDLPreview->SetGroundGrid( !pToggle->IsSelected() );
// collision
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName("Collision");
pToggle->AddActionSignalTarget( this );
m_pMDLPreview->SetCollsionModel( pToggle->IsSelected() );
// wireframe
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName("Wireframe");
pToggle->AddActionSignalTarget( this );
m_pMDLPreview->SetWireFrame( pToggle->IsSelected() );
// lockview
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName("LockView");
pToggle->AddActionSignalTarget( this );
m_pMDLPreview->SetLockView( pToggle->IsSelected() );
// look at camera
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName("LookAtCamera");
pToggle->AddActionSignalTarget( this );
m_pMDLPreview->SetLookAtCamera( pToggle->IsSelected() );
// thumbnail safe zone
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName("ThumbnailSafeZone");
pToggle->AddActionSignalTarget( this );
m_pMDLPreview->SetThumbnailSafeZone( pToggle->IsSelected() );
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CMDLPicker::~CMDLPicker()
{
}
//-----------------------------------------------------------------------------
// Performs layout
//-----------------------------------------------------------------------------
void CMDLPicker::PerformLayout()
{
// NOTE: This call should cause auto-resize to occur
// which should fix up the width of the panels
BaseClass::PerformLayout();
int w, h;
GetSize( w, h );
// Layout the mdl splitter
m_pFileBrowserSplitter->SetBounds( 0, 0, w, h );
}
//-----------------------------------------------------------------------------
// Buttons on various pages
//-----------------------------------------------------------------------------
void CMDLPicker::OnAssetSelected( KeyValues *pParams )
{
const char *pAsset = pParams->GetString( "asset" );
char pProbeBuf[MAX_PATH];
Q_snprintf( pProbeBuf, sizeof(pProbeBuf), "materials/lightprobes/%s", pAsset );
BeginDMXContext();
CDmxElement *pLightProbe = NULL;
bool bOk = UnserializeDMX( pProbeBuf, "GAME", true, &pLightProbe );
if ( !pLightProbe || !bOk )
{
char pBuf[1024];
Q_snprintf( pBuf, sizeof(pBuf), "Error loading lightprobe file '%s'!\n", pProbeBuf );
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "Error Loading File!\n", pBuf, GetParent() );
pMessageBox->DoModal( );
EndDMXContext( true );
return;
}
m_pMDLPreview->SetLightProbe( pLightProbe );
EndDMXContext( true );
}
//-----------------------------------------------------------------------------
// Buttons on various pages
//-----------------------------------------------------------------------------
void CMDLPicker::OnCommand( const char *pCommand )
{
if ( !Q_stricmp( pCommand, "ChooseLightProbe" ) )
{
CAssetPickerFrame *pPicker = new CAssetPickerFrame( this, "Select Light Probe (.prb) File",
"Light Probe", "prb", "materials/lightprobes", "lightprobe" );
pPicker->DoModal();
return;
}
else if ( !Q_stricmp( pCommand, "OutputDirectorySelect" ) )
{
if ( !m_hDirectorySelectDialog.Get() )
{
m_hDirectorySelectDialog = new DirectorySelectDialog( this, "Choose Screen Caps output folder" );
}
Label *m_pOutputDirectory;
char temp[ MAX_PATH ];
m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->GetText( temp, sizeof( temp ) );
m_hDirectorySelectDialog->MakeReadyForUse();
m_hDirectorySelectDialog->SetStartDirectory( temp );
m_hDirectorySelectDialog->DoModal();
return;
}
else if ( !Q_stricmp( pCommand, "Capture" ) )
{
CaptureScreenCaps();
return;
}
else if ( !Q_stricmp( pCommand, "GenerateBackpackIcons" ) )
{
// shut off the ground grid
vgui::CheckButton *pGroundToggle = (vgui::CheckButton *)m_pRenderPage->FindChildByName( "NoGround" );
bool bOriginalGridState = pGroundToggle->IsSelected();
vgui::CheckButton *pSafeZoneToggle = (vgui::CheckButton *)m_pRenderPage->FindChildByName( "ThumbnailSafeZone" );
bool bOriginalSafeZoneState = pSafeZoneToggle->IsSelected();
m_pMDLPreview->SetGroundGrid( false );
m_pMDLPreview->SetThumbnailSafeZone( false );
// make the icons
GenerateBackpackIcons();
// return the ground grid to its original state
m_pMDLPreview->SetGroundGrid( !bOriginalGridState );
m_pMDLPreview->SetThumbnailSafeZone( bOriginalSafeZoneState );
return;
}
else if ( !Q_stricmp( pCommand, "SaveCaps" ) )
{
SaveCaps( NULL );
return;
}
else if ( !Q_stricmp( pCommand, "RestoreCaps" ) )
{
if ( input()->IsKeyDown( KEY_RCONTROL ) || input()->IsKeyDown( KEY_LCONTROL ) )
{
int nCount = m_AssetList.Count();
for ( int i = 0; i < nCount; ++i )
{
if ( m_pAssetBrowser->IsItemVisible( m_AssetList[ i ].m_nItemId ) &&
m_pAssetBrowser->IsItemSelected( m_AssetList[ i ].m_nItemId ) )
{
KeyValues *pItemKeyValues = m_pAssetBrowser->GetItem( m_AssetList[ i ].m_nItemId );
const char *pSelectedAsset = pItemKeyValues->GetString( "asset" );
char szBathPath[ _MAX_PATH ];
Label *m_pOutputDirectory;
m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->GetText( szBathPath, sizeof( szBathPath ) );
char szPathedFileName[ _MAX_PATH ];
sprintf( szPathedFileName, "%s%s", szBathPath, pSelectedAsset );
Label *m_pResults = ( Label * )m_pScreenCapsPage->FindChildByName( "CaptureResults" );
if ( RestoreCaps( szPathedFileName ) )
{
m_pResults->SetText( "Prefs Restored" );
}
else
{
m_pResults->SetText( "Prefs NOT FOUND" );
}
break;
}
}
}
else
{
RestoreCaps( NULL );
}
return;
}
BaseClass::OnCommand( pCommand );
}
//-----------------------------------------------------------------------------
// Handles the directory selection for screen caps
//-----------------------------------------------------------------------------
void CMDLPicker::OnDirectorySelected( char const *dir )
{
if ( m_hDirectorySelectDialog != 0 )
{
m_hDirectorySelectDialog->MarkForDeletion();
}
Label *m_pOutputDirectory;
m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->SetText( dir );
}
//-----------------------------------------------------------------------------
// Screen captures the specific model and writes out a .tga. Assumes the MDLPreview
// panel has been properly adjusted to 0,0 in screen space and that width / height
// have been set.
//-----------------------------------------------------------------------------
const char *CMDLPicker::CaptureModel( int nModIndex, const char *AssetName, const char *OutputPath, int Width, int Height, Color BackgroundColor, bool bSelectedOnly )
{
char pBuf[ MAX_PATH ];
Q_snprintf( pBuf, sizeof( pBuf ), "%s\\%s\\%s", GetModPath( nModIndex ), m_pAssetSubDir, AssetName );
Q_FixSlashes( pBuf );
if ( !bSelectedOnly )
{
SelectMDL( pBuf, false, -1 );
}
CMatRenderContextPtr pRenderContext( materials );
g_pMaterialSystem->BeginFrame( 0 );
g_pStudioRender->BeginFrame();
// pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
// pRenderContext->ClearBuffers( true, true );
Color NewPanelColor;
NewPanelColor.SetColor( 0, 0, 0, 0 );
m_pMDLPreview->SetBackgroundColor( NewPanelColor );
g_pVGuiSurface->PaintTraverseEx( m_pMDLPreview->GetVPanel(), false );
g_pStudioRender->EndFrame();
g_pMaterialSystem->EndFrame( );
// get the data from the backbuffer and save to disk
// bitmap bits
unsigned char *pImageBlack = ( unsigned char * )malloc( Width * 4 * Height );
// Get Bits from the material system
pRenderContext->ReadPixels( 0, 0, Width, Height, pImageBlack, IMAGE_FORMAT_BGRA8888 );
g_pMaterialSystem->BeginFrame( 0 );
g_pStudioRender->BeginFrame();
// pRenderContext->ClearColor4ub( 255, 255, 255, 0 );
// pRenderContext->ClearBuffers( true, true );
NewPanelColor.SetColor( 255, 255, 255, 0 );
m_pMDLPreview->SetBackgroundColor( NewPanelColor );
g_pVGuiSurface->PaintTraverseEx( m_pMDLPreview->GetVPanel(), false );
g_pStudioRender->EndFrame();
g_pMaterialSystem->EndFrame( );
// get the data from the backbuffer and save to disk
// bitmap bits
unsigned char *pImageWhite = ( unsigned char * )malloc( Width * 4 * Height );
// Get Bits from the material system
pRenderContext->ReadPixels( 0, 0, Width, Height, pImageWhite, IMAGE_FORMAT_BGRA8888 );
unsigned char *pBlackPos = pImageBlack;
unsigned char *pWhitePos = pImageWhite;
for( int y = 0; y < Height; y++ )
{
for( int x = 0; x < Width; x++, pBlackPos += 4, pWhitePos += 4 )
{
if ( ( *( pBlackPos + 0 ) ) != ( *( pWhitePos + 0 ) ) || // blue
( *( pBlackPos + 1 ) ) != ( *( pWhitePos + 1 ) ) || // green
( *( pBlackPos + 2 ) ) != ( *( pWhitePos + 2 ) ) ) // red
{
unsigned char nBlueDiff = ( *( pBlackPos + 0 ) );
unsigned char nGreenDiff = ( *( pBlackPos + 1 ) );
unsigned char nRedDiff = ( *( pBlackPos + 2 ) );
unsigned char nMax = nBlueDiff;
if ( nGreenDiff > nMax )
{
nMax = nGreenDiff;
}
if ( nRedDiff > nMax )
{
nMax = nRedDiff;
}
*( pBlackPos + 3 ) = nMax;
}
else
{
*( pBlackPos + 3 ) = 0xff;
}
}
}
static char szPathedFileName[ _MAX_PATH ];
sprintf( szPathedFileName, "%s%s", OutputPath, AssetName );
V_SetExtension( szPathedFileName, ".tga", sizeof( szPathedFileName ) );
bool bResult = SaveTgaAndAddToP4( pImageBlack, IMAGE_FORMAT_BGRA8888, Width, Height, szPathedFileName );
free( pImageBlack );
free( pImageWhite );
if ( !bResult) return NULL;
if ( bSelectedOnly )
{
SaveCaps( szPathedFileName );
}
return szPathedFileName;
}
//-----------------------------------------------------------------------------
// Will go through the asset browser and capture each visible item.
//-----------------------------------------------------------------------------
void CMDLPicker::CaptureScreenCaps( void )
{
char temp[ 256 ];
TextEntry *pTempValue;
int width;
int height;
char szBathPath[ _MAX_PATH ];
Label *m_pOutputDirectory;
m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->GetText( szBathPath, sizeof( szBathPath ) );
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "WidthText" );
pTempValue->GetText( temp, sizeof( temp ) );
width = atoi( temp );
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "HeightText" );
pTempValue->GetText( temp, sizeof( temp ) );
height = atoi( temp );
int PanelX, PanelY, PanelWidth, PanelHeight;
Color PanelColor;
Panel *pParent = m_pMDLPreview->GetParent();
m_pMDLPreview->GetPos( PanelX, PanelY );
m_pMDLPreview->GetSize( PanelWidth, PanelHeight );
PanelColor = m_pMDLPreview->GetBackgroundColor();
m_pMDLPreview->SetParent( ( vgui::Panel * )NULL );
m_pMDLPreview->SetPos( 0, 0 );
m_pMDLPreview->SetSize( width, height );
CColorPickerButton *m_pBackgroundColor;
m_pBackgroundColor = ( CColorPickerButton * )m_pScreenCapsPage->FindChildByName( "BackgroundColor" );
Color NewPanelColor = m_pBackgroundColor->GetColor();
NewPanelColor[3] = 0;
m_pMDLPreview->SetBackgroundColor( NewPanelColor );
((VPanel *)m_pMDLPreview->GetVPanel())->Solve();
bool bSelectedOnly = false;
if ( input()->IsKeyDown( KEY_RCONTROL ) || input()->IsKeyDown( KEY_LCONTROL ) )
{
bSelectedOnly = true;
}
int nCount = m_AssetList.Count();
int nNumItems = 0;
for ( int i = 0; i < nCount; ++i )
{
if ( m_pAssetBrowser->IsItemVisible( m_AssetList[ i ].m_nItemId ) &&
( !bSelectedOnly || m_pAssetBrowser->IsItemSelected( m_AssetList[ i ].m_nItemId ) ) )
{
KeyValues *pItemKeyValues = m_pAssetBrowser->GetItem( m_AssetList[ i ].m_nItemId );
const char *pSelectedAsset = pItemKeyValues->GetString( "asset" );
int nModIndex = pItemKeyValues->GetInt( "modIndex" );
CaptureModel( nModIndex, pSelectedAsset, szBathPath, width, height, NewPanelColor, bSelectedOnly );
nNumItems++;
}
}
m_pMDLPreview->SetParent( pParent );
m_pMDLPreview->SetPos( PanelX, PanelY );
m_pMDLPreview->SetSize( PanelWidth, PanelHeight );
m_pMDLPreview->SetBackgroundColor( PanelColor );
((VPanel *)m_pMDLPreview->GetVPanel())->Solve();
Label *m_pResults;
sprintf( temp, "Captured %d items", nNumItems );
m_pResults = ( Label * )m_pScreenCapsPage->FindChildByName( "CaptureResults" );
m_pResults->SetText( temp );
}
//-----------------------------------------------------------------------------
// Stub for XBox360 compiles
//-----------------------------------------------------------------------------
#if defined( _X360 )
const char *getenv( const char *varname )
{
return NULL;
}
#endif
//-----------------------------------------------------------------------------
// Writes two very simple .vmt file, one for the passed in asset,
// and the other for <asset>_large.
//-----------------------------------------------------------------------------
void CMDLPicker::WriteBackbackVMTFiles( const char *pAssetName )
{
const char *pVProject = getenv( "VPROJECT" );
if ( !pVProject )
return;
char pStrippedAssetName[ MAX_PATH ];
V_StripExtension( pAssetName, pStrippedAssetName, sizeof( pStrippedAssetName ) );
V_strcat_safe( pStrippedAssetName, GetOutputFileSuffix().Get() );
char pVMTFilename[ MAX_PATH ];
Q_snprintf( pVMTFilename, sizeof( pVMTFilename ), "%s\\materials\\backpack\\%s.vmt", pVProject, pStrippedAssetName );
Q_FixSlashes( pVMTFilename );
char pBaseTextureName[ MAX_PATH ];
Q_snprintf( pBaseTextureName, sizeof( pBaseTextureName ), "backpack\\%s", pStrippedAssetName );
Q_FixSlashes( pBaseTextureName );
{
CP4AutoEditAddFile autop4( pVMTFilename );
FileHandle_t fileHandle = g_pFullFileSystem->Open( pVMTFilename, "w" );
if ( fileHandle )
{
g_pFullFileSystem->FPrintf( fileHandle, "\"UnlitGeneric\"\n" );
g_pFullFileSystem->FPrintf( fileHandle, "{\n" );
g_pFullFileSystem->FPrintf( fileHandle, " \"$baseTexture\" \"%s\"\n", pBaseTextureName );
g_pFullFileSystem->FPrintf( fileHandle, " $translucent 1\n" );
g_pFullFileSystem->FPrintf( fileHandle, " $vertexcolor 1\n" );
g_pFullFileSystem->FPrintf( fileHandle, "}\n" );
g_pFullFileSystem->Close( fileHandle );
}
}
// now write the _large version
Q_snprintf( pVMTFilename, sizeof( pVMTFilename ), "%s\\materials\\backpack\\%s_large", pVProject, pStrippedAssetName );
V_SetExtension( pVMTFilename, ".vmt", sizeof( pVMTFilename ) );
Q_FixSlashes( pVMTFilename );
Q_snprintf( pBaseTextureName, sizeof( pBaseTextureName ), "backpack\\%s_large", pStrippedAssetName );
Q_FixSlashes( pBaseTextureName );
{
CP4AutoEditAddFile autop4( pVMTFilename );
FileHandle_t fileHandle = g_pFullFileSystem->Open( pVMTFilename, "w" );
if ( fileHandle )
{
g_pFullFileSystem->FPrintf( fileHandle, "\"UnlitGeneric\"\n" );
g_pFullFileSystem->FPrintf( fileHandle, "{\n" );
g_pFullFileSystem->FPrintf( fileHandle, " \"$baseTexture\" \"%s\"\n", pBaseTextureName );
g_pFullFileSystem->FPrintf( fileHandle, " $translucent 1\n" );
g_pFullFileSystem->FPrintf( fileHandle, "}\n" );
g_pFullFileSystem->Close( fileHandle );
}
}
}
//-----------------------------------------------------------------------------
void *VTexFilesystemFactory( const char *pName, int *pReturnCode )
{
return g_pFullFileSystem;
}
void* MdlPickerFSFactory( const char *pName, int *pReturnCode )
{
if ( IsX360() )
return NULL;
if ( Q_stricmp( pName, FILESYSTEM_INTERFACE_VERSION ) == 0 )
return g_pFullFileSystem;
return NULL;
}
//-----------------------------------------------------------------------------
// Creates the two required icons for the TF2 store/backpack system
//-----------------------------------------------------------------------------
void CMDLPicker::GenerateBackpackIcons( void )
{
if ( !g_pVTex )
return;
int width;
int height;
// find the index of the item we are currently viewing
int selectedItemIndex;
for ( selectedItemIndex = 0; selectedItemIndex < m_AssetList.Count(); ++selectedItemIndex )
{
if ( m_pAssetBrowser->IsItemVisible( m_AssetList[ selectedItemIndex ].m_nItemId ) &&
m_pAssetBrowser->IsItemSelected( m_AssetList[ selectedItemIndex ].m_nItemId ) )
{
break;
}
}
if ( selectedItemIndex >= m_AssetList.Count() )
return;
//
// Fetch and check environment variables
//
const char *pVContent = getenv( "VCONTENT" );
if ( !pVContent )
{
Error( "VCONTENT environment variable not set" );
return;
}
const char *pVMod = getenv( "VMOD" );
if ( !pVMod )
{
Error( "VMOD environment variable not set" );
return;
}
const char *pVProject = getenv( "VPROJECT" );
if ( !pVProject )
{
Error( "VPROJECT environment variable not set" );
return;
}
// extract the filename of the model
KeyValues *pItemKeyValues = m_pAssetBrowser->GetItem( m_AssetList[ selectedItemIndex ].m_nItemId );
const char *pSelectedAsset = pItemKeyValues->GetString( "asset" );
// set the P4 changelist label to refer to this set of icons
char pChangelistLabel[ MAX_PATH ];
V_strcpy_safe( pChangelistLabel, pSelectedAsset );
V_FileBase( pChangelistLabel, pChangelistLabel, sizeof( pChangelistLabel ) );
V_strcat_safe( pChangelistLabel, " Auto Checkout", sizeof( pChangelistLabel ) );
g_p4factory->SetOpenFileChangeList( pChangelistLabel );
// generate .VMT files for normal and _large icons
WriteBackbackVMTFiles( pSelectedAsset );
// store original state of model preview panel
int PanelX, PanelY, PanelWidth, PanelHeight;
Color PanelColor;
Panel *pParent = m_pMDLPreview->GetParent();
m_pMDLPreview->GetPos( PanelX, PanelY );
m_pMDLPreview->GetSize( PanelWidth, PanelHeight );
PanelColor = m_pMDLPreview->GetBackgroundColor();
// slam preview panel to desired TGA size for large icon, and write it out
width = 512;
height = 512;
m_pMDLPreview->SetParent( ( vgui::Panel * )NULL );
m_pMDLPreview->SetPos( 0, 0 );
m_pMDLPreview->SetSize( width, height );
CColorPickerButton *m_pBackgroundColor;
m_pBackgroundColor = ( CColorPickerButton * )m_pScreenCapsPage->FindChildByName( "BackgroundColor" );
Color NewPanelColor = m_pBackgroundColor->GetColor();
NewPanelColor[3] = 0;
m_pMDLPreview->SetBackgroundColor( NewPanelColor );
((VPanel *)m_pMDLPreview->GetVPanel())->Solve();
char pLargeAssetName[ MAX_PATH ];
V_strcpy_safe( pLargeAssetName, pSelectedAsset );
V_StripExtension( pLargeAssetName, pLargeAssetName, ARRAYSIZE( pLargeAssetName ) );
CUtlString strExtention = GetOutputFileSuffix();
strExtention += "_large.mdl";
V_strcat_safe( pLargeAssetName, strExtention.String() );
char pOutputPath[ MAX_PATH ];
Q_snprintf( pOutputPath, sizeof( pOutputPath ), "%s\\%s\\materialsrc\\backpack\\", pVContent, pVMod );
Q_FixSlashes( pOutputPath );
int nModIndex = pItemKeyValues->GetInt( "modIndex" );
const char *pLargeTGAName = CaptureModel( nModIndex, pLargeAssetName, pOutputPath, width, height, NewPanelColor, true );
if ( !pLargeTGAName )
return;
// write corresponding .txt file with vtex options
char pVTexOptionsFileName[ MAX_PATH ];
V_strcpy_safe( pVTexOptionsFileName, pLargeTGAName );
V_SetExtension( pVTexOptionsFileName, ".txt", sizeof( pVTexOptionsFileName ) );
{
CP4AutoEditAddFile autop4( pVTexOptionsFileName );
FileHandle_t hVTexOptionsFile = g_pFullFileSystem->Open( pVTexOptionsFileName, "w" );
if ( hVTexOptionsFile )
{
g_pFullFileSystem->FPrintf( hVTexOptionsFile, "nomip 1\n" );
g_pFullFileSystem->FPrintf( hVTexOptionsFile, "nolod 1\n" );
g_pFullFileSystem->Close( hVTexOptionsFile );
}
}
// !KLUDGE! Everybody I've talked to says that vtex is *supposed* to
// use VPROJECT. But it doesn't. I don't think I can safely change vtex
// without breaking tons of stuff. So just force the output directory.
// Determine the proper output directory based on VPROJECT
char pOutputPathGame[ MAX_PATH ];
Q_strncpy( pOutputPathGame, pVProject, sizeof( pOutputPathGame ) );
Q_StripTrailingSlash( pOutputPathGame );
Q_strncat( pOutputPathGame, "/materials/", sizeof( pOutputPathGame ) );
const char *pBackpack = Q_stristr( pLargeTGAName, "backpack" );
if ( pBackpack )
{
Q_strncat( pOutputPathGame, pBackpack, sizeof( pOutputPathGame ) );
Q_StripFilename( pOutputPathGame );
}
Q_FixSlashes( pOutputPathGame );
// run vtex on the TGA and .txt file to create .VTF and add it to our Perforce changelist
char *vTexArgv[64];
int vTexArgc = 0;
vTexArgv[ vTexArgc++ ] = "";
vTexArgv[ vTexArgc++ ] = "-quiet";
vTexArgv[ vTexArgc++ ] = "-UseStandardError";
vTexArgv[ vTexArgc++ ] = "-WarningsAsErrors";
vTexArgv[ vTexArgc++ ] = "-p4skip";
vTexArgv[ vTexArgc++ ] = "-outdir";
vTexArgv[ vTexArgc++ ] = pOutputPathGame;
vTexArgv[ vTexArgc++ ] = (char *)pLargeTGAName;
g_pVTex->VTex( MdlPickerFSFactory, pOutputPathGame, vTexArgc, vTexArgv );
// Generale small TGA name, by removing the "large" part
char pSmallTGAName[ MAX_PATH ];
strcpy( pSmallTGAName, pLargeTGAName );
char *_large = Q_stristr( pSmallTGAName, "_large");
Assert(_large);
strcpy(_large, _large+6);
// Load up the large icon
int nCheckWidth, nCheckHeight;
ImageFormat largeFmt;
float gamma;
CUtlBuffer largeTGAFileData;
CUtlMemory<unsigned char> largeTGAImageData;
if ( !g_pFullFileSystem->ReadFile( pLargeTGAName, NULL, largeTGAFileData )
|| !TGALoader::GetInfo( largeTGAFileData, &nCheckWidth, &nCheckHeight, &largeFmt, &gamma )
|| nCheckWidth != width || nCheckHeight != height )
{
Error( "Failed to reload image header %s", pLargeTGAName );
Assert( false );
return;
}
largeTGAFileData.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
if ( !TGALoader::LoadRGBA8888( largeTGAFileData, largeTGAImageData, nCheckWidth, nCheckHeight )
|| nCheckWidth != width || nCheckHeight != height )
{
Error( "Failed to reload image data %s", pLargeTGAName );
Assert( false );
return;
}
//
// Perform a downsample. This is better than just re-rendering at the smaller size,
// which essentially just point-samples the image.
//
CUtlMemory<unsigned char> smallTGAImageData;
const int kSmallSize = 128;
smallTGAImageData.EnsureCapacity(kSmallSize*kSmallSize*4);
ImageLoader::ResampleInfo_t resampleInfo;
resampleInfo.m_nSrcWidth = width;
resampleInfo.m_nSrcHeight = height;
resampleInfo.m_flSrcGamma = gamma;
resampleInfo.m_pSrc = (unsigned char *)largeTGAImageData.Base();
resampleInfo.m_nDestWidth = kSmallSize;
resampleInfo.m_nDestHeight = kSmallSize;
resampleInfo.m_flDestGamma = gamma;
resampleInfo.m_pDest = (unsigned char *)smallTGAImageData.Base();
resampleInfo.m_nFlags = ImageLoader::RESAMPLE_CLAMPS | ImageLoader::RESAMPLE_CLAMPT;
//resampleInfo.m_nFlags |= ImageLoader::RESAMPLE_NICE_FILTER; // Turn this off. It has some sort of edge enhancement or something. Causes edges to ring.
if ( !ImageLoader::ResampleRGBA8888( resampleInfo ) )
{
Error( "Failed to resample %s", pLargeTGAName );
Assert( false );
return;
}
// Save it
if ( !SaveTgaAndAddToP4( resampleInfo.m_pDest, IMAGE_FORMAT_RGBA8888, resampleInfo.m_nDestWidth, resampleInfo.m_nDestHeight, pSmallTGAName ) )
{
return;
}
// Save the .cfg file.
SaveCaps( pSmallTGAName );
// write corresponding .txt file with vtex options
V_strcpy_safe( pVTexOptionsFileName, pSmallTGAName );
V_SetExtension( pVTexOptionsFileName, ".txt", sizeof( pVTexOptionsFileName ) );
{
CP4AutoEditAddFile autop4( pVTexOptionsFileName );
FileHandle_t hVTexOptionsFile = g_pFullFileSystem->Open( pVTexOptionsFileName, "w" );
if ( hVTexOptionsFile )
{
g_pFullFileSystem->FPrintf( hVTexOptionsFile, "nomip 1\n" );
g_pFullFileSystem->FPrintf( hVTexOptionsFile, "nolod 1\n" );
g_pFullFileSystem->Close( hVTexOptionsFile );
}
}
// run vtex on the TGA and .txt file to create .VTF and add it to our Perforce changelist
vTexArgc = 0;
vTexArgv[ vTexArgc++ ] = "";
vTexArgv[ vTexArgc++ ] = "-quiet";
vTexArgv[ vTexArgc++ ] = "-UseStandardError";
vTexArgv[ vTexArgc++ ] = "-WarningsAsErrors";
vTexArgv[ vTexArgc++ ] = "-p4skip";
vTexArgv[ vTexArgc++ ] = "-outdir";
vTexArgv[ vTexArgc++ ] = pOutputPathGame;
vTexArgv[ vTexArgc++ ] = (char *)pSmallTGAName;
g_pVTex->VTex( MdlPickerFSFactory, pOutputPathGame, vTexArgc, vTexArgv );
// restore the preview panel to its original state
m_pMDLPreview->SetParent( pParent );
m_pMDLPreview->SetPos( PanelX, PanelY );
m_pMDLPreview->SetSize( PanelWidth, PanelHeight );
m_pMDLPreview->SetBackgroundColor( PanelColor );
((VPanel *)m_pMDLPreview->GetVPanel())->Solve();
}
CUtlString CMDLPicker::GetOutputFileSuffix()
{
char temp[256];
TextEntry *pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "SuffixText" );
if ( pTempValue )
{
pTempValue->GetText( temp, sizeof( temp ) );
}
return temp;
}
//-----------------------------------------------------------------------------
// Saves the screen cap information and camera position
//-----------------------------------------------------------------------------
void CMDLPicker::SaveCaps( const char *szFileName )
{
char temp[ _MAX_PATH ];
KeyValues *CaptureData = new KeyValues( "ScreenCaps" );
Vector vecPos;
QAngle angDir;
m_pMDLPreview->GetCameraPositionAndAngles( vecPos, angDir );
sprintf( temp, "%g %g %g", vecPos.x, vecPos.y, vecPos.z );
CaptureData->SetString( "CameraPosition", temp );
sprintf( temp, "%g %g %g", angDir.x, angDir.y, angDir.z );
CaptureData->SetString( "CameraAngles", temp );
Vector vecOffset;
m_pMDLPreview->GetCameraOffset( vecOffset );
sprintf( temp, "%g %g %g", vecOffset.x, vecOffset.y, vecOffset.z );
CaptureData->SetString( "CameraOffset", temp );
CColorPickerButton *m_pBackgroundColor;
m_pBackgroundColor = ( CColorPickerButton * )m_pScreenCapsPage->FindChildByName( "BackgroundColor" );
Color color = m_pBackgroundColor->GetColor();
sprintf( temp, "%d %d %d %d", color.r(), color.g(), color.b(), color.a() );
CaptureData->SetString( "BackgroundColor", temp );
TextEntry *pTempValue;
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "WidthText" );
pTempValue->GetText( temp, sizeof( temp ) );
CaptureData->SetString( "Width", temp );
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "HeightText" );
pTempValue->GetText( temp, sizeof( temp ) );
CaptureData->SetString( "Height", temp );
vgui::CheckButton *pToggle;
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "NoGround" );
CaptureData->SetInt( "NoGround", pToggle->IsSelected() ? 1 : 0 );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "Collision" );
CaptureData->SetInt( "Collision", pToggle->IsSelected() ? 1 : 0 );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "Wireframe" );
CaptureData->SetInt( "Wifeframe", pToggle->IsSelected() ? 1 : 0 );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "LockView" );
CaptureData->SetInt( "LockView", pToggle->IsSelected() ? 1 : 0 );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "LookAtCamera" );
CaptureData->SetInt( "LookAtCamera", pToggle->IsSelected() ? 1 : 0 );
for( int i = 1; i < MAX_SELECTED_MODELS; i++ )
{
if ( m_hSelectedMDL[ i ] != MDLHANDLE_INVALID )
{
const char *MergedModelName = vgui::MDLCache()->GetModelName( m_hSelectedMDL[ i ] );
sprintf( temp, "Merged_%d", i );
CaptureData->SetString( temp, MergedModelName );
}
}
if ( szFileName != NULL )
{
strcpy( temp, szFileName );
V_SetExtension( temp, ".cfg", sizeof( temp ) );
}
else
{
Label *m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->GetText( temp, sizeof( temp ) );
strcat( temp, "ScreenCaps.cfg" );
}
CaptureData->SaveToFile( g_pFullFileSystem, temp );
CP4AutoAddFile autop4( temp );
}
//-----------------------------------------------------------------------------
// Restores the screen cap information and camera position
//-----------------------------------------------------------------------------
bool CMDLPicker::RestoreCaps( const char *szFileName )
{
char temp[ _MAX_PATH ];
if ( szFileName != NULL )
{
strcpy( temp, szFileName );
V_SetExtension( temp, ".cfg", sizeof( temp ) );
}
else
{
Label *m_pOutputDirectory = ( Label * )m_pScreenCapsPage->FindChildByName( "OutputDirectory" );
m_pOutputDirectory->GetText( temp, sizeof( temp ) );
strcat( temp, "ScreenCaps.cfg" );
}
KeyValues *CaptureData = new KeyValues( "ScreenCaps" );
if ( !CaptureData->LoadFromFile( g_pFullFileSystem, temp ) )
{
return false;
}
Vector vecPos;
QAngle angDir;
Vector vecOffset;
sscanf( CaptureData->GetString( "CameraPosition" ), "%g %g %g", &vecPos.x, &vecPos.y, &vecPos.z );
sscanf( CaptureData->GetString( "CameraAngles" ), "%g %g %g", &angDir.x, &angDir.y, &angDir.z );
sscanf( CaptureData->GetString( "CameraOffset" ), "%g %g %g", &vecOffset.x, &vecOffset.y, &vecOffset.z );
m_pMDLPreview->SetCameraOffset( vecOffset );
m_pMDLPreview->SetCameraPositionAndAngles( vecPos, angDir );
CColorPickerButton *m_pBackgroundColor;
int r, g, b, a;
m_pBackgroundColor = ( CColorPickerButton * )m_pScreenCapsPage->FindChildByName( "BackgroundColor" );
sscanf( CaptureData->GetString( "BackgroundColor" ), "%d %d %d %d", &r, &g, &b, &a );
m_pBackgroundColor->SetColor( r, g, b, a );
TextEntry *pTempValue;
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "WidthText" );
pTempValue->SetText( CaptureData->GetString( "Width" ) );
pTempValue = ( TextEntry * )m_pScreenCapsPage->FindChildByName( "HeightText" );
pTempValue->SetText( CaptureData->GetString( "Height" ) );
vgui::CheckButton *pToggle;
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "NoGround" );
pToggle->SetSelected( ( CaptureData->GetInt( "NoGround" ) == 1 ) );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "Collision" );
pToggle->SetSelected( ( CaptureData->GetInt( "Collision" ) == 1 ) );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "Wireframe" );
pToggle->SetSelected( ( CaptureData->GetInt( "Wireframe" ) == 1 ) );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "LockView" );
pToggle->SetSelected( ( CaptureData->GetInt( "LockView" ) == 1 ) );
pToggle = (vgui::CheckButton*)m_pRenderPage->FindChildByName( "LookAtCamera" );
pToggle->SetSelected( ( CaptureData->GetInt( "LookAtCamera" ) == 1 ) );
for( int i = 1; i < MAX_SELECTED_MODELS; i++ )
{
sprintf( temp, "Merged_%d", i );
const char *MergedModelName = CaptureData->GetString( temp, NULL );
if ( MergedModelName )
{
SelectMDL( MergedModelName, false, i );
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: rebuilds the list of activities
//-----------------------------------------------------------------------------
void CMDLPicker::RefreshActivitiesAndSequencesList()
{
m_pActivitiesList->RemoveAll();
m_pSequencesList->RemoveAll();
m_pMDLPreview->SetSequence( 0 );
if ( m_hSelectedMDL[ 0 ] == MDLHANDLE_INVALID )
{
m_pActivitiesList->SetEmptyListText("No .MDL file currently selected");
m_pSequencesList->SetEmptyListText("No .MDL file currently selected");
return;
}
m_pActivitiesList->SetEmptyListText(".MDL file contains no activities");
m_pSequencesList->SetEmptyListText(".MDL file contains no sequences");
studiohdr_t *hdr = vgui::MDLCache()->GetStudioHdr( m_hSelectedMDL[ 0 ] );
CUtlDict<int, unsigned short> activityNames( true, 0, hdr->GetNumSeq() );
for (int j = 0; j < hdr->GetNumSeq(); j++)
{
if ( /*g_viewerSettings.showHidden ||*/ !(hdr->pSeqdesc(j).flags & STUDIO_HIDDEN))
{
const char *pActivityName = hdr->pSeqdesc(j).pszActivityName();
if ( pActivityName && pActivityName[0] )
{
// Multiple sequences can have the same activity name; only add unique activity names
if ( activityNames.Find( pActivityName ) == activityNames.InvalidIndex() )
{
KeyValues *pkv = new KeyValues("node", "activity", pActivityName );
int nItemID = m_pActivitiesList->AddItem( pkv, 0, false, false );
KeyValues *pDrag = new KeyValues( "drag", "text", pActivityName );
pDrag->SetString( "texttype", "activityName" );
pDrag->SetString( "mdl", vgui::MDLCache()->GetModelName( m_hSelectedMDL[ 0 ] ) );
m_pActivitiesList->SetItemDragData( nItemID, pDrag );
activityNames.Insert( pActivityName, j );
}
}
const char *pSequenceName = hdr->pSeqdesc(j).pszLabel();
if ( pSequenceName && pSequenceName[0] )
{
KeyValues *pkv = new KeyValues("node", "sequence", pSequenceName);
int nItemID = m_pSequencesList->AddItem( pkv, 0, false, false );
KeyValues *pDrag = new KeyValues( "drag", "text", pSequenceName );
pDrag->SetString( "texttype", "sequenceName" );
pDrag->SetString( "mdl", vgui::MDLCache()->GetModelName( m_hSelectedMDL[ 0 ] ) );
m_pSequencesList->SetItemDragData( nItemID, pDrag );
}
}
}
}
//-----------------------------------------------------------------------------
// A MDL was selected
//-----------------------------------------------------------------------------
void CMDLPicker::OnSelectedAssetPicked( const char *pMDLName )
{
char pRelativePath[MAX_PATH];
int nSelectSecondary = -1;
if ( input()->IsKeyDown( KEY_RCONTROL ) || input()->IsKeyDown( KEY_LCONTROL ) )
{
nSelectSecondary = 0;
}
else if ( input()->IsMouseDown(MOUSE_RIGHT) )
{
nSelectSecondary = 1;
}
if ( pMDLName )
{
Q_snprintf( pRelativePath, sizeof(pRelativePath), "models\\%s", pMDLName );
SelectMDL( pRelativePath, true, nSelectSecondary );
}
else
{
SelectMDL( NULL, true, nSelectSecondary );
}
}
//-----------------------------------------------------------------------------
// Allows external apps to select a MDL
//-----------------------------------------------------------------------------
void CMDLPicker::SelectMDL( const char *pRelativePath, bool bDoLookAt, int nSelectSecondary )
{
MDLHandle_t hSelectedMDL = pRelativePath ? vgui::MDLCache()->FindMDL( pRelativePath ) : MDLHANDLE_INVALID;
int index = ( nSelectSecondary > 0 ? nSelectSecondary : 0 );
// We didn't change models after all...
if ( hSelectedMDL == m_hSelectedMDL[ index ] )
{
// vgui::MDLCache()->FindMDL adds a reference by default we don't use, release it again
if ( hSelectedMDL != MDLHANDLE_INVALID )
{
vgui::MDLCache()->Release( hSelectedMDL );
}
return;
}
m_hSelectedMDL[ index ] = hSelectedMDL;
if ( vgui::MDLCache()->IsErrorModel( m_hSelectedMDL[ index ] ) )
{
m_hSelectedMDL[ index ] = MDLHANDLE_INVALID;
}
if ( nSelectSecondary != -1 )
{
m_pMDLPreview->ClearMergeMDLs();
for( int i = 1; i < MAX_SELECTED_MODELS; i++ )
{
if ( i != index )
{
m_hSelectedMDL[ i ] = MDLHANDLE_INVALID;
}
}
}
if ( index > 0 )
{
m_pMDLPreview->SetMergeMDL( m_hSelectedMDL[ index ] );
}
else
{
m_pMDLPreview->SetMDL( m_hSelectedMDL[ index ] );
if ( bDoLookAt )
{
m_pMDLPreview->LookAtMDL();
}
if ( m_nFlags & ( PAGE_SKINS ) )
{
UpdateSkinsList();
}
if ( m_nFlags & ( PAGE_INFO ) )
{
UpdateInfoTab();
}
if ( m_nFlags & (PAGE_ACTIVITIES|PAGE_SEQUENCES) )
{
RefreshActivitiesAndSequencesList();
}
}
// vgui::MDLCache()->FindMDL adds a reference by default we don't use, release it again
if ( hSelectedMDL != MDLHANDLE_INVALID )
{
vgui::MDLCache()->Release( hSelectedMDL );
}
PostActionSignal( new KeyValues( "MDLPreviewChanged", "mdl", pRelativePath ? pRelativePath : "" ) );
}
//-----------------------------------------------------------------------------
// Purpose: updates revision view on a file being selected
//-----------------------------------------------------------------------------
void CMDLPicker::OnCheckButtonChecked(KeyValues *kv)
{
// RefreshMDLList();
BaseClass::OnCheckButtonChecked( kv );
RefreshRenderSettings();
}
void CMDLPicker::GetSelectedMDLName( char *pBuffer, int nMaxLen )
{
Assert( nMaxLen > 0 );
if ( GetSelectedAssetCount() > 0 )
{
Q_snprintf( pBuffer, nMaxLen, "models\\%s", GetSelectedAsset( ) );
}
else
{
pBuffer[0] = 0;
}
}
//-----------------------------------------------------------------------------
// Gets the selected activity/sequence
//-----------------------------------------------------------------------------
int CMDLPicker::GetSelectedPage( )
{
if ( m_pSequencesPage && ( m_pViewsSheet->GetActivePage() == m_pSequencesPage ) )
return PAGE_SEQUENCES;
if ( m_pActivitiesPage && ( m_pViewsSheet->GetActivePage() == m_pActivitiesPage ) )
return PAGE_ACTIVITIES;
return PAGE_NONE;
}
const char *CMDLPicker::GetSelectedSequenceName()
{
if ( !m_pSequencesPage )
return NULL;
int nIndex = m_pSequencesList->GetSelectedItem( 0 );
if ( nIndex >= 0 )
{
KeyValues *pkv = m_pSequencesList->GetItem( nIndex );
return pkv->GetString( "sequence", NULL );
}
return NULL;
}
const char *CMDLPicker::GetSelectedActivityName()
{
if ( !m_pActivitiesPage )
return NULL;
int nIndex = m_pActivitiesList->GetSelectedItem( 0 );
if ( nIndex >= 0 )
{
KeyValues *pkv = m_pActivitiesList->GetItem( nIndex );
return pkv->GetString( "activity", NULL );
}
return NULL;
}
int CMDLPicker::GetSelectedSkin()
{
if ( !m_pSkinsPage )
return 0;
int nIndex = m_pSkinsList->GetSelectedItem( 0 );
if ( nIndex >= 0 )
{
return nIndex;
}
return 0;
}
//-----------------------------------------------------------------------------
// Plays the selected activity
//-----------------------------------------------------------------------------
void CMDLPicker::SelectActivity( const char *pActivityName )
{
studiohdr_t *pstudiohdr = vgui::MDLCache()->GetStudioHdr( m_hSelectedMDL[ 0 ] );
for ( int i = 0; i < pstudiohdr->GetNumSeq(); i++ )
{
mstudioseqdesc_t &seqdesc = pstudiohdr->pSeqdesc( i );
if ( stricmp( seqdesc.pszActivityName(), pActivityName ) == 0 )
{
// FIXME: Add weighted sequence selection logic?
m_pMDLPreview->SetSequence( i );
break;
}
}
PostActionSignal( new KeyValues( "SequenceSelectionChanged", "activity", pActivityName ) );
}
//-----------------------------------------------------------------------------
// Plays the selected sequence
//-----------------------------------------------------------------------------
void CMDLPicker::SelectSequence( const char *pSequenceName )
{
studiohdr_t *pstudiohdr = vgui::MDLCache()->GetStudioHdr( m_hSelectedMDL[ 0 ] );
for (int i = 0; i < pstudiohdr->GetNumSeq(); i++)
{
mstudioseqdesc_t &seqdesc = pstudiohdr->pSeqdesc( i );
if ( !Q_stricmp( seqdesc.pszLabel(), pSequenceName ) )
{
m_pMDLPreview->SetSequence( i );
break;
}
}
PostActionSignal( new KeyValues( "SequenceSelectionChanged", "sequence", pSequenceName ) );
}
void CMDLPicker::SelectSkin( int nSkin )
{
m_pMDLPreview->SetSkin( nSkin );
PostActionSignal( new KeyValues( "SkinSelectionChanged", "skin", nSkin));
}
//-----------------------------------------------------------------------------
// Purpose: Updates preview when an item is selected
//-----------------------------------------------------------------------------
void CMDLPicker::OnItemSelected( KeyValues *kv )
{
Panel *pPanel = (Panel *)kv->GetPtr("panel", NULL);
if ( m_pSequencesList && (pPanel == m_pSequencesList ) )
{
const char *pSequenceName = GetSelectedSequenceName();
if ( pSequenceName )
{
SelectSequence( pSequenceName );
}
return;
}
if ( m_pActivitiesList && ( pPanel == m_pActivitiesList ) )
{
const char *pActivityName = GetSelectedActivityName();
if ( pActivityName )
{
SelectActivity( pActivityName );
}
return;
}
if ( m_pSkinsList && ( pPanel == m_pSkinsList ) )
{
int nSelectedSkin = GetSelectedSkin();
SelectSkin( nSelectedSkin );
return;
}
BaseClass::OnItemSelected( kv );
}
//-----------------------------------------------------------------------------
// Purpose: Called when a page is shown
//-----------------------------------------------------------------------------
void CMDLPicker::OnPageChanged( )
{
if ( m_pSequencesPage && ( m_pViewsSheet->GetActivePage() == m_pSequencesPage ) )
{
m_pSequencesList->RequestFocus();
const char *pSequenceName = GetSelectedSequenceName();
if ( pSequenceName )
{
SelectSequence( pSequenceName );
}
return;
}
if ( m_pActivitiesPage && ( m_pViewsSheet->GetActivePage() == m_pActivitiesPage ) )
{
m_pActivitiesList->RequestFocus();
const char *pActivityName = GetSelectedActivityName();
if ( pActivityName )
{
SelectActivity( pActivityName );
}
return;
}
}
//-----------------------------------------------------------------------------
//
// Purpose: Modal picker frame
//
//-----------------------------------------------------------------------------
CMDLPickerFrame::CMDLPickerFrame( vgui::Panel *pParent, const char *pTitle, int nFlags ) :
BaseClass( pParent )
{
SetAssetPicker( new CMDLPicker( this, nFlags ) );
LoadControlSettingsAndUserConfig( "resource/mdlpickerframe.res" );
SetTitle( pTitle, false );
}
CMDLPickerFrame::~CMDLPickerFrame()
{
}
//-----------------------------------------------------------------------------
// Allows external apps to select a MDL
//-----------------------------------------------------------------------------
void CMDLPickerFrame::SelectMDL( const char *pRelativePath )
{
static_cast<CMDLPicker*>( GetAssetPicker() )->SelectMDL( pRelativePath );
}
int CMDLPicker::UpdateSkinsList()
{
int nNumSkins = 0;
if ( m_pSkinsList )
{
m_pSkinsList->RemoveAll();
studiohdr_t *hdr = vgui::MDLCache()->GetStudioHdr( m_hSelectedMDL[ 0 ] );
if ( hdr )
{
nNumSkins = hdr->numskinfamilies;
for ( int i = 0; i < nNumSkins; i++ )
{
char skinText[25] = "";
sprintf( skinText, "skin%i", i );
KeyValues *pkv = new KeyValues("node", "skin", skinText );
m_pSkinsList->AddItem( pkv, 0, false, false );
}
}
}
return nNumSkins;
}
void CMDLPicker::UpdateInfoTab()
{
studiohdr_t *hdr = vgui::MDLCache()->GetStudioHdr( m_hSelectedMDL[ 0 ] );
if ( !hdr )
return;
int nMass = hdr->mass;
Panel *pTempPanel = m_pInfoPage->FindChildByName("MassValue");
char massBuff[10];
Q_snprintf( massBuff, 10, "%d", nMass );
((vgui::Label *)pTempPanel)->SetText( massBuff );
bool bIsStatic = hdr->flags & STUDIOHDR_FLAGS_STATIC_PROP;
bool bIsPhysics = false;
const char* buf = hdr->KeyValueText();
Label * pTempLabel = (Label *)m_pInfoPage->FindChildByName("StaticText");
pTempLabel->SetVisible( false );
if( buf )
{
buf = Q_strstr( buf, "prop_data" );
if ( buf )
{
int iPropDataCount = UpdatePropDataList( buf, bIsStatic );
if( iPropDataCount )
{
bIsPhysics = true;
}
}
else
{
m_pPropDataList->RemoveAll();
}
}
else
{
m_pPropDataList->RemoveAll();
}
CheckButton * pTempCheck = (CheckButton *)m_pInfoPage->FindChildByName("StaticObject");
pTempCheck->SetCheckButtonCheckable( true );
pTempCheck->SetSelected( bIsStatic );
pTempCheck->SetCheckButtonCheckable( false );
pTempCheck = (CheckButton *)m_pInfoPage->FindChildByName("PhysicsObject");
pTempCheck->SetCheckButtonCheckable( true );
pTempCheck->SetSelected( bIsPhysics );
pTempCheck->SetCheckButtonCheckable( false );
pTempCheck = (CheckButton *)m_pInfoPage->FindChildByName("DynamicObject");
pTempCheck->SetCheckButtonCheckable( true );
pTempCheck->SetSelected( !bIsPhysics );
pTempCheck->SetCheckButtonCheckable( false );
}
int CMDLPicker::UpdatePropDataList( const char* pszPropData, bool &bIsStatic )
{
int iCount = 0;
if ( m_pPropDataList )
{
m_pPropDataList->RemoveAll();
const char * endPropData = strchr( pszPropData, '}' );
char keyText[255] = "";
char valueText[255] = "";
const char *beginChunk = strchr( pszPropData, '\"' );
if ( !beginChunk )
{
return 0;
}
beginChunk++;
const char *endChunk = strchr( beginChunk, '\"' );
while( endChunk )
{
Q_memcpy( keyText, beginChunk, endChunk - beginChunk );
beginChunk = endChunk + 1;
beginChunk = strchr( beginChunk, '\"' ) + 1;
endChunk = strchr( beginChunk, '\"' );
Q_memcpy( valueText, beginChunk, endChunk - beginChunk );
if( !Q_strcmp( keyText, "allowstatic" ) && !Q_strcmp( valueText , "1" ) )
{
if ( !bIsStatic )
{
Label * pTempLabel = (Label *)m_pInfoPage->FindChildByName("StaticText");
pTempLabel->SetVisible( true );
}
bIsStatic &= true;
}
KeyValues *pkv = new KeyValues("node", "key", keyText, "value", valueText );
m_pPropDataList->AddItem( pkv, 0, false, false );
Q_memset( keyText, 0, 255 );
Q_memset( valueText, 0, 255 );
iCount++;
beginChunk = endChunk + 1;
beginChunk = strchr( beginChunk, '\"' );
if ( !beginChunk || beginChunk > endPropData )
{
return iCount;
}
beginChunk++;
endChunk = strchr( beginChunk, '\"' );
}
}
return iCount;
}