diff options
Diffstat (limited to 'game/client/econ/item_model_panel.cpp')
| -rw-r--r-- | game/client/econ/item_model_panel.cpp | 3933 |
1 files changed, 3933 insertions, 0 deletions
diff --git a/game/client/econ/item_model_panel.cpp b/game/client/econ/item_model_panel.cpp new file mode 100644 index 0000000..3cbe994 --- /dev/null +++ b/game/client/econ/item_model_panel.cpp @@ -0,0 +1,3933 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include "cbase.h" +#include "vgui/IInput.h" +#include <vgui/IVGui.h> +#include <vgui/IScheme.h> +#include "item_model_panel.h" +#include "iclientmode.h" +#include "baseviewport.h" +#include "econ_entity.h" +#include "gamestringpool.h" +#include "vgui_controls/TextImage.h" +#include "vgui_controls/Label.h" +#include "vgui_controls/Button.h" +#include "econ_item_system.h" +#include "ienginevgui.h" +#include "VGuiMatSurface/IMatSystemSurface.h" +#include "renderparm.h" +#include "vgui_controls/ScalableImagePanel.h" +#include "engine/IEngineSound.h" +#include "econ/tool_items/tool_items.h" +#include "econ_item_description.h" +#include "econ_item_tools.h" +#include "tool_items/custom_texture_cache.h" +#include "econ_dynamic_recipe.h" +#include "materialsystem/imaterialvar.h" +#include "materialsystem/itexturecompositor.h" +#include "bone_setup.h" +#include "animation.h" +#include "iconrenderreceiver.h" + +#ifdef TF_CLIENT_DLL +#include "tf_shareddefs.h" +#include "tf_gamerules.h" +#endif // TF_CLIENT_DLL +#include "KeyValues.h" + +ConVar tf_time_loading_item_panels( "tf_time_loading_item_panels", "0.0005", FCVAR_ARCHIVE, "The time to spend per frame loading data for item panels" ); +#ifdef STAGING_ONLY +ConVar tf_paint_kit_show_unique_icon( "tf_paint_kit_show_unique_icon", "1" ); +ConVar tf_test_loading_panels( "tf_test_loading_panels", "0" ); +ConVar tf_force_highres_item_image( "tf_force_highres_item_image", "0" ); +ConVar tf_unique_icon_perf_debug( "tf_unique_icon_perf_debug", "0" ); +#endif + +const char* g_ItemModelPanelRenderTargetNames[] = +{ + "_rt_ItemModelPanel0", + "_rt_ItemModelPanel1", + "_rt_ItemModelPanel2" +}; +COMPILE_TIME_ASSERT( ITEM_MODEL_IMAGE_CACHE_SIZE == ARRAYSIZE( g_ItemModelPanelRenderTargetNames ) ); + +CItemMaterialCustomizationIconPanel::CItemMaterialCustomizationIconPanel( vgui::Panel *pParent, const char *pName ) + : BaseClass( pParent, pName ) +{ + m_iPaintSplat = -1; +} + +CItemMaterialCustomizationIconPanel::~CItemMaterialCustomizationIconPanel() +{ + if ( vgui::surface() ) + { + if ( m_iPaintSplat != -1 ) + { + vgui::surface()->DestroyTextureID( m_iPaintSplat ); + m_iPaintSplat = -1; + } + } +} + +// Custom painting +void CItemMaterialCustomizationIconPanel::PaintBackground( void ) +{ + // Draw custom texture, if we have one + if ( m_hUGCId != 0 ) + { + // Request it from the cache, and get filename, if it's downloaded + // and ready + int iCustomTexture = GetCustomTextureGuiHandle( m_hUGCId ); + if ( iCustomTexture != 0 ) + { + surface()->DrawSetTexture( iCustomTexture ); + DrawQuad( 0, 1 ); + surface()->DrawSetColor(COLOR_WHITE); + } + } + + for ( int i = 0; i < m_colPaintColors.Size(); i++ ) + { + const Color& c = m_colPaintColors[i]; + + if ( m_iPaintSplat == -1 ) + { + m_iPaintSplat = surface()->CreateNewTextureID(); + surface()->DrawSetTextureFile( m_iPaintSplat, "vgui/backpack_jewel_paint_splatter", true, false); + } + surface()->DrawSetTexture( m_iPaintSplat ); + surface()->DrawSetColor( c.r(), c.g(), c.b(), GetAlpha() ); + DrawQuad( i, m_colPaintColors.Size() ); + surface()->DrawSetColor(COLOR_WHITE); + } + + // Clean up + vgui::surface()->DrawSetTexture(0); +} + +// Draw a quad that fills our extents +void CItemMaterialCustomizationIconPanel::DrawQuad( int iSubtileIndex, int iSubtileCount ) +{ + int iWide, iTall; + GetSize( iWide, iTall ); + + // All of this math is to accomplish the following: allow us to split our single "icon" + // into some number of equivalent columns. Then take each column and angle the divider so + // it goes from the left image to the right image: + // + // +-----+-----+ +------+----+ + // | | | | / | + // | | | | | | + // | | | | / | + // +-----+-----+ +--- +------+ + // + // ...because the angle is prettier than a straight vertical cut. + // + // My hope is that this code is so awful I'm never allowed to write UI code again. + float fXScale = 1.0f / (float)iSubtileCount, + fXOffsetL = (float)iSubtileIndex * fXScale, + fXOffsetR = (float)(iSubtileIndex + 1) * fXScale, + fXUpperLowerOffset = fXScale * 0.65f; + + // We shift our coordinates on the top slightly to the right (by fXUpperLowerOffset) and on + // the bottom slightly to the left (also by fXUpperLowerOffset). The far left side can't move + // away from 0 and the far right side can't move away from 1, so the edge case handling makes + // this look uglier than it really is. + float fXUL = iSubtileIndex == 0 ? fXOffsetL : fXOffsetL + fXUpperLowerOffset, + fXUR = iSubtileIndex == iSubtileCount - 1 ? fXOffsetR : fXOffsetR + fXUpperLowerOffset, + fXBL = iSubtileIndex == 0 ? fXOffsetL : fXOffsetL - fXUpperLowerOffset, + fXBR = iSubtileIndex == iSubtileCount - 1 ? fXOffsetR : fXOffsetR - fXUpperLowerOffset; + + Vector2D uv11( fXUL, 0.0f ); + Vector2D uv21( fXUR, 0.0f ); + Vector2D uv22( fXBR, 1.0f ); + Vector2D uv12( fXBL, 1.0f ); + + vgui::Vertex_t verts[4]; + verts[0].Init( Vector2D( iWide * fXUL, 0 ), uv11 ); + verts[1].Init( Vector2D( iWide * fXUR, 0 ), uv21 ); + verts[2].Init( Vector2D( iWide * fXBR, iTall ), uv22 ); + verts[3].Init( Vector2D( iWide * fXBL, iTall ), uv12 ); + + vgui::surface()->DrawTexturedPolygon( 4, verts ); +} + +DECLARE_BUILD_FACTORY( CItemModelPanel ); +DECLARE_BUILD_FACTORY( CEmbeddedItemModelPanel ); +DECLARE_BUILD_FACTORY( CItemMaterialCustomizationIconPanel ); + +item_model_cache_t g_ItemModelImageCache[ITEM_MODEL_IMAGE_CACHE_SIZE]; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CEmbeddedItemModelPanel::CEmbeddedItemModelPanel( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName ) +{ + m_bUseItemRenderTarget = false; + m_bForceUseModel = false; + m_pItem = NULL; + m_pszToolTargetItemImage = NULL; + m_iTextureID = -1; + m_iToolTargetItemTextureID = -1; + m_iOverlayTextureIDs.SetLessFunc( DefLessFunc(int) ); + m_iOverlayTextureIDs.Purge(); + m_bImageNotLoaded = false; + m_bGreyedOut = false; + m_bModelIsHidden = false; + m_bUseRenderTargetAsIcon = false; + + m_bWeaponAllowInspect = false; + m_pCachedWeaponIcon = NULL; + m_pCachedWeaponMaterial = NULL; + m_iCachedTextureID = -1; + + m_flModelRotateYawSpeed = 0; + + m_bUsePedestal = false; + m_bOfflineIconGeneration = false; + + m_pItemParticle = NULL; + +#ifdef STAGING_ONLY + m_flStartUpdateTime = 0.0; +#endif // STAGING_ONLY +} + + +CEmbeddedItemModelPanel::~CEmbeddedItemModelPanel() +{ + CleanUpCachedWeaponIcon(); + + SafeDeleteParticleData( &m_pItemParticle ); +} + + +void CEmbeddedItemModelPanel::CleanUpCachedWeaponIcon() +{ + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + + SafeRelease( &m_pCachedWeaponIcon ); + SafeRelease( &m_pCachedWeaponMaterial ); + + if ( m_iCachedTextureID != -1 ) + { + surface()->DeleteTextureByID( m_iCachedTextureID ); + m_iCachedTextureID = -1; + } + + // If we match a cache here, clear it so we redraw once when we appear. + for ( int i = 0; i < ITEM_MODEL_IMAGE_CACHE_SIZE; i++ ) + { + bool bMatch = g_ItemModelImageCache[i].m_hModelPanelLock.Get() == this; + if ( bMatch ) + { + g_ItemModelImageCache[i].Clear(); + } + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEmbeddedItemModelPanel::UpdateCameraForIcon() +{ + if ( m_iCameraAttachment == -1 ) + return; + + studiohdr_t *pItemStudioHdr = m_RootMDL.m_MDL.GetStudioHdr(); + if ( pItemStudioHdr ) + { + matrix3x4_t matBoneToWorld[MAXSTUDIOBONES]; + m_RootMDL.m_MDL.SetUpBones( m_RootMDL.m_MDLToWorld, MAXSTUDIOBONES, matBoneToWorld ); + + // Get attachment transform + mstudioattachment_t attach = pItemStudioHdr->pAttachment( m_iCameraAttachment ); + matrix3x4_t matLocalToWorld; + ConcatTransforms( matBoneToWorld[ attach.localbone ], attach.local, matLocalToWorld ); + + QAngle angCameraAngles; + Vector vecCameraPos; + MatrixAngles( matLocalToWorld, angCameraAngles, vecCameraPos ); + SetCameraOffset( vec3_origin ); + SetCameraPositionAndAngles( vecCameraPos, angCameraAngles ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEmbeddedItemModelPanel::SetItem( CEconItemView *pItem ) +{ + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + + m_iTextureID = -1; + m_iToolTargetItemTextureID = -1; + m_iOverlayTextureIDs.Purge(); + CleanUpCachedWeaponIcon(); + SafeDeleteParticleData( &m_pItemParticle ); + + // reset all models + SetMDL( MDLHANDLE_INVALID ); + m_ItemModel.m_bDisabled = true; + m_ItemModel.m_MDL.SetMDL( MDLHANDLE_INVALID ); + m_StatTrackModel.m_bDisabled = true; + m_StatTrackModel.m_MDL.SetMDL( MDLHANDLE_INVALID ); + + m_AttachedModels.Purge(); + + m_iCameraAttachment = -1; + + m_pItem = pItem; + + if ( !m_pItem ) + return; + + const char* pszInventoryImage = m_pItem->IsValid() ? m_pItem->GetInventoryImage() : NULL; + if ( ( pszInventoryImage && pszInventoryImage[0] && !g_pMaterialSystem->IsMaterialLoaded( pszInventoryImage ) ) +#ifdef STAGING_ONLY + || tf_test_loading_panels.GetBool() +#endif + ) + { + m_bImageNotLoaded = true; + } + + if ( !m_pItem->IsValid() ) + return; + + float flValue; + static CSchemaAttributeDefHandle pAttrib_ToolTarget( "tool target item" ); + if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( m_pItem, pAttrib_ToolTarget, &flValue ) ) + { + const CEconItemDefinition *pTargetDef = GetItemSchema()->GetItemDefinition( flValue ); + + m_pszToolTargetItemImage = pTargetDef->GetInventoryImage(); + } + else + { + m_pszToolTargetItemImage = NULL; + } + +#ifdef STAGING_ONLY + if ( tf_paint_kit_show_unique_icon.GetBool() ) +#endif // STAGING_ONLY + { + float flInspect = 0; + static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" ); + if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( m_pItem, pAttrib_WeaponAllowInspect, &flInspect ) ) + { + m_bWeaponAllowInspect = flInspect != 0; + +#ifdef STAGING_ONLY + if ( m_flStartUpdateTime == 0 ) + m_flStartUpdateTime = Plat_FloatTime(); +#endif // STAGING_ONLY + } + else + { + m_bWeaponAllowInspect = false; + +#ifdef STAGING_ONLY + m_flStartUpdateTime = 0.0; +#endif // STAGING_ONLY + } + } + + float flUseCacheIcon = 0.f; + static CSchemaAttributeDefHandle pAttrib_UseModelCacheIcon( "use_model_cache_icon" ); + if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( m_pItem, pAttrib_UseModelCacheIcon, &flUseCacheIcon ) && flUseCacheIcon != 0.f ) + { + m_bUseRenderTargetAsIcon = true; + } + else + { + m_bUseRenderTargetAsIcon = false; + } + + if ( !m_bModelIsHidden ) + { + if ( !m_pItem->GetInventoryImage() || IsForcingModelUsage() || m_bWeaponAllowInspect || UseRenderTargetAsIcon() ) + { + const char *pszModelName = m_pItem->GetPlayerDisplayModel( 0, 0 ); + if ( pszModelName ) + { + CMDL *pMDL = NULL; +#ifndef PORTAL2 // DOTA COME BACK + if ( m_bUsePedestal ) + { + MDLHandle_t hPedestalMDL = mdlcache->FindMDL( "models/weapons/pedestal/pedestal.mdl" ); + SetMDL( hPedestalMDL, NULL ); + mdlcache->Release( hPedestalMDL ); // counterbalance addref from within FindMDL + + MDLHandle_t hItemMDL = mdlcache->FindMDL( pszModelName ); + if ( mdlcache->IsErrorModel( hItemMDL ) ) + { + hItemMDL = MDLHANDLE_INVALID; + } + m_ItemModel.m_MDL.SetMDL( hItemMDL ); + mdlcache->Release( hItemMDL ); // counterbalance addref from within FindMDL + + pMDL = &m_ItemModel.m_MDL; + } + else + { + MDLHandle_t hMDL = mdlcache->FindMDL( pszModelName ); + SetMDL( hMDL, static_cast<IClientRenderable*>( m_pItem ) ); + mdlcache->Release( hMDL ); // counterbalance addref from within FindMDL + + pMDL = &m_RootMDL.m_MDL; + } +#endif + + if ( pMDL ) + { + studiohdr_t *pItemStudioHdr = pMDL->GetStudioHdr(); + if ( pItemStudioHdr ) + { + // Get the appropriate attachment + CStudioHdr HDR( pItemStudioHdr, g_pMDLCache ); + if ( m_bUsePedestal ) + { + m_iPedestalAttachment = Studio_FindAttachment( &HDR, "pedestal_0" ); + if ( m_iPedestalAttachment != -1 ) + { + m_ItemModel.m_MDL.m_pProxyData = static_cast<IClientRenderable*>(m_pItem); + m_ItemModel.m_bDisabled = false; + m_ItemModel.m_MDL.m_nSequence = ACT_IDLE; + SetIdentityMatrix( m_ItemModel.m_MDLToWorld ); + } + } + else + { + m_iCameraAttachment = Studio_FindAttachment( &HDR, "icon_camera" ); + UpdateCameraForIcon(); + } + + // should we override this model bodygroup + const CEconStyleInfo *pStyle = m_pItem->GetItemDefinition()->GetStyleInfo( m_pItem->GetStyle() ); + if ( pStyle && pStyle->GetBodygroupName() != NULL ) + { + int iBodyGroup = ::FindBodygroupByName( &HDR, pStyle->GetBodygroupName() ); + if ( iBodyGroup != -1 ) + { + ::SetBodygroup( &HDR, pMDL->m_nBody, iBodyGroup, pStyle->GetBodygroupSubmodelIndex() ); + } + } + } + } + + // Attach Models + // Attach the models for the item + { + int iTeam = m_pItem->GetItemDefinition()->GetBestVisualTeamData( m_pItem->GetTeamNumber() ); + { + // Set attached models if viewable third-person. + const int iNumAttachedModels = m_pItem->GetItemDefinition()->GetNumAttachedModels( iTeam ); + for ( int i = 0; i < iNumAttachedModels; ++i ) + { + attachedmodel_t *pModel = m_pItem->GetItemDefinition()->GetAttachedModelData( iTeam, i ); + LoadAttachedModel( pModel ); + } + } + + // Festive + static CSchemaAttributeDefHandle pAttr_is_festivized( "is_festivized" ); + if ( pAttr_is_festivized && m_pItem->FindAttribute( pAttr_is_festivized ) ) + { + const int iNumAttachedModels = m_pItem->GetItemDefinition()->GetNumAttachedModelsFestivized( iTeam ); + for ( int i = 0; i < iNumAttachedModels; ++i ) + { + attachedmodel_t *pModel = m_pItem->GetItemDefinition()->GetAttachedModelDataFestivized( iTeam, i ); + LoadAttachedModel( pModel ); + } + } + } + + // Stattrak + CAttribute_String attrModule; + static CSchemaAttributeDefHandle pAttr_module( "weapon_uses_stattrak_module" ); + if ( m_pItem->FindAttribute( pAttr_module, &attrModule ) && attrModule.has_value() ) + { + // Allow for already strange items + bool bIsStrange = false; + if ( m_pItem->GetQuality() == AE_STRANGE ) + { + bIsStrange = true; + } + + if ( !bIsStrange ) + { + // Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply + for ( int i = 0; i < GetKillEaterAttrCount(); i++ ) + { + if ( m_pItem->FindAttribute( GetKillEaterAttr_Score( i ) ) ) + { + bIsStrange = true; + break; + } + } + } + + if ( bIsStrange ) + { + static CSchemaAttributeDefHandle pAttr_moduleScale( "weapon_stattrak_module_scale" ); + // Does it have a stat track module + m_flStatTrackScale = 1.0f; + uint32 unFloatAsUint32 = 1; + if ( m_pItem->FindAttribute( pAttr_moduleScale, &unFloatAsUint32 ) ) + { + m_flStatTrackScale = (float&)unFloatAsUint32; + } + + MDLHandle_t hStatTrackMDL = mdlcache->FindMDL( "models/weapons/c_models/stattrack.mdl" ); + if ( mdlcache->IsErrorModel( hStatTrackMDL ) ) + { + hStatTrackMDL = MDLHANDLE_INVALID; + } + m_StatTrackModel.m_MDL.SetMDL( hStatTrackMDL ); + mdlcache->Release( hStatTrackMDL ); // counterbalance addref from within FindMDL + + m_StatTrackModel.m_MDL.m_pProxyData = static_cast<IClientRenderable*>(pItem); + m_StatTrackModel.m_bDisabled = false; + m_StatTrackModel.m_MDL.m_nSequence = ACT_IDLE; + SetIdentityMatrix( m_StatTrackModel.m_MDLToWorld ); + } + } + + int iTeam = GetLocalPlayerTeam(), + iSkin = iTeam; + +#ifdef TF_CLIENT_DLL + // If we aren't in a game we default to previewing the red team skin. + if ( iTeam == TEAM_UNASSIGNED ) + { + iTeam = TF_TEAM_RED; + } +#endif // TF_CLIENT_DLL + + if ( iSkin != TEAM_UNASSIGNED ) + { + // Use the first skin for the first team, and the second skin for the other (but default to 0) + iSkin = (iSkin == (FIRST_GAME_TEAM+1)) ? 1 : 0; + } + + // Handle styles/visuals overriding the skin. + int iOverrideSkin = m_pItem->GetSkin( iTeam ); + if ( iOverrideSkin != -1 ) + { + iSkin = iOverrideSkin; + } + + SetSkin( iSkin ); + + if ( m_bUsePedestal ) + { + m_ItemModel.m_MDL.m_nSkin = iSkin; + } + } + } + } +} + +void CEmbeddedItemModelPanel::LoadAttachedModel( attachedmodel_t *pModel ) +{ + if ( !( pModel->m_iModelDisplayFlags & kAttachedModelDisplayFlag_WorldModel ) ) + return; + + if ( !pModel->m_pszModelName ) + { + Warning( "econ item definition '%s' attachment has no model\n", m_pItem->GetItemDefinition()->GetDefinitionName() ); + return; + } + + int iIndex = m_AttachedModels.AddToTail(); + MDLHandle_t hMDL = mdlcache->FindMDL( pModel->m_pszModelName ); + if ( mdlcache->IsErrorModel( hMDL ) ) + { + hMDL = MDLHANDLE_INVALID; + } + m_AttachedModels[iIndex].m_MDL.SetMDL( hMDL ); + mdlcache->Release( hMDL ); // counterbalance addref from within FindMDL + + m_AttachedModels[iIndex].m_MDL.m_pProxyData = static_cast<IClientRenderable*>( m_pItem ); + m_AttachedModels[iIndex].m_bDisabled = false; + m_AttachedModels[iIndex].m_MDL.m_nSequence = ACT_IDLE; + SetIdentityMatrix( m_AttachedModels[iIndex].m_MDLToWorld ); +} + +bool CEmbeddedItemModelPanel::IsLoadingWeaponSkin( void ) const +{ + static ConVarRef mat_dxlevel( "mat_dxlevel" ); + if ( mat_dxlevel.GetInt() < 90 ) + return false; + + if ( m_bForceUseModel ) + return false; + + if ( m_pItem && m_pItem->IsValid() ) + { + if ( m_bWeaponAllowInspect && m_pItem->GetCustomPainkKitDefinition() ) + { + return m_pItem->GetWeaponSkinBaseCompositor() != NULL || !m_pCachedWeaponIcon || !m_pCachedWeaponIcon->GetTexture(); + } + else if ( UseRenderTargetAsIcon() ) + { + return !m_pCachedWeaponIcon || !m_pCachedWeaponIcon->GetTexture(); + } + } + + return false; +} + + +bool CEmbeddedItemModelPanel::IsImageNotLoaded( void ) const +{ + if ( m_bForceUseModel ) + return false; + + if ( m_bImageNotLoaded && m_pItem && m_pItem->IsValid() ) + return true; + + return false; +} + + +IMaterial* GetMaterialForImage( CEmbeddedItemModelPanel::InventoryImageType_t eImageType, const char* pszBaseName ) +{ + IMaterial *pMaterial = NULL; + + Assert( pszBaseName ); + if ( !pszBaseName ) + return NULL; + +#ifdef STAGING_ONLY + if ( eImageType == CEmbeddedItemModelPanel::IMAGETYPE_SMALL && tf_force_highres_item_image.GetBool() ) + { + eImageType = CEmbeddedItemModelPanel::IMAGETYPE_LARGE; + } +#endif // STAGING_ONLY + + switch ( eImageType ) + { + case CEmbeddedItemModelPanel::IMAGETYPE_SMALL: + pMaterial = g_pMaterialSystem->FindMaterial( pszBaseName, TEXTURE_GROUP_VGUI ); + break; + case CEmbeddedItemModelPanel::IMAGETYPE_DETAILED: + pMaterial = g_pMaterialSystem->FindMaterial( CFmtStr("%s_detail",pszBaseName).Access(), TEXTURE_GROUP_VGUI, false ); + break; + case CEmbeddedItemModelPanel::IMAGETYPE_LARGE: + pMaterial = g_pMaterialSystem->FindMaterial( CFmtStr("%s_large",pszBaseName).Access(), TEXTURE_GROUP_VGUI ); + break; + default: + Assert(0); + } + + Assert( pMaterial && !IsErrorMaterial( pMaterial ) ); + + return pMaterial; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEmbeddedItemModelPanel::LoadInventoryImage() +{ + InventoryImageType_t type = (InventoryImageType_t)m_iInventoryImageType; + if ( m_iInventoryImageType == IMAGETYPE_DETAILED && !m_pItem->GetStaticData()->HasDetailedIcon() ) + { + type = IMAGETYPE_LARGE; + } + GetMaterialForImage( type, m_pItem->GetInventoryImage() ); + m_bImageNotLoaded = false; + m_iTextureID = -1; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEmbeddedItemModelPanel::PerformLayout( void ) +{ + BaseClass::PerformLayout(); + + CleanUpCachedWeaponIcon(); + + // Nive the "player pos" to the defined distance + if ( m_pItem && m_pItem->IsValid() ) + { + if ( m_bUsePedestal ) + { + Vector vecOffset = m_BMPResData.m_vecOriginOffset; + vecOffset.x = m_pItem->GetItemDefinition()->GetInspectPanelDistance(); + // reset model angle and pos to initial values + SetModelAnglesAndPosition( m_BMPResData.m_angModelPoseRot, vecOffset ); + } + else if ( m_iCameraAttachment != -1 ) + { + UpdateCameraForIcon(); + } + } +} + +#ifdef STAGING_ONLY +static double s_min_time = FLT_MAX; +static double s_max_time = 0.f; +static double s_total_time = 0.f; +#endif // STAGING_ONLY + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEmbeddedItemModelPanel::Paint( void ) +{ + if ( !m_pItem || !m_pItem->IsValid() ) + return; + + if ( m_bModelIsHidden ) + { + BaseClass::Paint(); + return; + } + + // Don't even try to render backpack icon if we're not loaded + if ( m_bImageNotLoaded && !m_bWeaponAllowInspect && !UseRenderTargetAsIcon() ) + return; + + const char *pszInventoryImage = m_pItem->GetInventoryImage(); + + CMatRenderContextPtr pRenderContext( materials ); + + int iWidth = GetWide(); + int iHeight = GetTall(); + float flTexW = 1.0; + float flTexH = 1.0; + float flTexX = 0.0; + float flTexY = 0.0; + int x = 0; + int y = 0; + + // First, try and use the inventory image instead of the model. + bool bIsLoadingWeaponSkin = IsLoadingWeaponSkin(); + + int iTexture = -1; + if ( !bIsLoadingWeaponSkin && !m_bForceUseModel ) + { + // should we override material with cache texture + if ( m_pCachedWeaponIcon && m_pCachedWeaponIcon->GetTexture() ) + { + // Clear out the composited texture--we're finished with it. + m_pItem->SetWeaponSkinBase( NULL ); + // The compositor should have been cleaned up by the material proxy. + Assert( m_pItem->GetWeaponSkinBaseCompositor() == NULL ); + + if ( !m_pCachedWeaponMaterial && g_pMaterialSystem ) + { + const char *pszTextureName = m_pCachedWeaponIcon->GetTexture()->GetName(); + KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" ); + pVMTKeyValues->SetString( "$basetexture", pszTextureName ); + pVMTKeyValues->SetInt( "$translucent", 1 ); + pVMTKeyValues->SetInt( "$vertexcolor", 1 ); + IMaterial *pMaterial = g_pMaterialSystem->FindProceduralMaterial( pszTextureName, TEXTURE_GROUP_VGUI, pVMTKeyValues ); + SafeAssign( &m_pCachedWeaponMaterial, pMaterial ); + + bool bFound = false; + IMaterialVar *pVar = m_pCachedWeaponMaterial->FindVar( "$basetexture", &bFound ); + if ( bFound && pVar ) + { + pVar->SetTextureValue( m_pCachedWeaponIcon->GetTexture() ); + m_pCachedWeaponMaterial->RefreshPreservingMaterialVars(); + } + } + + if ( m_iCachedTextureID == -1 ) + { + //m_pCachedWeaponIcon->GetTexture()->SaveToFile( CFmtStr( "%d_weapon_skin_cache.tga", m_pItem->GetItemDefIndex() ) ); + m_iCachedTextureID = g_pMatSystemSurface->DrawGetTextureId( m_pCachedWeaponIcon->GetTexture() ); + g_pMatSystemSurface->DrawSetTextureMaterial( m_iCachedTextureID, m_pCachedWeaponMaterial ); + } + iTexture = m_iCachedTextureID; + x = 0; + y = 0; + flTexX = flTexY = 0.f; + + int iMappingWidth = m_pCachedWeaponMaterial->GetMappingWidth(); + int iMappingHeight = m_pCachedWeaponMaterial->GetMappingHeight(); + if ( iWidth > iMappingWidth || iHeight > iMappingHeight ) + { + flTexW = 1.f; + flTexH = 1.f; + } + else + { + flTexW = (float)iWidth / iMappingWidth; + flTexH = (float)iHeight / iMappingHeight; + } + +#ifdef STAGING_ONLY + if ( tf_unique_icon_perf_debug.GetBool() && m_flStartUpdateTime != 0 ) + { + double flTimeTaken = Plat_FloatTime() - m_flStartUpdateTime; + m_flStartUpdateTime = 0.0; + s_min_time = MIN( s_min_time, flTimeTaken ); + s_max_time = MAX( s_max_time, flTimeTaken ); + s_total_time += flTimeTaken; + DevMsg( "took %.3f with min %.3f max %.3f with total %.3f\n", flTimeTaken, s_min_time, s_max_time, s_total_time ); + } +#endif // STAGING_ONLY + } + else if ( pszInventoryImage ) + { + // Look up the material (use the large one if we've been told to) + IMaterial *pMaterial = GetMaterialForImage( (CEmbeddedItemModelPanel::InventoryImageType_t)m_iInventoryImageType, pszInventoryImage ); + + int iCenter[2]; + iCenter[0] = x + (iWidth * 0.5); + iCenter[1] = y + (iHeight * 0.5); + + // Maintain image aspect ratios. Fit to height. + int iPosition[2] = {0,0}; + int iSize[2] = {0,0}; + m_pItem->GetInventoryImageData( iPosition, iSize ); + + if ( m_bForceSquareImage ) + { + iSize[0] = MAX( iSize[0], iSize[1] ); + iSize[1] = iSize[0]; + } + if ( !iSize[0] && !iSize[1] ) + { + iSize[0] = pMaterial->GetMappingWidth(); + iSize[1] = pMaterial->GetMappingHeight(); + } + else + { + bool bForceHighRes = false; +#ifdef STAGING_ONLY + bForceHighRes = tf_force_highres_item_image.GetBool(); +#endif // STAGING_ONLY + if ( m_iInventoryImageType != IMAGETYPE_SMALL || bForceHighRes ) + { + // Normal is 128*128, large is 512x512 + iSize[0] *= 4; + iSize[1] *= 4; + } + + flTexW = ((float)iSize[0] / (float)pMaterial->GetMappingWidth()); + flTexH = ((float)iSize[1] / (float)pMaterial->GetMappingHeight()); + flTexX = ( 1.0 - flTexW ) * 0.5; + flTexY = ( 1.0 - flTexH ) * 0.5; + } + if ( iPosition[0] || iPosition[1] ) + { + x += XRES(iPosition[0]); + y += YRES(iPosition[1]); + } + + float flRatio = ((float)iSize[0] / (float)iSize[1]); + if ( flRatio != ((float)iWidth / (float)iHeight) ) + { + // Fit to the height + int iCenterX = x + (iWidth * 0.5); + iWidth = iHeight * flRatio; + x = iCenterX - (iWidth * 0.5); + } + + // Reload our texture, if we need to + if ( m_iTextureID == -1 ) + { + m_iTextureID = vgui::surface()->DrawGetTextureId( pMaterial->GetName() ); + + // If we didn't find it, create a new one + if ( m_iTextureID == -1 ) + { + m_iTextureID = vgui::surface()->CreateNewTextureID(); + g_pMatSystemSurface->DrawSetTextureMaterial( m_iTextureID, pMaterial ); + } + } + + iTexture = m_iTextureID; + } + } + + // draw texture if we have a valid texture + if ( iTexture != -1 ) + { + surface()->DrawSetTexture( iTexture ); + + if ( m_bGreyedOut ) + { + surface()->DrawSetColor( 96, 96, 96, 255 ); + } + else + { + surface()->DrawSetColor( 255, 255, 255, 255 ); + } + surface()->DrawTexturedSubRect( x, y, x + iWidth, y + iHeight, flTexX, flTexY, flTexX + flTexW, flTexY + flTexH ); + + // Draw the overlay image now, and tint it by the tint attribute (if we have one) + for ( int i=0; i<m_pItem->GetInventoryOverlayImageCount(); i++ ) + { + const char *pszInventoryOverlayImage = m_pItem->GetInventoryOverlayImage( i ); + IMaterial *pOverlayMaterial = GetMaterialForImage( (CEmbeddedItemModelPanel::InventoryImageType_t)m_iInventoryImageType, pszInventoryOverlayImage ); + + if ( !pOverlayMaterial ) + continue; + + int iTextureIDIdx = m_iOverlayTextureIDs.Find(i); + if ( (iTextureIDIdx == m_iOverlayTextureIDs.InvalidIndex() + || m_iOverlayTextureIDs[iTextureIDIdx] == -1 ) ) + { + int iTextureID = vgui::surface()->DrawGetTextureId( pOverlayMaterial->GetName() ); + + // If we didn't find it, create a new one + if ( iTextureID == -1 ) + { + iTextureID = vgui::surface()->CreateNewTextureID(); + g_pMatSystemSurface->DrawSetTextureMaterial( iTextureID, pOverlayMaterial ); + } + + m_iOverlayTextureIDs.Insert( i, iTextureID ); + } + + surface()->DrawSetTexture( m_iOverlayTextureIDs[m_iOverlayTextureIDs.Find( i )] ); + + int iRGB = m_pItem->GetModifiedRGBValue( i == 0 ); + Color col; + col.SetColor( clamp( (iRGB & 0xFF0000) >> 16, 0, 255 ), clamp( (iRGB & 0xFF00) >> 8, 0, 255 ), clamp( (iRGB & 0xFF), 0, 255 ), 255 ); + // Dim this color if the item is currently greyed out + float flColorScale = m_bGreyedOut ? 96.f / 255.f : 1.f; + col.SetColor( col.r() * flColorScale, col.g() * flColorScale, col.b() * flColorScale, col.a() ); + + surface()->DrawSetColor( col ); + + surface()->DrawTexturedSubRect( x, y, x + iWidth, y + iHeight, flTexX, flTexY, flTexX + flTexW, flTexY + flTexH ); + } + + // Draw strangifier item on top of strangifier bottles + if ( m_pszToolTargetItemImage && m_pszToolTargetItemImage[0] ) + { + IMaterial* pToolTargetItemMaterial = GetMaterialForImage( (CEmbeddedItemModelPanel::InventoryImageType_t)m_iInventoryImageType, m_pszToolTargetItemImage ); + + if ( m_iToolTargetItemTextureID == -1 ) + { + m_iToolTargetItemTextureID = vgui::surface()->DrawGetTextureId( pToolTargetItemMaterial->GetName() ); + + // If we didn't find it, create a new one + if ( m_iToolTargetItemTextureID == -1 ) + { + m_iToolTargetItemTextureID = vgui::surface()->CreateNewTextureID(); + g_pMatSystemSurface->DrawSetTextureMaterial( m_iToolTargetItemTextureID, pToolTargetItemMaterial ); + } + + CAttribute_String attrToolTargetItemIconOffset; + static CSchemaAttributeDefHandle pAttrDef_ToolTargetItemIconOffset( "tool_target_item_icon_offset" ); + if ( m_pItem->FindAttribute( pAttrDef_ToolTargetItemIconOffset, &attrToolTargetItemIconOffset ) && attrToolTargetItemIconOffset.has_value() ) + { + UTIL_StringToVector( m_vecToolTargetItemImageOffset.Base(), attrToolTargetItemIconOffset.value().c_str() ); + } + } + + surface()->DrawSetTexture( m_iToolTargetItemTextureID ); + + int iStrangeX = x + ( iWidth * m_vecToolTargetItemImageOffset.x ); + int iStrangeY = y + ( iHeight * m_vecToolTargetItemImageOffset.y ); + float flScale = m_vecToolTargetItemImageOffset.z; + + surface()->DrawTexturedSubRect( iStrangeX, + iStrangeY, + iStrangeX + (iWidth * flScale), + iStrangeY + (iHeight * flScale), + flTexX, + flTexY, + flTexX + (flTexW ), + flTexY + (flTexH ) ); + } + + return; + } + + item_model_cache_t *pCacheRenderTarget = NULL; + const char *pszCacheRenderTargetName = NULL; + // find available render target + for ( int i=0; i<ITEM_MODEL_IMAGE_CACHE_SIZE; ++i ) + { + CEmbeddedItemModelPanel *pLockPanel = g_ItemModelImageCache[i].m_hModelPanelLock.Get(); + + // found available render target? + if ( pLockPanel == NULL ) + { + pszCacheRenderTargetName = m_bOfflineIconGeneration ? "offline_icon_generation" : g_ItemModelPanelRenderTargetNames[i]; + pCacheRenderTarget = &g_ItemModelImageCache[i]; + break; + } + else + { + // waiting for async copy to finish + if ( pLockPanel->m_pCachedWeaponIcon && pLockPanel->m_pCachedWeaponIcon->GetTexture() ) + { + g_ItemModelImageCache[i].Clear(); + + pszCacheRenderTargetName = m_bOfflineIconGeneration ? "offline_icon_generation" : g_ItemModelPanelRenderTargetNames[i]; + pCacheRenderTarget = &g_ItemModelImageCache[i]; + break; + } + } + } + + // can't find available cache render target, don't do anything + if ( !pszCacheRenderTargetName || !pCacheRenderTarget ) + { + BaseClass::Paint(); + return; + } + + // Turn off depth-write to dest alpha so that we get white there instead. The code that uses + // the render target needs a mask of where stuff was rendered. + pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA, false ); + + bool bUseRenderTarget = !m_bForceUseModel && ( UseRenderTargetAsIcon() || bIsLoadingWeaponSkin ); + bool bRenderToTexture = m_bRenderToTexture; + if ( bUseRenderTarget ) + { + g_pMatSystemSurface->Set3DPaintTempRenderTarget( pszCacheRenderTargetName ); + } + else if ( m_bUseParticle ) + { + // we want to render particle with this model. don't render to texture + m_bRenderToTexture = false; + } + + // make sure the weapon skin is ready before we render the model + bool bDrawWeaponWithSkin = bIsLoadingWeaponSkin && m_pCachedWeaponIcon == NULL && m_pItem->GetWeaponSkinBase(); + + m_pItem->SetWeaponSkinBaseCreateFlags( TEX_COMPOSITE_CREATE_FLAGS_NO_COMPRESSION | TEX_COMPOSITE_CREATE_FLAGS_NO_MIPMAPS ); + + BaseClass::Paint(); + + m_bRenderToTexture = bRenderToTexture; + + // copy the rendered weapon skin from the render target + if ( !m_bForceUseModel && ( UseRenderTargetAsIcon() || bDrawWeaponWithSkin ) && !m_pCachedWeaponIcon ) + { + char buffer[_MAX_PATH]; + V_sprintf_safe( buffer, "proc/icon/item%d_id%lld_w%d_h%d", m_pItem->GetItemDefIndex(), m_pItem->GetID(), iWidth, iHeight ); + SafeAssign( &m_pCachedWeaponIcon, new CIconRenderReceiver() ); + + // If the icon still exists in the material system, don't bother regenerating it. + if ( materials->IsTextureLoaded( buffer ) ) + { + ITexture* resTexture = materials->FindTexture( buffer, TEXTURE_GROUP_RUNTIME_COMPOSITE, false, 0 ); + if ( resTexture && resTexture->IsError() == false ) + { + m_pCachedWeaponIcon->OnAsyncCreateComplete( resTexture, NULL ); + } + } + else + { + // No icon available yet, need to create it. + ITexture *pRenderTarget = g_pMaterialSystem->FindTexture( pszCacheRenderTargetName, TEXTURE_GROUP_RENDER_TARGET ); + if ( pRenderTarget ) + { + pRenderContext->AsyncCreateTextureFromRenderTarget( pRenderTarget, buffer, IMAGE_FORMAT_RGBA8888, false, 0, m_pCachedWeaponIcon, NULL ); + + pCacheRenderTarget->iItemID = m_pItem->GetItemID(); + pCacheRenderTarget->iItemDefinitionIndex = m_pItem->GetItemDefIndex(); + pCacheRenderTarget->iWidth = iWidth; + pCacheRenderTarget->iHeight = iHeight; + pCacheRenderTarget->m_hModelPanelLock = this; + } + } + } + + if ( bUseRenderTarget ) + { + g_pMatSystemSurface->Reset3DPaintTempRenderTarget(); + } + + if ( m_flModelRotateYawSpeed != 0 ) + { + m_angPlayer[YAW] += m_flModelRotateYawSpeed * gpGlobals->frametime; + SetModelAnglesAndPosition( m_angPlayer, m_vecPlayerPos ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +ITexture *CEmbeddedItemModelPanel::GetCachedGeneratedIcon() +{ + return m_pCachedWeaponIcon ? m_pCachedWeaponIcon->GetTexture() : NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CEmbeddedItemModelPanel::UpdateParticle( + IMatRenderContext *pRenderContext, + CStudioHdr *pStudioHdr, + MDLHandle_t mdlHandle, + matrix3x4_t *pWorldMatrix + ) +{ + if ( !m_bUseParticle ) + return false; + + if ( m_pItemParticle && m_pItemParticle->m_bIsUpdateToDate ) + return false; + + if ( !m_pItem || !m_pItem->IsValid() ) + return false; + + attachedparticlesystem_t *pParticleSystem = NULL; + + // do community_sparkle effect if this is a community item? + const int iQualityParticleType = m_pItem->GetQualityParticleType(); + if ( iQualityParticleType > 0 ) + { + pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iQualityParticleType ); + } + + if ( !pParticleSystem ) + { + // does this hat even have a particle effect + static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" ); + uint32 iValue = 0; + if ( !m_pItem->FindAttribute( pAttrDef_AttachParticleEffect, &iValue ) ) + { + return false; + } + + const float& value_as_float = (float&)iValue; + pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( value_as_float ); + } + + // failed to find any particle effect + if ( !pParticleSystem ) + { + return false; + } + + // Team Color + if ( m_pItem->GetTeamNumber() == TF_TEAM_BLUE && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_red" )) + { + static char pBlue[256]; + V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 ); + pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pBlue ); + if ( !pParticleSystem ) + { + return false; + } + } + + // if this thing has a bip_head or prp_helmet (aka a hat) + int iBone = Studio_BoneIndexByName( pStudioHdr, "bip_head" ); + if ( iBone < 0 ) + { + iBone = Studio_BoneIndexByName( pStudioHdr, "prp_helmet" ); + if ( iBone < 0 ) + { + iBone = Studio_BoneIndexByName( pStudioHdr, "prp_hat" ); + } + } + + // default to root + if ( iBone < 0 ) + { + iBone = 0; + } + + // Get Use Head Origin + CUtlVector< int > vecAttachments; + static CSchemaAttributeDefHandle pAttrDef_UseHead( "particle effect use head origin" ); + uint32 iUseHead = 0; + if ( !m_pItem->FindAttribute( pAttrDef_UseHead, &iUseHead ) || !iUseHead == 0 ) + { + // not using head? try searching for attachment points + for ( int i=0; i<ARRAYSIZE( pParticleSystem->pszControlPoints ); ++i ) + { + const char *pszAttachmentName = pParticleSystem->pszControlPoints[i]; + if ( pszAttachmentName && pszAttachmentName[0] ) + { + int iAttachment = Studio_FindAttachment( pStudioHdr, pszAttachmentName ); + if ( iAttachment < 0 ) + continue; + + vecAttachments.AddToTail( iAttachment ); + } + } + } + + static char pszFullname[256]; + const char* pszSystemName = pParticleSystem->pszSystemName; + // Weapon Remap for a Base Effect to be used on a specific weapon + if ( pParticleSystem->bUseSuffixName && m_pItem && m_pItem->GetItemDefinition()->GetParticleSuffix() ) + { + V_strcpy_safe( pszFullname, pParticleSystem->pszSystemName ); + V_strcat_safe( pszFullname, "_" ); + V_strcat_safe( pszFullname, m_pItem->GetItemDefinition()->GetParticleSuffix() ); + pszSystemName = pszFullname; + } + + // Update the Particles and render them + if ( m_pItemParticle ) + { + // Check if its a new particle system + if ( V_strcmp( m_pItemParticle->m_pParticleSystem->GetName(), pszSystemName ) ) + { + SafeDeleteParticleData( &m_pItemParticle ); + m_pItemParticle = CreateParticleData( pszSystemName ); + } + } + else + { + // create + m_pItemParticle = CreateParticleData( pszSystemName ); + } + + // Particle system does not exist + if ( !m_pItemParticle ) + return false; + + // Get offset if it exists (and if we're using head offset) + static CSchemaAttributeDefHandle pAttrDef_VerticalOffset( "particle effect vertical offset" ); + uint32 iOffset = 0; + Vector vecParticleOffset( 0, 0, 0 ); + if ( iUseHead > 0 && m_pItem->FindAttribute( pAttrDef_VerticalOffset, &iOffset ) ) + { + vecParticleOffset.z = (float&)iOffset; + } + + m_pItemParticle->UpdateControlPoints( pStudioHdr, pWorldMatrix, vecAttachments, 0, vecParticleOffset ); + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CEmbeddedItemModelPanel::RenderStatTrack( CStudioHdr *pStudioHdr, matrix3x4_t *pWorldMatrix ) +{ + // Draw the merge MDLs. + if ( !m_StatTrackModel.m_bDisabled ) + { + matrix3x4_t matMergeBoneToWorld[MAXSTUDIOBONES]; + + // Get the merge studio header. + studiohdr_t *pStatTrackStudioHdr = m_StatTrackModel.m_MDL.GetStudioHdr(); + matrix3x4_t *pMergeBoneToWorld = &matMergeBoneToWorld[0]; + + // If we have a valid mesh, bonemerge it. If we have an invalid mesh we can't bonemerge because + // it'll crash trying to pull data from the missing header. + if ( pStatTrackStudioHdr != NULL ) + { + CStudioHdr mergeHdr( pStatTrackStudioHdr, g_pMDLCache ); + m_StatTrackModel.m_MDL.SetupBonesWithBoneMerge( &mergeHdr, pMergeBoneToWorld, pStudioHdr, pWorldMatrix, m_StatTrackModel.m_MDLToWorld ); + for ( int i=0; i<mergeHdr.numbones(); ++i ) + { + MatrixScaleBy( m_flStatTrackScale, pMergeBoneToWorld[i] ); + } + m_StatTrackModel.m_MDL.Draw( m_StatTrackModel.m_MDLToWorld, pMergeBoneToWorld ); + } + + return true; + } + + return false; +} + +bool CEmbeddedItemModelPanel::RenderAttachedModels( CStudioHdr *pStudioHdr, matrix3x4_t *pWorldMatrix ) +{ + // Draw the merge MDLs. + FOR_EACH_VEC( m_AttachedModels, iModel ) + { + matrix3x4_t matMergeBoneToWorld[MAXSTUDIOBONES]; + + // Get the merge studio header. + studiohdr_t *pAttachedStudioHdr = m_AttachedModels[iModel].m_MDL.GetStudioHdr(); + matrix3x4_t *pMergeBoneToWorld = &matMergeBoneToWorld[0]; + + // If we have a valid mesh, bonemerge it. If we have an invalid mesh we can't bonemerge because + // it'll crash trying to pull data from the missing header. + if ( pAttachedStudioHdr != NULL ) + { + CStudioHdr mergeHdr( pAttachedStudioHdr, g_pMDLCache ); + m_AttachedModels[iModel].m_MDL.SetupBonesWithBoneMerge( &mergeHdr, pMergeBoneToWorld, pStudioHdr, pWorldMatrix, m_AttachedModels[iModel].m_MDLToWorld ); + m_AttachedModels[iModel].m_MDL.Draw( m_AttachedModels[iModel].m_MDLToWorld, pMergeBoneToWorld ); + } + } + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEmbeddedItemModelPanel::RenderingRootModel( IMatRenderContext *pRenderContext, CStudioHdr *pStudioHdr, MDLHandle_t mdlHandle, matrix3x4_t *pWorldMatrix ) +{ + // No model? Bail + if ( m_ItemModel.m_bDisabled ) + { + // no model means not using pedestal. just use pStudioHdr to find the attachment points + UpdateParticle( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix ); + RenderStatTrack( pStudioHdr, pWorldMatrix ); + RenderAttachedModels( pStudioHdr, pWorldMatrix ); + return; + } + + studiohdr_t *pItemStudioHdr = m_ItemModel.m_MDL.GetStudioHdr(); + + if ( pItemStudioHdr != NULL ) + { + matrix3x4_t matIdentity; + SetIdentityMatrix( matIdentity ); + + matrix3x4_t *pBoneToWorld = g_pStudioRender->LockBoneMatrices( pItemStudioHdr->numbones ); + m_ItemModel.m_MDL.SetUpBones( matIdentity, pItemStudioHdr->numbones, pBoneToWorld ); + + // Get attachment transform + mstudioattachment_t attach = pItemStudioHdr->pAttachment( m_iPedestalAttachment ); + matrix3x4_t matLocalToWorld; + matrix3x4_t matWorldToLocal; + matrix3x4_t matTransform; + + ConcatTransforms( pBoneToWorld[ attach.localbone ], attach.local, matLocalToWorld ); + MatrixInvert( matLocalToWorld, matWorldToLocal ); + ConcatTransforms( m_RootMDL.m_MDLToWorld, matWorldToLocal, matTransform ); + + m_ItemModel.m_MDL.SetUpBones( matTransform, pItemStudioHdr->numbones, pBoneToWorld ); + + g_pStudioRender->UnlockBoneMatrices(); + + IMaterial* pOverrideMaterial = GetOverrideMaterial( m_ItemModel.m_MDL.GetMDL() ); + if ( pOverrideMaterial != NULL ) + g_pStudioRender->ForcedMaterialOverride( pOverrideMaterial ); + + m_ItemModel.m_MDL.Draw( m_ItemModel.m_MDLToWorld, pBoneToWorld ); + + if ( pOverrideMaterial != NULL ) + g_pStudioRender->ForcedMaterialOverride( NULL ); + + CStudioHdr HDR( pItemStudioHdr, g_pMDLCache ); + + // update particle with the actual item model pItemStudioHdr + UpdateParticle( pRenderContext, &HDR, mdlHandle, pBoneToWorld ); + RenderStatTrack( &HDR, pBoneToWorld ); + RenderAttachedModels( &HDR, pBoneToWorld ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +IMaterial *CEmbeddedItemModelPanel::GetOverrideMaterial( MDLHandle_t mdlHandle ) +{ + // This matches the check in RenderingRootModel, if we're not on a pedestal + // then we expect mdlHandle to not match m_ItemModel and that's fine--we should + // just get the override from the m_pItem + if ( !m_ItemModel.m_bDisabled && m_ItemModel.m_MDL.GetMDL() != mdlHandle ) + return NULL; + + if ( !m_pItem ) + return NULL; + + int iTeam = GetLocalPlayerTeam(); + +#ifdef TF_CLIENT_DLL + // If we aren't in a game we default to previewing the red team skin. + if ( iTeam == TEAM_UNASSIGNED ) + { + iTeam = TF_TEAM_RED; + } +#endif + + return m_pItem->GetMaterialOverride( iTeam ); +} + + +float CItemModelPanel::sm_flLoadingTimeThisFrame = 0.0f; +int CItemModelPanel::sm_nCurrentDecriptionUpdateFrame = 0; +CItemModelPanel::eLoadingType_t CItemModelPanel::se_CurrentLoadingTask = LOADING_ICONS; +int CItemModelPanel::sai_NumLoadingRequests[NUM_LOADING_TYPES] = {0,0,0}; +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CItemModelPanel::CItemModelPanel( vgui::Panel *parent, const char *name ) : vgui::EditablePanel( parent, name ) +{ + m_pModelPanel = NULL; + m_pItemNameLabel = NULL; + m_pPaintIcon = NULL; + m_pTF2Icon = NULL; + m_pItemAttribLabel = NULL; + m_pItemCollectionNameLabel = NULL; + m_pItemCollectionListLabel = NULL; + m_pItemCollectionHighlight = NULL; + m_pItemEquippedLabel = NULL; + m_pItemQuantityLabel = NULL; + m_pVisionRestrictionImage = NULL; + m_pIsStrangeImage = NULL; + m_pIsUnusualImage = NULL; + m_pIsLoanerImage = NULL; + m_pSeriesLabel = NULL; + m_pMainContentContainer = NULL; + m_pLoadingSpinner = NULL; +// m_ItemData = NULL; + m_nCollectionItemLoaded = LOADED_COLLECTION_NONE; + m_pFontNameSmallest = vgui::INVALID_FONT; + m_pFontNameSmall = vgui::INVALID_FONT; + m_pFontNameLarge = vgui::INVALID_FONT; + m_pFontAttribSmallest = vgui::INVALID_FONT; + m_pFontAttribSmall = vgui::INVALID_FONT; + m_pFontAttribLarge = vgui::INVALID_FONT; + + m_pszNoItemText = NULL; + m_pwcNoItemText = NULL; + m_pwcNoItemAttrib = NULL; + REGISTER_COLOR_AS_OVERRIDABLE( m_NoItemTextColor, "noitem_textcolor" ); + + m_bClickable = false; + m_bMouseOver = false; + m_bSelected = false; + m_bShowEquipped = false; + m_bForceShowEquipped = false; + m_bShowQuantity = false; + m_pszGreyedOutReason = NULL; + m_bShowGreyedOutTooltip = false; + m_bShouldSendPanelEnterExits = false; + m_bContainedItem = false; + m_bShowOthersGiftWrappedItems = false; + m_bDescriptionDirty = false; + m_nRecipeMatchingIndex = 0; + + m_pContainedItemPanel = NULL; + + m_bFakeButton = false; + + m_mapMatchingAttributes.SetLessFunc( DefLessFunc( attrib_definition_index_t ) ); + + SetActAsButton( false, false ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CItemModelPanel::~CItemModelPanel( void ) +{ + CleanupNoItemWChars(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::ApplySchemeSettings( vgui::IScheme *pScheme ) +{ + BaseClass::ApplySchemeSettings( pScheme ); + // These pointers must be zeroed here because their memory may be freed + // by LoadControlSettings *and* if they remain non-zero they may be dereferenced + // before LoadControlSettings returns. This causes reliable crashes if you + // go to the store, shop, change resolutions, then return to the store -- and + // if you use pageheap/AppVerifier. + // This set of pointers is simply the set of pointers that are initialized after + // LoadControlSettings. + m_pModelPanel = NULL; + m_pItemNameLabel = NULL; + m_pItemAttribLabel = NULL; + m_pItemCollectionNameLabel = NULL; + m_pItemCollectionListLabel = NULL; + m_pItemEquippedLabel = NULL; + m_pItemQuantityLabel = NULL; + m_pVisionRestrictionImage = NULL; + m_pIsStrangeImage = NULL; + m_pIsUnusualImage = NULL; + m_pIsLoanerImage = NULL; + m_pSeriesLabel = NULL; + m_pMatchesLabel = NULL; + m_pPaintIcon = NULL; + m_pTF2Icon = NULL; + m_pFontNameSmallest = NULL; + m_pFontNameSmall = NULL; + m_pFontNameLarge = NULL; + m_pFontNameLarger = NULL; + m_pFontAttribSmallest = NULL; + m_pFontAttribSmall = NULL; + m_pFontAttribLarge = NULL; + m_pFontAttribLarger = NULL; + m_pContainedItemPanel = NULL; + m_pMainContentContainer = NULL; + m_pLoadingSpinner = NULL; + m_nCollectionItemLoaded = LOADED_COLLECTION_NONE; + LoadResFileForCurrentItem( true ); + + m_pFontNameSmallest = pScheme->GetFont( "ItemFontNameSmallest", true ); + m_pFontNameSmall = pScheme->GetFont( "ItemFontNameSmall", true ); + m_pFontNameLarge = pScheme->GetFont( "ItemFontNameLarge", true ); + m_pFontNameLarger = pScheme->GetFont( "ItemFontNameLarger", true ); + m_pFontAttribSmallest = pScheme->GetFont( "ItemFontAttribSmallest", true ); + m_pFontAttribSmall = pScheme->GetFont( "ItemFontAttribSmallv2", true ); + m_pFontAttribLarge = pScheme->GetFont( "ItemFontAttribLarge", true ); + m_pFontAttribLarger = pScheme->GetFont( "ItemFontAttribLarger", true ); + + if ( m_bContainedItem ) + { + // SetBorder( pScheme->GetBorder("TFThinLineBorder") ); + } + else + { + SetBorder( pScheme->GetBorder( "TFFatLineBorder" ) ); + } + + if ( m_pModelPanel ) + { + m_pModelPanel->SetBorder( pScheme->GetBorder( "TFFatLineBorder" ) ); + } +} + +void CItemModelPanel::ApplySettings( KeyValues *inResourceData ) +{ + if ( !inResourceData ) + return; + + BaseClass::ApplySettings( inResourceData ); + + // Pass the itemmodelpanel KVs to the actual model panel + KeyValues* pItemModelPanelKVs = inResourceData->FindKey( "itemmodelpanel" ); + if ( m_pModelPanel && pItemModelPanelKVs ) + { + m_pModelPanel->ApplySettings( pItemModelPanelKVs ); + } + + // We can get our settings applied AFTER we've already setup our + // panel, so re-update. + UpdatePanels(); +} + +void CItemModelPanel::LoadResFileForCurrentItem( bool bForceLoad ) +{ + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + bool bCollectionMouseover = ( m_bIsMouseOverPanel && GetItem() && GetItem()->GetItemDefinition()->GetItemCollectionDefinition() ); + if ( bCollectionMouseover ) + { + float flInspect = 0; + static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" ); + if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( GetItem(), pAttrib_WeaponAllowInspect, &flInspect ) && flInspect != 0.f ) + { + if ( bForceLoad || m_nCollectionItemLoaded != LOADED_COLLECTION_WEAPON ) + { + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s ItemModelPanelCollectionItem", __FUNCTION__ ); + LoadControlSettings( "Resource/UI/econ/ItemModelPanelCollectionItem.res" ); + m_nCollectionItemLoaded = LOADED_COLLECTION_WEAPON; + } + } + else + { + if ( bForceLoad || m_nCollectionItemLoaded != LOADED_COLLECTION_COSMETIC ) + { + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s ItemModelPanelCollectionCosmeticItem", __FUNCTION__ ); + LoadControlSettings( "Resource/UI/econ/ItemModelPanelCollectionCosmeticItem.res" ); + m_nCollectionItemLoaded = LOADED_COLLECTION_COSMETIC; + } + } + m_bHideModel = false; // Hack + } + else + { + if ( bForceLoad || m_nCollectionItemLoaded != LOADED_COLLECTION_NONE ) + { + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s ItemModelPanel", __FUNCTION__ ); + LoadControlSettings( "Resource/UI/econ/ItemModelPanel.res" ); + } + m_bHideModel = m_bHideModelDefault; + m_nCollectionItemLoaded = LOADED_COLLECTION_NONE; + } + + m_pModelPanel = dynamic_cast<CEmbeddedItemModelPanel*>( FindChildByName( "itemmodelpanel", true ) ); + SetModelIsHidden( m_bHideModel ); + if ( m_bIsMouseOverPanel && m_pModelPanel ) + { + m_pModelPanel->SetInventoryImageType( CEmbeddedItemModelPanel::IMAGETYPE_LARGE ); + } + + m_pItemNameLabel = dynamic_cast<CExLabel*>( FindChildByName( "namelabel", true ) ); + m_pItemAttribLabel = dynamic_cast<vgui::Label*>( FindChildByName( "attriblabel", true ) ); + m_pItemCollectionNameLabel = dynamic_cast<CExLabel*>( FindChildByName( "collectionnamelabel", true ) ); + m_pItemCollectionListLabel = dynamic_cast<vgui::Label*>( FindChildByName( "collectionlistlabel", true ) ); + m_pItemCollectionHighlight = dynamic_cast<vgui::EditablePanel*>( FindChildByName( "collectionhighlight", true ) ); + m_pItemEquippedLabel = dynamic_cast<vgui::Label*>( FindChildByName( "equippedlabel", true ) ); + m_pItemQuantityLabel = dynamic_cast<vgui::Label*>( FindChildByName( "quantitylabel", true ) ); + m_pVisionRestrictionImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "vision_restriction_icon", true ) ); + + m_pIsStrangeImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "is_strange_icon", true ) ); + m_pIsUnusualImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "is_unusual_icon", true ) ); + m_pIsLoanerImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "is_loaner_icon", true ) ); + + m_pSeriesLabel = dynamic_cast<vgui::Label*>( FindChildByName( "serieslabel", true ) ); + m_pMatchesLabel = dynamic_cast<vgui::Label*>( FindChildByName( "matcheslabel", true ) ); + m_pMainContentContainer = dynamic_cast<vgui::EditablePanel*>( FindChildByName( "MainContentsContainer" ) ); + m_pLoadingSpinner = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "LoadingSpinner" ) ); + + if ( m_pItemEquippedLabel ) + { + m_pItemEquippedLabel->SetKeyBoardInputEnabled( false ); + m_pItemEquippedLabel->SetMouseInputEnabled( false ); + } + if ( m_pItemQuantityLabel ) + { + m_pItemQuantityLabel->SetKeyBoardInputEnabled( false ); + m_pItemQuantityLabel->SetMouseInputEnabled( false ); + } + if ( m_pVisionRestrictionImage ) + { + m_pVisionRestrictionImage->SetKeyBoardInputEnabled( false ); + m_pVisionRestrictionImage->SetMouseInputEnabled( false ); + } + if ( m_pIsStrangeImage ) + { + m_pIsStrangeImage->SetKeyBoardInputEnabled( false ); + m_pIsStrangeImage->SetMouseInputEnabled( false ); + } + if ( m_pIsUnusualImage ) + { + m_pIsUnusualImage->SetKeyBoardInputEnabled( false ); + m_pIsUnusualImage->SetMouseInputEnabled( false ); + } + if ( m_pIsLoanerImage ) + { + m_pIsLoanerImage->SetKeyBoardInputEnabled( false ); + m_pIsLoanerImage->SetMouseInputEnabled( false ); + } + + if ( m_pSeriesLabel ) + { + m_pSeriesLabel->SetKeyBoardInputEnabled( false ); + m_pSeriesLabel->SetMouseInputEnabled( false ); + } + if ( m_pMatchesLabel ) + { + m_pMatchesLabel->SetKeyBoardInputEnabled( false ); + m_pMatchesLabel->SetMouseInputEnabled( false ); + } + + m_pPaintIcon = dynamic_cast<CItemMaterialCustomizationIconPanel*>( FindChildByName( "paint_icon", true ) ); + if ( m_pPaintIcon ) + { + m_pPaintIcon->SetMouseInputEnabled( false ); + } + m_pTF2Icon = dynamic_cast<vgui::ScalableImagePanel*>( FindChildByName( "tf2_icon", true ) ); + if ( m_pTF2Icon ) + { + m_pTF2Icon->SetMouseInputEnabled( false ); + } + + if ( m_bContainedItem ) + { + SetPaintBackgroundEnabled( true ); + } + else + { + SetPaintBackgroundEnabled( false ); + } + + if ( m_pModelPanel ) + { + m_pModelPanel->SetBgColor( Color( 0, 0, 0, 255 ) ); + m_pModelPanel->AddActionSignalTarget( this ); + m_pModelPanel->SetMouseInputEnabled( false ); + } + + if ( m_pItemNameLabel ) + { + m_OrgItemTextColor = m_pItemNameLabel->GetFgColor(); + m_pItemNameLabel->SetMouseInputEnabled( false ); + m_pItemNameLabel->AddActionSignalTarget( this ); + m_pItemNameLabel->InvalidateLayout( true, true ); + } + + if ( m_pItemAttribLabel ) + { + m_pItemAttribLabel->SetMouseInputEnabled( false ); + m_pItemAttribLabel->AddActionSignalTarget( this ); + m_pItemAttribLabel->InvalidateLayout( true, true ); + } + + if ( m_pItemCollectionNameLabel ) + { + m_pItemCollectionNameLabel->SetMouseInputEnabled( false ); + m_pItemCollectionNameLabel->AddActionSignalTarget( this ); + m_pItemCollectionNameLabel->InvalidateLayout( true, true ); + } + + if ( m_pItemCollectionListLabel ) + { + m_pItemCollectionListLabel->SetMouseInputEnabled( false ); + m_pItemCollectionListLabel->AddActionSignalTarget( this ); + m_pItemCollectionListLabel->InvalidateLayout( true, true ); + } + + if ( m_pItemCollectionHighlight ) + { + m_pItemCollectionHighlight->SetMouseInputEnabled( false ); + m_pItemCollectionHighlight->AddActionSignalTarget( this ); + m_pItemCollectionHighlight->InvalidateLayout( true, true ); + } + + m_pContainedItemPanel = dynamic_cast<CItemModelPanel*>( FindChildByName( "contained_item_panel", true ) ); + + // Dont eat mouse input + if ( m_pMainContentContainer ) + { + m_pMainContentContainer->SetMouseInputEnabled( false ); + } + + UpdatePanels(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::PerformLayout( void ) +{ + int w,h; + GetSize( w, h ); + w = m_iBaseWide ? m_iBaseWide : w; + h = m_iBaseTall ? m_iBaseTall : h; + + int iTextW = GetAttribWide(w); + int iModelW = m_iModelWide && m_iModelWide < w ? m_iModelWide : w; + int iModelT = m_iModelTall && m_iModelTall < h ? m_iModelTall : h; + int iModelX = m_bModelCenterX ? ( ( w - iModelW ) * 0.5 ) : m_iModelXPos; + int iModelY = m_bModelCenterY ? ( ( h - iModelT ) * 0.5 ) : m_iModelYPos; + + ResizeLabels(); + + if ( m_pModelPanel ) + { + m_pModelPanel->SetBounds( iModelX, iModelY, iModelW, iModelT ); + } + if ( m_pLoadingSpinner ) + { + int nWidthHeight = Max( iModelW, iModelT ); + int xOffset = int( w / 2.f ) - int( nWidthHeight / 2.f ); + int yOffset = int( h / 2.f ) - int( nWidthHeight / 2.f ); + m_pLoadingSpinner->SetBounds( xOffset, yOffset, nWidthHeight, nWidthHeight ); + } + + if ( m_bNoItemFullPanel ) + { + // We want the "no item" text to use the entire panel, and hide the attribs entirely + if ( m_pItemNameLabel && m_pItemAttribLabel ) + { + m_pItemNameLabel->SetBounds( XRES(4), 0, GetWide() - XRES(8), GetTall() ); + } + } + else if ( m_pItemNameLabel && m_pItemAttribLabel && !m_bModelOnly ) + { + // Force the labels to layout now, and get their height. + m_pItemNameLabel->InvalidateLayout( true ); + m_pItemAttribLabel->InvalidateLayout( true ); + m_pItemNameLabel->SizeToContents(); + m_pItemAttribLabel->SizeToContents(); + + if ( m_pItemCollectionNameLabel ) + { + m_pItemCollectionNameLabel->InvalidateLayout( true ); + m_pItemCollectionNameLabel->SizeToContents(); + } + + if ( m_pItemCollectionListLabel ) + { + m_pItemCollectionListLabel->InvalidateLayout( true ); + m_pItemCollectionListLabel->SizeToContents(); + } + + // "" strings still size themselves as one font-heighth tall, but 0 wide. If there's no + // text in the attribute, we want 0 tall as well, so we don't get blank lines. + int iCollectionTall = m_pItemCollectionListLabel ? m_pItemCollectionListLabel->GetTall() : 0; + int iAttribTall = (m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0); + iAttribTall = Max( iAttribTall, iCollectionTall ); + + int iNameTall = m_pItemNameLabel->GetTall(); + + int iCollectionNameTall = m_pItemCollectionNameLabel ? m_pItemCollectionNameLabel->GetTall() : 0; + + if ( m_bAttribOnly ) + { + iNameTall = 0; + } + + if ( m_bTextCenterX ) + { + m_pItemNameLabel->SetSize( iTextW, iNameTall ); + m_pItemAttribLabel->SetSize( iTextW, iAttribTall ); + } + else if ( m_iTextYPos ) + { + m_pItemNameLabel->SetSize( iTextW, iNameTall ); + m_pItemAttribLabel->SetSize( iTextW, (m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0) ); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SetSize( iTextW, iCollectionNameTall ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SetSize( iTextW, iCollectionTall ); + } + else if ( m_bTextCenter ) + { + m_pItemNameLabel->SetSize( iTextW, iNameTall ); + m_pItemAttribLabel->SetSize( iTextW, iAttribTall ); + } + else + { + m_pItemNameLabel->SetSize( iTextW, iNameTall ); + m_pItemAttribLabel->SetSize( iTextW, iAttribTall ); + } + + m_pItemNameLabel->InvalidateLayout( true ); + + // Force attrib layout to update now in its new size. + m_pItemAttribLabel->InvalidateLayout( true ); + m_pItemAttribLabel->SizeToContents(); + + // Reget sizes, wtf + iCollectionTall = m_pItemCollectionListLabel ? m_pItemCollectionListLabel->GetTall() : 0; + iAttribTall = ( m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0 ); + // HACK: Now we resize it again. Sets our height properly. Ridiculous. + m_pItemAttribLabel->SetSize( iTextW, iAttribTall ); + m_pItemNameLabel->SetSize( iTextW, iNameTall ); + + // Ignore attributes if we're only showing the name + if ( m_bNameOnly || (!HasItem() && m_pszNoItemText && m_pszNoItemText[0]) ) + { + iAttribTall = 0; + } + + int iLabelOffset = 0; + if ( m_bResizeToText ) + { + h = m_iTextYPos + iNameTall + iAttribTall + m_iHPadding; + + // Must be at least tall enough to fit the image (if visible) + if ( !m_bHideModel ) + { + //h = MAX( h, (iModelT + (iModelY * 2)) ); + h = Max( h + iModelT + iModelY, m_iTextYPos + iCollectionNameTall + iCollectionTall + m_iHPadding); + iLabelOffset = iModelT + iModelY; + } + } + + // If we don't have a specific X pos, or attrib width, indent ourselves + int iTextXPos = (m_iTextXPos || m_iTextWide) ? m_iTextXPos : ATTRIB_LABEL_INDENT; + + if ( iCollectionNameTall && iCollectionTall && m_iTextXPosCollection ) + { + iTextXPos = m_iTextXPosCollection; + } + + // Position the name label now we know where our attrib label is + // If we've got a Y pos, use it. Otherwise, stack up from the bottom of the panel. + if ( m_bTextCenterX ) + { + m_pItemNameLabel->SizeToContents(); + m_pItemAttribLabel->SizeToContents(); + + m_pItemNameLabel->SetPos( ( w - m_pItemNameLabel->GetWide() ) * 0.5f, m_iTextYPos + iLabelOffset ); + m_pItemAttribLabel->SetPos( ( w - m_pItemAttribLabel->GetWide() ) * 0.5f, m_iTextYPos + iNameTall + iLabelOffset ); + } + else if ( m_iTextYPos ) + { + m_pItemNameLabel->SetPos( iTextXPos, m_iTextYPos + iLabelOffset ); + m_pItemAttribLabel->SetPos( iTextXPos, m_iTextYPos + iNameTall + iLabelOffset); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SetPos( m_iCollectionListXPos, m_iTextYPos ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SetPos( m_iCollectionListXPos, m_iTextYPos + iCollectionNameTall ); + } + else if ( m_bTextCenter ) + { + int iYTop = (h - (iNameTall + iAttribTall)) * 0.5; + if ( iYTop < 0 ) + { + iYTop = 0; + } + m_pItemNameLabel->SetPos( iTextXPos, iYTop ); + m_pItemAttribLabel->SetPos( iTextXPos, iYTop + iNameTall ); + //m_pItemCollectionLabel->SetPos( iTextXPos + iTextW, iYTop ); + } + else + { + int iOffsetY = (m_iTextYOffset != 0) ? m_iTextYOffset : YRES(8); + m_pItemNameLabel->SetPos( iTextXPos, h - iAttribTall - iNameTall - iOffsetY + m_iHPadding ); + m_pItemAttribLabel->SetPos( iTextXPos, h - iAttribTall - iOffsetY + m_iHPadding ); + //m_pItemCollectionLabel->SetPos( iTextXPos + iTextW, h - iAttribTall - iNameTall - iOffsetY + m_iHPadding ); + } + + if ( m_bResizeToText ) + { + if ( m_bIsMouseOverPanel && GetItem() && GetItem()->GetItemDefinition()->GetItemCollectionDefinition() && !m_bHideCollectionPanel ) + { + if ( m_pItemCollectionListLabel && m_pItemCollectionNameLabel && m_pItemCollectionHighlight ) + { + m_pItemCollectionListLabel->SizeToContents(); + m_pItemCollectionNameLabel->SizeToContents(); + int iContentW = Max( m_pItemCollectionNameLabel->GetWide(), m_pItemCollectionListLabel->GetWide() ); + w = iContentW + m_iCollectionListXPos + m_iTextXPosCollection; + m_pItemCollectionHighlight->SetWide( iContentW ); + } + } + SetSize( w, h ); + } + } + + // pin icons to top right corner + int xpos = m_iBaseWide - XRES(1); + int ypos = YRES(1); + + if ( m_pPaintIcon && m_pPaintIcon->IsVisible() ) + { + m_pPaintIcon->SetPos( xpos - m_pPaintIcon->GetWide(), ypos ); + ypos += m_pPaintIcon->GetTall() * 0.9; + } + if ( m_pTF2Icon && m_pTF2Icon->IsVisible() ) + { + m_pTF2Icon->SetPos( xpos - m_pTF2Icon->GetWide() + m_iTF2IconOffsetX, ypos + m_iTF2IconOffsetY ); + ypos += m_pTF2Icon->GetTall() * 0.9; + } + if ( m_pVisionRestrictionImage && m_pVisionRestrictionImage->IsVisible() ) + { + m_pVisionRestrictionImage->SetPos( xpos - m_pVisionRestrictionImage->GetWide(), ypos ); + ypos += m_pVisionRestrictionImage->GetTall() * 0.9; + } + if ( m_pIsUnusualImage && m_pIsUnusualImage->IsVisible() ) + { + m_pIsUnusualImage->SetPos( xpos - m_pIsUnusualImage->GetWide(), ypos ); + ypos += m_pIsUnusualImage->GetTall() * 0.9; + } + if ( m_pIsStrangeImage && m_pIsStrangeImage->IsVisible() ) + { + m_pIsStrangeImage->SetPos( xpos - m_pIsStrangeImage->GetWide(), ypos ); + ypos += m_pIsStrangeImage->GetTall() * 0.9; + } + if ( m_pIsLoanerImage && m_pIsLoanerImage->IsVisible() ) + { + m_pIsLoanerImage->SetPos( xpos - m_pIsLoanerImage->GetWide(), ypos ); + ypos += m_pIsLoanerImage->GetTall() * 0.9; + } + + + if ( m_pItemNameLabel ) + { + //m_pItemNameLabel->SetContentAlignment( (vgui::Label::Alignment) m_iNameLabelAlignment ); + } + + if ( m_bModelOnly ) + { + if ( m_pItemNameLabel ) + { + m_pItemNameLabel->SetVisible( false ); + } + if ( m_pItemAttribLabel ) + { + m_pItemAttribLabel->SetVisible( false ); + } + if ( m_pItemCollectionNameLabel ) + { + m_pItemCollectionNameLabel->SetVisible( false ); + } + if ( m_pItemCollectionListLabel ) + { + m_pItemCollectionListLabel->SetVisible( false ); + } + if ( m_pItemCollectionHighlight ) + { + m_pItemCollectionHighlight->SetVisible( false ); + } + } + + BaseClass::PerformLayout(); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::PaintTraverse( bool forceRepaint, bool allowForce ) +{ + if ( m_bFakeButton ) + return; + + BaseClass::PaintTraverse( forceRepaint, allowForce ); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnSizeChanged( int newWide, int newTall ) +{ + BaseClass::OnSizeChanged( newWide, newTall ); + InvalidateLayout( true ); + + if ( m_bModelOnly ) + return; + + if ( m_pItemNameLabel && m_pItemNameLabel->GetTextImage() ) + { + m_pItemNameLabel->GetTextImage()->RecalculateNewLinePositions(); + } + if ( m_pItemAttribLabel && m_pItemAttribLabel->GetTextImage() ) + { + m_pItemAttribLabel->GetTextImage()->RecalculateNewLinePositions(); + } + if ( m_pItemCollectionNameLabel && m_pItemCollectionNameLabel->GetTextImage() ) + { + m_pItemCollectionNameLabel->GetTextImage()->RecalculateNewLinePositions(); + } + if ( m_pItemCollectionListLabel && m_pItemCollectionListLabel->GetTextImage() ) + { + m_pItemCollectionListLabel->GetTextImage()->RecalculateNewLinePositions(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::ResizeLabels( void ) +{ + if ( !m_pItemNameLabel || !m_pItemAttribLabel || m_bModelOnly ) + return; + + int w,h; + GetSize( w, h ); + int iTextW = GetAttribWide(w); + + if ( m_iMaxTextHeight ) + { + h = m_iMaxTextHeight; + } + + // HACK to get the item model panel on the main menu to have its fonts. + vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() ); + if ( !m_pFontNameSmallest ) + m_pFontNameSmallest = pScheme->GetFont( "ItemFontNameSmallest", true ); + if ( !m_pFontNameSmall ) + m_pFontNameSmall = pScheme->GetFont( "ItemFontNameSmall", true ); + if ( !m_pFontNameLarge ) + m_pFontNameLarge = pScheme->GetFont( "ItemFontNameLarge", true ); + if ( !m_pFontNameLarger ) + m_pFontNameLarger = pScheme->GetFont( "ItemFontNameLarger", true ); + if ( !m_pFontAttribSmallest ) + m_pFontAttribSmallest = pScheme->GetFont( "ItemFontAttribSmallest", true ); + if ( !m_pFontAttribSmall ) + m_pFontAttribSmall = pScheme->GetFont( "ItemFontAttribSmallv2", true ); + if ( !m_pFontAttribLarge ) + m_pFontAttribLarge = pScheme->GetFont( "ItemFontAttribLarge", true ); + if ( !m_pFontAttribLarger ) + m_pFontAttribLarger = pScheme->GetFont( "ItemFontAttribLarger", true ); + + if ( m_iForceTextSize && m_iForceTextSize <= 4 ) + { + // Leave center wrap on if the noitem text is getting to use the whole panel + if ( !m_bNoItemFullPanel ) + { + m_pItemNameLabel->SetCenterWrap( false ); + } + m_pItemNameLabel->InvalidateLayout( true, true ); + m_pItemAttribLabel->InvalidateLayout( true, true ); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->InvalidateLayout( true, true ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->InvalidateLayout( true, true ); + + switch ( m_iForceTextSize ) + { + case 1: + m_pItemNameLabel->SetFont( m_pFontNameLarge ); + m_pItemAttribLabel->SetFont( m_pFontAttribLarge ); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SetFont( m_pFontNameLarge ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SetFont( m_pFontAttribLarge ); + break; + + case 2: + m_pItemNameLabel->SetFont( m_pFontNameSmall ); + m_pItemAttribLabel->SetFont( m_pFontAttribSmall ); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SetFont( m_pFontNameSmall ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SetFont( m_pFontAttribSmall ); + break; + + case 3: + m_pItemNameLabel->SetFont( m_pFontNameSmallest ); + m_pItemAttribLabel->SetFont( m_pFontAttribSmallest ); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SetFont( m_pFontNameSmallest ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SetFont( m_pFontAttribSmallest ); + break; + + case 4: + m_pItemNameLabel->SetFont( m_pFontNameLarger ); + m_pItemAttribLabel->SetFont( m_pFontAttribLarger ); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SetFont( m_pFontNameLarger ); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SetFont( m_pFontAttribLarger ); + break; + } + + m_pItemNameLabel->SizeToContents(); + m_pItemAttribLabel->SizeToContents(); + if ( m_pItemCollectionNameLabel ) + m_pItemCollectionNameLabel->SizeToContents(); + if ( m_pItemCollectionListLabel ) + m_pItemCollectionListLabel->SizeToContents(); + } + else + { + m_pItemNameLabel->SetFont( m_pFontNameLarge ); + m_pItemNameLabel->SetCenterWrap( false ); + m_pItemNameLabel->SizeToContents(); + m_pItemAttribLabel->SetFont( m_pFontAttribLarge ); + m_pItemAttribLabel->SizeToContents(); + if ( m_pItemCollectionNameLabel ) + { + m_pItemCollectionNameLabel->SetFont( m_pFontNameLarge ); + m_pItemCollectionNameLabel->SetCenterWrap( false ); + m_pItemCollectionNameLabel->SizeToContents(); + } + if ( m_pItemCollectionListLabel ) + { + m_pItemCollectionListLabel->SetFont( m_pFontAttribLarge ); + m_pItemCollectionListLabel->SizeToContents(); + } + + if ( !m_bResizeToText ) + { + int iAttribTall = m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0; + int iNameTall = m_bAttribOnly ? 0 : m_pItemNameLabel->GetTall(); + int iTotalH = iAttribTall + iNameTall; + + // If these fonts won't fit, use the smaller ones + if ( m_pItemNameLabel->GetWide() > iTextW || (!m_bNameOnly && m_pItemAttribLabel->GetWide() > iTextW) || (iTotalH > h) ) + { + m_pItemNameLabel->SetFont( m_pFontNameSmall ); + m_pItemAttribLabel->SetFont( m_pFontAttribSmall ); + + m_pItemNameLabel->InvalidateLayout( true ); + m_pItemNameLabel->SizeToContents(); + + iAttribTall = m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0; + iNameTall = m_pItemNameLabel->GetTall(); + iTotalH = iAttribTall + iNameTall; + + // If they don't fit, go to the smallest + if ( m_pItemNameLabel->GetWide() > iTextW || (!m_bNameOnly && m_pItemAttribLabel->GetWide() > iTextW) || (iTotalH > h) ) + { + m_pItemNameLabel->SetFont( m_pFontNameSmallest ); + m_pItemAttribLabel->SetFont( m_pFontAttribSmallest ); + + m_pItemNameLabel->InvalidateLayout( true ); + m_pItemNameLabel->SizeToContents(); + } + } + } + } + + // If it still doesn't fit, turn on wrap and pray + if ( m_pItemNameLabel->GetWide() > iTextW ) + { + m_pItemNameLabel->SetCenterWrap( true ); + } + + if ( m_pItemAttribLabel->GetWide() > iTextW ) + { + m_pItemAttribLabel->SetWrap( true ); + } + + // Now restore the sizes + m_pItemNameLabel->SetSize( iTextW, m_pItemNameLabel->GetTall() ); + m_pItemAttribLabel->SetSize( iTextW, m_pItemAttribLabel->GetTall() ); + + if ( m_pItemEquippedLabel ) + { + m_pItemEquippedLabel->SetPos( GetWide() - m_pItemEquippedLabel->GetWide() - m_iEquippedInsetX, GetTall() - m_pItemEquippedLabel->GetTall() - m_iEquippedInsetY ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetItem( const CEconItemView *pItem ) +{ + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + + HideContainedItemPanel(); + + bool bMatch = false; + + if ( pItem && pItem->IsValid() ) + { + if ( m_ItemData.IsValid() ) + { + if ( m_ItemData.GetItemID() != INVALID_ITEM_ID ) + { + bool bUseIndexCompare = false; + +#ifdef TF_CLIENT_DLL + if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() ) + { + if ( ( m_ItemData.GetItemID() == 1 ) && ( m_ItemData.GetItemID() == pItem->GetItemID() ) ) + { + // Items the bots carry in MvM all have itemID of 1, so we need to compare the item index + bUseIndexCompare = true; + } + } +#endif + + if ( bUseIndexCompare ) + { + bMatch = m_ItemData.GetItemDefIndex() == pItem->GetItemDefIndex(); + } + else + { + // Our current item is non-base. We need to match global indices. + bMatch = ( m_ItemData.GetItemID() == pItem->GetItemID() ); + } + } + else if ( pItem->GetItemID() == INVALID_ITEM_ID ) + { + static CSchemaFieldHandle<CEconItemAttributeDefinition> pAttrib_ToolTarget( "tool target item" ); + bMatch &= pItem->FindAttribute( pAttrib_ToolTarget ); + + // Our current item is a base item. Our new item needs to be base too, and match item indices and quality + bMatch &= ( m_ItemData.GetItemDefIndex() == pItem->GetItemDefIndex() ) && + ( m_ItemData.GetItemQuality() == pItem->GetItemQuality() ) && + ( m_ItemData.GetSOCData() == pItem->GetSOCData() ); + } + } + + // if we match item so far, check for strange + if ( bMatch ) + { + // Are we tracking alternate stats as well? + for ( int i = 0; i < GetKillEaterAttrCount(); i++ ) + { + const CEconItemAttributeDefinition *pKillEaterAltAttrDef = GetKillEaterAttr_Score( i ), + *pKillEaterAltScoreTypeAttrDef = GetKillEaterAttr_Type( i ); + if ( !pKillEaterAltAttrDef || !pKillEaterAltScoreTypeAttrDef ) + continue; + + uint32 unNewScore = 0; + uint32 unOldScore = 0; + bool bNewFoundAttr = pItem->FindAttribute( pKillEaterAltAttrDef, &unNewScore ); + bool bOldFoundAttr = m_ItemData.FindAttribute( pKillEaterAltAttrDef, &unOldScore ); + if ( bNewFoundAttr != bOldFoundAttr || unNewScore != unOldScore ) + { + // different score + bMatch = false; + break; + } + + float flNewType = 0.f; + float flOldType = 0.f; + bNewFoundAttr = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pKillEaterAltScoreTypeAttrDef, &flNewType ); + bOldFoundAttr = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( &m_ItemData, pKillEaterAltScoreTypeAttrDef, &flOldType ); + if ( bNewFoundAttr != bOldFoundAttr || flNewType != flOldType ) + { + // different score + bMatch = false; + break; + } + } + } + + if ( !bMatch ) + { + // cancel weapon skin composition for old item + if ( m_ItemData.IsValid() ) + { + m_ItemData.CancelWeaponSkinComposite(); + } + + m_ItemData = *pItem; + + if ( m_bIsMouseOverPanel ) + { + LoadResFileForCurrentItem( false ); + } + + // If the item hasn't built its attribute string, go ahead and do that. + m_ItemData.SetGrayedOutReason( GetGreyedOutReason() ); + } + else + { + // The rest of the data may match, but we still need the inventory position updates + m_ItemData.SetInventoryPosition( pItem->GetInventoryPosition() ); + } + + ShowContainedItemPanel( pItem ); + } + else + { + // cancel weapon skin composition for old item + if ( m_ItemData.IsValid() ) + { + m_ItemData.CancelWeaponSkinComposite(); + } + else + { + bMatch = true; + } + + m_ItemData.GetAttributeList()->DestroyAllAttributes(); + m_ItemData.Invalidate(); + } + + // only update panels when item is not matched + if ( !bMatch ) + { + UpdatePanels(); + } + + // TODO: Update only description for strange item in the same panel +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::Dragged( bool bDragging ) +{ + if ( m_pContainedItemPanel ) + { + if ( bDragging ) + { + m_pContainedItemPanel->SetActAsButton( false, false ); + m_pContainedItemPanel->SetVisible( false ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::ShowContainedItemPanel( const CEconItemView *pItem ) +{ + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + + // If this item contains another item, create an interior item model panel. + if ( pItem->GetSOCData() && pItem->GetSOCData()->GetInteriorItem() && m_pContainedItemPanel ) + { + if ( !m_pContainedItemPanel->IsContainedItem() ) + { + m_pContainedItemPanel->SetContainedItem( true ); + m_pContainedItemPanel->InvalidateLayout( false, true ); + } + + CEconItem *pInteriorItem = pItem->GetSOCData()->GetInteriorItem(); + if ( !pInteriorItem ) + return; + + const IEconTool *pEconTool = pItem->GetItemDefinition() + ? pItem->GetItemDefinition()->GetEconTool() + : NULL; + if ( !pEconTool ) + return; + + if ( !pEconTool->ShouldShowContainedItemPanel( pItem ) ) + { + // Only show this to non-local, non-wrapping players if we've been told to (usually in trading panel) + if ( !m_bShowOthersGiftWrappedItems ) + return; + } + + SetNeedsToLoad(); + + m_pContainedItemPanel->SetEconItem( pInteriorItem ); + m_pContainedItemPanel->SetVisible( true ); + m_pContainedItemPanel->SetActAsButton( false, true ); + m_pContainedItemPanel->SetTooltip( GetTooltip(), "" ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::HideContainedItemPanel() +{ + if ( m_pContainedItemPanel && m_pContainedItemPanel->IsVisible() ) + { + m_pContainedItemPanel->SetActAsButton( false, false ); + m_pContainedItemPanel->SetVisible( false ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetEconItem( CEconItem* pItem ) +{ + m_ItemData.SetItemDefIndex( pItem->GetDefinitionIndex() ); + m_ItemData.SetItemQuality( pItem->GetQuality() ); + m_ItemData.SetItemLevel( pItem->GetItemLevel() ); + m_ItemData.SetItemID( pItem->GetItemID() ); + m_ItemData.SetNonSOEconItem( pItem ); + m_ItemData.SetInitialized( true ); + +#ifdef CLIENT_DLL + m_ItemData.SetIsTradeItem( false ); + m_ItemData.SetItemQuantity( pItem->GetQuantity() ); +#endif + + m_ItemData.GetAttributeList()->DestroyAllAttributes(); + + if ( m_pModelPanel ) + { + m_pModelPanel->SetItem( &m_ItemData ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetNoItemText( const char *pszText ) +{ + m_pszNoItemText = pszText; + CleanupNoItemWChars(); + + if ( !HasItem() ) + { + UpdatePanels(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::CleanupNoItemWChars( void ) +{ + if ( m_pwcNoItemText ) + { + delete m_pwcNoItemText; + m_pwcNoItemText = NULL; + } + if ( m_pwcNoItemAttrib ) + { + delete m_pwcNoItemAttrib; + m_pwcNoItemAttrib = NULL; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CItemModelPanel::UpdateSeriesLabel() +{ + // hijacking m_bShowQuantity here to indicate "show things where the quantity counter goes", in this case meaning "show crate series indicator" + if ( m_pSeriesLabel && m_bShowQuantity ) + { + static CSchemaAttributeDefHandle pAttrDef_CrateSeries( "set supply crate series" ); + static CSchemaAttributeDefHandle pAttrDef_HideSeries( "hide crate series number" ); + + float fCrateSeries; + if ( pAttrDef_CrateSeries && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( &m_ItemData, pAttrDef_CrateSeries, &fCrateSeries ) && pAttrDef_HideSeries && !m_ItemData.FindAttribute( pAttrDef_HideSeries ) ) + { + wchar_t wszSeries[16]=L""; + _snwprintf( wszSeries, ARRAYSIZE( wszSeries ), L"#%i", (int)fCrateSeries ); + m_pSeriesLabel->SetVisible( true ); + m_pSeriesLabel->SetText( wszSeries ); + + return true; + } + else + { + m_pSeriesLabel->SetVisible( false ); + + return false; + } + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Read through a few items and see if they match the recipe's criteria +// Show elipses while still tallying. Remove our tick once all items +// are tallied. +//----------------------------------------------------------------------------- +bool CItemModelPanel::CheckRecipeMatches() +{ + // Don't do this if either we or our parent are invisible + if( !IsVisible() || ( GetParent() && !GetParent()->IsVisible() ) ) + return false; + + const IEconTool* pTool = m_ItemData.GetStaticData()->GetEconTool(); + + // If this isnt a dynamic recipe tool, dont show or do any of this + if( !pTool + || V_stricmp( m_ItemData.GetStaticData()->GetEconTool()->GetTypeName() , "dynamic_recipe") + || m_ItemData.GetStaticData()->GetDefaultLoadoutSlot() != INVALID_EQUIPPED_SLOT ) + { + if( m_pMatchesLabel ) + { + m_pMatchesLabel->SetVisible( false ); + } + + return false; + } + + bool bStillWorking = true; + if( m_pMatchesLabel && m_bShowQuantity ) + { + CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory(); + if ( pLocalInv == NULL ) + return false; + + // We still need to match recipe components + if ( m_nRecipeMatchingIndex < pLocalInv->GetItemCount() ) + sai_NumLoadingRequests[LOADING_RECIPE_MATCHES]++; + + if ( se_CurrentLoadingTask == LOADING_RECIPE_MATCHES ) + { + // Go through our entire backpack and check for matches, but only go through a few at a time + while ( m_nRecipeMatchingIndex < pLocalInv->GetItemCount() && sm_flLoadingTimeThisFrame < tf_time_loading_item_panels.GetFloat() ) + { + // Mark this time + float flTime = Plat_FloatTime(); + + CEconItemView *pItem = pLocalInv->GetItem( m_nRecipeMatchingIndex ); + Assert( pItem ); + + // Check each item + CRecipeComponentMatchingIterator matchingIterator( &m_ItemData, pItem ); + m_ItemData.IterateAttributes( &matchingIterator ); + const CUtlVector< const CEconItemAttributeDefinition* >& matchingAttribs = matchingIterator.GetMatchingComponentInputs(); + Assert( matchingAttribs.Count() <= 1 ); + FOR_EACH_VEC( matchingAttribs, j ) + { + CAttribute_DynamicRecipeComponent value; + const CEconItemAttributeDefinition* pAttrib = matchingAttribs[j]; + attrib_definition_index_t nIndex = pAttrib->GetDefinitionIndex(); + m_ItemData.FindAttribute( pAttrib, &value ); + + // Add this entry if it doesnt exist in out map yet + if( m_mapMatchingAttributes.Find( nIndex ) == m_mapMatchingAttributes.InvalidIndex() ) + { + m_mapMatchingAttributes.Insert( nIndex ); + m_mapMatchingAttributes[ m_mapMatchingAttributes.Find( nIndex ) ] = 0; + } + + // Increment this value if it's less than the max needed + int &nCount = m_mapMatchingAttributes[ m_mapMatchingAttributes.Find( nIndex ) ]; + if( (unsigned)nCount < ( value.num_required() - value.num_fulfilled() ) ) + { + ++nCount; + } + } + + m_nRecipeMatchingIndex++; + // Accumulate time + sm_flLoadingTimeThisFrame += ( Plat_FloatTime() - flTime ); + } + } + + bStillWorking = m_nRecipeMatchingIndex != pLocalInv->GetItemCount(); + wchar_t wszMatches[16]=L"..."; + + if( !bStillWorking ) + { + CRecipeComponentMatchingIterator matchingIterator( &m_ItemData, NULL ); + m_ItemData.IterateAttributes( &matchingIterator ); + int nTotalAttribs = matchingIterator.GetTotalInputs() - matchingIterator.GetInputsFulfilled(); + int nMatchingAttribs = 0; + + unsigned short index = m_mapMatchingAttributes.FirstInorder(); + while( index != m_mapMatchingAttributes.InvalidIndex() ) + { + nMatchingAttribs += m_mapMatchingAttributes[ index ]; + index = m_mapMatchingAttributes.NextInorder( index ); + } + + // Fill out the actual number of matches + _snwprintf( wszMatches, ARRAYSIZE( wszMatches ), L"%i/%i", nMatchingAttribs, nTotalAttribs ); + } + + m_pMatchesLabel->SetVisible( true ); + m_pMatchesLabel->SetText( wszMatches ); + } + + return bStillWorking; +} + +void CItemModelPanel::UpdateDescription() +{ + if ( !m_bDescriptionDirty ) + return; + + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + + m_bDescriptionDirty = false; + + enum { kAttribBufferSize = 4 * 1024 }; + wchar_t wszAttribBuffer[ kAttribBufferSize ] = L""; + + enum { kCollectionBufferSize = 4 * 1024 }; + wchar_t wszCollectionListBuffer[kCollectionBufferSize] = L""; + + wchar_t wszCollectionNameBuffer[512] = L""; + + if ( !m_bNameOnly ) + { + const CEconItemDescription *pDescription = m_ItemData.GetDescription(); + if ( pDescription ) + { + unsigned int unWrittenLines = 0; + unsigned int unWrittenCollectionLines = 0; + for ( unsigned int i = 0; i < pDescription->GetLineCount(); i++ ) + { + const econ_item_description_line_t& line = pDescription->GetLine(i); + + // m_bSpecialAttributesOnly, only show purple and orange text, ignore rest + if ( m_bSpecialAttributesOnly ) + { + if ( line.eColor == ATTRIB_COL_UNUSUAL || line.eColor == ATTRIB_COL_STRANGE ) + { + V_wcscat_safe( wszAttribBuffer, unWrittenLines++ == 0 ? L"" : L"\n" ); // add empty lines everywhere except before the first line + V_wcscat_safe( wszAttribBuffer, line.sText.Get() ); + } + } + else if ( ( line.unMetaType & kDescLineFlag_CollectionName ) != 0 ) + { + // Ignore name spacers + if ( !( line.unMetaType & kDescLineFlag_Empty) ) + { + V_wcscat_safe( wszCollectionNameBuffer, line.sText.Get() ); + } + } + else if ( ( line.unMetaType & kDescLineFlag_Collection ) != 0 ) + { + V_wcscat_safe( wszCollectionListBuffer, unWrittenCollectionLines++ == 0 ? L"" : L"\n" ); // add empty lines everywhere except before the first line + V_wcscat_safe( wszCollectionListBuffer, line.sText.Get() ); + } + else if ( (line.unMetaType & kDescLineFlag_Name ) == 0 ) + { + V_wcscat_safe( wszAttribBuffer, unWrittenLines++ == 0 ? L"" : L"\n" ); // add empty lines everywhere except before the first line + V_wcscat_safe( wszAttribBuffer, line.sText.Get() ); + } + } + + // If we have an unknown name, we should try to rebuild for "awhile" + m_bDescriptionDirty |= pDescription->HasUnknownPlayer(); + } + } + + if( m_pMainContentContainer ) + { + m_pMainContentContainer->SetDialogVariable( "attriblist", wszAttribBuffer ); + m_pMainContentContainer->SetDialogVariable( "collectionname", wszCollectionNameBuffer ); + m_pMainContentContainer->SetDialogVariable( "collectionlist", wszCollectionListBuffer ); + m_pMainContentContainer->SetDialogVariable( "itemname", m_ItemData.GetItemName() ); + } + + if ( m_pItemNameLabel ) + { + // Set the name to the quality color + // Rarity Econ Colorization + EEconItemQuality eQuality = (EEconItemQuality)m_ItemData.GetItemQuality(); + if ( GetItemSchema()->GetRarityColor( m_ItemData.GetItemDefinition()->GetRarity() ) && eQuality != AE_SELFMADE ) + { + m_pItemNameLabel->SetColorStr( GetItemSchema()->GetRarityColor( m_ItemData.GetItemDefinition()->GetRarity() ) ); + } + else + { + const char *pszQualityColorString = EconQuality_GetColorString( eQuality ); + if ( m_ItemData.IsValid() && !m_bStandardTextColor && pszQualityColorString ) + { + m_pItemNameLabel->SetColorStr( pszQualityColorString ); + } + else + { + m_pItemNameLabel->SetColorStr( m_OrgItemTextColor ); + } + } + m_pItemNameLabel->SetVisible( !m_bAttribOnly ); + } + + if ( m_pItemAttribLabel ) + { + m_pItemAttribLabel->SetVisible( !m_bNameOnly ); + } + + bool bCollectionVisible = m_bHideCollectionPanel ? false : !m_bNameOnly; + + if ( m_pItemCollectionNameLabel ) + { + m_pItemCollectionNameLabel->SetVisible( bCollectionVisible ); + } + if ( m_pItemCollectionListLabel ) + { + m_pItemCollectionListLabel->SetVisible( bCollectionVisible ); + } + if ( m_pItemCollectionHighlight ) + { + m_pItemCollectionHighlight->SetVisible( bCollectionVisible ); + } + + InvalidateLayout( true ); + + // Now that we've built the attribute description, give the attribute colors to our label + if ( m_pItemAttribLabel && !m_bNameOnly && m_pItemAttribLabel->GetTextImage() && m_ItemData.GetDescription() ) + { + const CEconItemDescription *pDescription = m_ItemData.GetDescription(); + vgui::TextImage *pAttrTextImage = m_pItemAttribLabel->GetTextImage(); + pAttrTextImage->ClearColorChangeStream(); + + vgui::TextImage *pCollectionNameTextImage = m_pItemCollectionNameLabel ? m_pItemCollectionNameLabel->GetTextImage() : NULL; + if ( pCollectionNameTextImage ) + pCollectionNameTextImage->ClearColorChangeStream(); + + vgui::TextImage *pCollectionListTextImage = m_pItemCollectionListLabel ? m_pItemCollectionListLabel->GetTextImage() : NULL; + if ( pCollectionListTextImage ) + pCollectionListTextImage->ClearColorChangeStream(); + + vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() ); + + Color prevAttrColor(0,0,0); + Color prevCollectionColor(0,0,0); + unsigned int unCurrentAttrTextStreamIndex = 0; + unsigned int unCurrentCollectionNameTextStreamIndex = 0; + unsigned int unCurrentCollectionListTextStreamIndex = 0; + int iCollectionLineCount = 0; + + if ( m_pItemCollectionHighlight ) + { + m_pItemCollectionHighlight->SetVisible( false ); + } + + for ( unsigned int i = 0; i < pDescription->GetLineCount(); i++ ) + { + const econ_item_description_line_t& line = pDescription->GetLine(i); + + // Ignore the name line, it was added above + if ( ( line.unMetaType & kDescLineFlag_Name ) != 0 ) + { + continue; + } + + // collection + int fontHeight = surface()->GetFontTall( m_pFontAttribSmall ); + if ( ( line.unMetaType & (kDescLineFlag_Collection | kDescLineFlag_CollectionName | kDescLineFlag_CollectionCurrentItem ) ) != 0 && pCollectionNameTextImage && pCollectionListTextImage ) + { + bool bIsCollectionName = ( line.unMetaType & kDescLineFlag_CollectionName ) != 0; + vgui::TextImage *pTextImage = bIsCollectionName ? pCollectionNameTextImage : pCollectionListTextImage; + unsigned int &unCurrentCollectionTextStreamIndex = bIsCollectionName ? unCurrentCollectionNameTextStreamIndex : unCurrentCollectionListTextStreamIndex; + + bool bIsCurrentItem = ( line.unMetaType & kDescLineFlag_CollectionCurrentItem ) != 0; + // use bg color as text color for current item for a better highlight + Color col = bIsCurrentItem ? Color( 0, 0, 0, 255 ) : pScheme->GetColor( GetColorNameForAttribColor( line.eColor ), Color( 255, 255, 255, 255 ) ); + // Output a color change if necessary. + if ( i == 0 || prevCollectionColor != col ) + { + pTextImage->AddColorChange( col, unCurrentCollectionTextStreamIndex ); + prevCollectionColor = col; + } + + unCurrentCollectionTextStreamIndex += StringFuncs<locchar_t>::Length( line.sText.Get() ) + 1; // add one character to deal with newlines + + if ( bIsCollectionName ) + { + continue; + } + + // Current line highlight + if ( bIsCurrentItem && m_pItemCollectionHighlight ) + { + // use text color as bg color for the current item for a better highlight + Color bgColor = pScheme->GetColor( GetColorNameForAttribColor( line.eColor ), Color( 255, 255, 255, 255 ) ); + + // Get the current ypos + int x, y; + m_pItemCollectionListLabel->GetPos( x, y ); + m_pItemCollectionHighlight->SetPos( x, y + iCollectionLineCount * fontHeight ); + m_pItemCollectionHighlight->SetBgColor( bgColor ); + m_pItemCollectionHighlight->SetVisible( bCollectionVisible ); + } + iCollectionLineCount++; + } + else + { + Color col = pScheme->GetColor( GetColorNameForAttribColor( line.eColor ), Color( 255, 255, 255, 255 ) ); + + // m_bSpecialAttributesOnly, only show purple and orange text, ignore rest + if ( m_bSpecialAttributesOnly ) + { + if ( ( line.eColor != ATTRIB_COL_UNUSUAL && line.eColor != ATTRIB_COL_STRANGE ) ) + { + continue; + } + } + + // Output a color change if necessary. + if ( i == 0 || prevAttrColor != col ) + { + pAttrTextImage->AddColorChange( col, unCurrentAttrTextStreamIndex ); + prevAttrColor = col; + } + unCurrentAttrTextStreamIndex += StringFuncs<locchar_t>::Length( line.sText.Get() ) + 1; // add one character to deal with newlines + } + } + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::DirtyDescription() +{ + m_bDescriptionDirty = true; + + if ( HasItem() ) + GetItem()->OnAttributeValuesChanged(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CItemModelPanel::UpdateMatchesLabel() +{ + const IEconTool* pTool = m_ItemData.GetStaticData()->GetEconTool(); + + if( !pTool || Q_stricmp( m_ItemData.GetStaticData()->GetEconTool()->GetTypeName() , "dynamic_recipe") ) + { + return false; + } + + m_nRecipeMatchingIndex = 0; + m_mapMatchingAttributes.Purge(); + SetNeedsToLoad(); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CItemModelPanel::UpdateQuantityLabel() +{ + if ( m_pItemQuantityLabel ) + { + bool bVisible = m_bShowQuantity && m_ItemData.GetStaticData() != NULL; + if ( bVisible ) + { + const IEconTool *pEconTool = m_ItemData.GetStaticData()->GetEconTool(); + if ( pEconTool && pEconTool->ShouldDisplayQuantity( &m_ItemData ) ) + { + wchar_t wszQuantity[16]=L""; + _snwprintf( wszQuantity, ARRAYSIZE( wszQuantity ), L"%i", m_ItemData.GetQuantity() ); + m_pItemQuantityLabel->SetVisible( true ); + m_pItemQuantityLabel->SetText( wszQuantity ); + } + else + { + bVisible = false; + } + } + m_pItemQuantityLabel->SetVisible( bVisible ); + + return true; + } + + return false; +} + +//-------------------------------------------------------------------------------------------------------- +/** + * Simple utility function to allocate memory and duplicate a wide string + */ +inline wchar_t *CloneWString( const wchar_t *str ) +{ + const int nLen = V_wcslen(str)+1; + wchar_t *cloneStr = new wchar_t [ nLen ]; + const int nSize = nLen * sizeof( wchar_t ); + V_wcsncpy( cloneStr, str, nSize ); + return cloneStr; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetNoItemText( const wchar_t *pwszTitleOverride, const wchar_t *pwszAttribs, int iNegAttribsBegin ) +{ + static CSchemaColorDefHandle pColorDef_DescAttribPositive( "desc_attrib_positive" ); + static CSchemaColorDefHandle pColorDef_DescAttribNegative( "ItemAttribNegative" ); + + CleanupNoItemWChars(); + + m_pwcNoItemText = CloneWString( pwszTitleOverride ); + m_pszNoItemText = NULL; + + if ( pwszAttribs ) + { + m_pwcNoItemAttrib = CloneWString( pwszAttribs ); + + if ( m_pItemAttribLabel && m_pItemAttribLabel->GetTextImage() ) + { + m_pItemAttribLabel->GetTextImage()->ClearColorChangeStream(); + + if ( iNegAttribsBegin ) + { + vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() ); + + if ( pColorDef_DescAttribPositive ) + { + Color col = pScheme->GetColor( pColorDef_DescAttribPositive->GetColorName(), Color(255,255,255,255) ); + m_pItemAttribLabel->GetTextImage()->AddColorChange( col, 0 ); + } + + if ( pColorDef_DescAttribNegative ) + { + Color col = pScheme->GetColor( pColorDef_DescAttribNegative->GetColorName(), Color(255,255,255,255) ); + m_pItemAttribLabel->GetTextImage()->AddColorChange( col, iNegAttribsBegin ); + } + } + } + } + + if ( !HasItem() ) + { + UpdatePanels(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::HideAllModifierIcons() +{ + if ( m_pPaintIcon ) + { + m_pPaintIcon->SetVisible( false ); + } + if ( m_pTF2Icon ) + { + m_pTF2Icon->SetVisible( false ); + } + if ( m_pItemEquippedLabel ) + { + m_pItemEquippedLabel->SetVisible( false ); + } + if ( m_pItemQuantityLabel ) + { + m_pItemQuantityLabel->SetVisible( false ); + } + if ( m_pVisionRestrictionImage ) + { + m_pVisionRestrictionImage->SetVisible( false ); + } + if ( m_pIsStrangeImage ) + { + m_pIsStrangeImage->SetVisible( false ); + } + if ( m_pIsUnusualImage ) + { + m_pIsUnusualImage->SetVisible( false ); + } + if ( m_pIsLoanerImage ) + { + m_pIsLoanerImage->SetVisible( false ); + } + if ( m_pSeriesLabel ) + { + m_pSeriesLabel->SetVisible( false ); + } + if ( m_pMatchesLabel ) + { + m_pMatchesLabel->SetVisible( false ); + } + if ( m_pItemEquippedLabel && m_bForceShowEquipped ) + { + m_pItemEquippedLabel->SetVisible( m_bForceShowEquipped ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::UpdatePanels( void ) +{ + tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ ); + + if ( !m_pModelPanel ) + return; + + m_pModelPanel->SetModelHidden( m_bHideModel ); + + // By default we dont need a tick. + vgui::ivgui()->RemoveTickSignal( GetVPanel() ); + + // Default to loading icons + se_CurrentLoadingTask = LOADING_ICONS; + + m_pModelPanel->SetItem( &m_ItemData ); + // We need to load if our image isn't in memory already. + if ( !m_bHideModel && ( m_pModelPanel->IsImageNotLoaded() || m_pModelPanel->IsLoadingWeaponSkin() ) ) + { + if ( m_pMainContentContainer ) + { + m_pMainContentContainer->SetVisible( false ); + } + + // Show the spinner + if ( m_pLoadingSpinner ) + { + m_pLoadingSpinner->SetVisible( true ); + } + + SetNeedsToLoad(); + } + else + { + // hide the spinner + if ( m_pLoadingSpinner ) + { + m_pLoadingSpinner->SetVisible( false ); + } + } + + if ( !HasItem() ) + { + if ( m_bModelOnly ) + { + if ( m_pItemNameLabel ) + { + m_pItemNameLabel->SetVisible( false ); + } + if ( m_pItemAttribLabel ) + { + m_pItemAttribLabel->SetVisible( false ); + } + } + else + { + if ( m_pItemNameLabel ) + { + const wchar_t *wcNOText = NULL; + if ( m_pszNoItemText && m_pszNoItemText[0] ) + { + wcNOText = g_pVGuiLocalize->Find( m_pszNoItemText ); + } + else if ( m_pwcNoItemText ) + { + wcNOText = m_pwcNoItemText; + } + + if ( wcNOText && wcNOText[0] ) + { + if ( m_pMainContentContainer ) + m_pMainContentContainer->SetDialogVariable( "itemname", wcNOText ); + m_pItemNameLabel->SetVisible( true ); + m_pItemNameLabel->SetColorStr( m_NoItemTextColor ); + + m_pItemNameLabel->InvalidateLayout(true,true); + if ( m_iForceTextSize && m_iForceTextSize <= 3 ) + { + // Leave center wrap on if the noitem text is getting to use the whole panel + if ( !m_bNoItemFullPanel ) + { + m_pItemNameLabel->SetCenterWrap( false ); + } + + switch ( m_iForceTextSize ) + { + case 1: + m_pItemNameLabel->SetFont( m_pFontNameLarge ); + break; + + case 2: + m_pItemNameLabel->SetFont( m_pFontNameSmall ); + break; + + case 3: + m_pItemNameLabel->SetFont( m_pFontNameSmallest ); + break; + } + } + } + else + { + m_pItemNameLabel->SetVisible( false ); + } + } + + if ( !m_bNameOnly && m_pwcNoItemAttrib ) + { + if ( m_pMainContentContainer ) + m_pMainContentContainer->SetDialogVariable( "attriblist", m_pwcNoItemAttrib ); + if ( m_pItemAttribLabel && !m_pItemAttribLabel->IsVisible() ) + { + m_pItemAttribLabel->SetVisible( true ); + } + } + else + { + if ( m_pItemAttribLabel && m_pItemAttribLabel->IsVisible() ) + { + m_pItemAttribLabel->SetVisible( false ); + } + } + } + + HideAllModifierIcons(); + return; + } + + if ( m_bHideModifierIcons ) + { + HideAllModifierIcons(); + return; + } + + if ( m_pPaintIcon ) + { + m_pPaintIcon->SetVisible( false ); + if ( !m_bHideModel && !m_bHidePaintIcon ) + { + // Empty out our list of paint colors. We may or may not put things back in -- an empty + // list at the end means "don't draw the paint icon". + m_pPaintIcon->m_colPaintColors.RemoveAll(); + + // Fetch custom texture, if any + m_pPaintIcon->m_hUGCId = m_ItemData.GetCustomUserTextureID(); + if ( m_pPaintIcon->m_hUGCId != 0 ) + m_pPaintIcon->SetVisible( true ); + + // Don't show paint icons on any tools, their icon contains the color + const bool bIsEconTool = m_ItemData.GetItemDefinition()->IsTool(); + + // Has the item been painted? + int iRGB0 = m_ItemData.GetModifiedRGBValue( false ), + iRGB1 = m_ItemData.GetModifiedRGBValue( true ); + + if ( !bIsEconTool && (iRGB0 != 0 || iRGB1 != 0)) + { + m_pPaintIcon->SetVisible( true ); + m_pPaintIcon->m_colPaintColors.AddToTail( Color( clamp( (iRGB0 & 0xFF0000) >> 16, 0, 255 ), clamp( (iRGB0 & 0xFF00) >> 8, 0, 255 ), clamp( (iRGB0 & 0xFF), 0, 255 ), 255 ) ); + if ( iRGB0 != iRGB1 ) + { + m_pPaintIcon->m_colPaintColors.AddToTail( Color( clamp( (iRGB1 & 0xFF0000) >> 16, 0, 255 ), clamp( (iRGB1 & 0xFF00) >> 8, 0, 255 ), clamp( (iRGB1 & 0xFF), 0, 255 ), 255 ) ); + } + } + } + } + + if ( m_pTF2Icon ) + { + if ( m_bHideModel || m_bHidePaintIcon ) + { + m_pTF2Icon->SetVisible( false ); + } + else + { + m_pTF2Icon->SetVisible( m_ItemData.GetSOCData() && m_ItemData.GetSOCData()->IsForeign() ); + } + } + + if ( m_bNoItemFullPanel ) + { + // If we're a noitem-fullpanel mode, we don't show strings when we have an item. + m_pItemNameLabel->SetVisible( false ); + m_pItemAttribLabel->SetVisible( false ); + } + else if ( m_bModelOnly ) + { + if ( m_pItemNameLabel ) + { + m_pItemNameLabel->SetVisible( false ); + } + if ( m_pItemAttribLabel ) + { + m_pItemAttribLabel->SetVisible( false ); + } + } + else + { + // deferred description loading + m_bDescriptionDirty = true; + SetNeedsToLoad(); + if ( m_pMainContentContainer ) + m_pMainContentContainer->SetDialogVariable( "itemname", "" ); + } + + if ( m_pItemEquippedLabel ) + { + m_pItemEquippedLabel->SetVisible( m_bForceShowEquipped || (m_bShowEquipped && IsEquipped()) ); + } + + // Hide all of these labels + if( m_pMatchesLabel ) + { + m_pMatchesLabel->SetVisible( false ); + } + + if( m_pSeriesLabel ) + { + m_pSeriesLabel->SetVisible( false ); + } + + if( m_pItemQuantityLabel ) + { + m_pItemQuantityLabel->SetVisible( false ); + } + + + // Update that number in the top right + if ( !UpdateMatchesLabel() ) + { + if ( !UpdateSeriesLabel() ) + { + UpdateQuantityLabel(); + } + } + + if ( m_pVisionRestrictionImage ) + { + int nVisionFilterFlags = 0; + const CEconItemDefinition *pData = m_ItemData.GetItemDefinition(); + if ( !m_bModelOnly && pData ) + { + nVisionFilterFlags = pData->GetVisionFilterFlags(); + + // Add support for all the holidays and "vision" mode restrictions + if ( pData->GetHolidayRestriction() ) + { + int iHolidayRestriction = UTIL_GetHolidayForString( pData->GetHolidayRestriction() ); + switch ( iHolidayRestriction ) + { + default: + case kHoliday_None: + case kHoliday_TFBirthday: + case kHoliday_Christmas: + case kHoliday_Valentines: + case kHoliday_MeetThePyro: + case kHoliday_AprilFools: + case kHoliday_EOTL: + case kHoliday_CommunityUpdate: + break; + + case kHoliday_Halloween: + case kHoliday_FullMoon: + case kHoliday_HalloweenOrFullMoon: + case kHoliday_HalloweenOrFullMoonOrValentines: + #ifdef TF_CLIENT_DLL + nVisionFilterFlags |= TF_VISION_FILTER_HALLOWEEN; + #endif + break; + } + } + } + + switch ( nVisionFilterFlags ) + { + default: + AssertMsg1( false, "Unexpected vision restriction flags %d", nVisionFilterFlags ); + case 0: + m_pVisionRestrictionImage->SetVisible( false ); + break; +#ifdef TF_CLIENT_DLL + case 1: + m_pVisionRestrictionImage->SetImage( "viewmode_pyrovision" ); + m_pVisionRestrictionImage->SetVisible( true ); + break; + case 2: + // Check if most players who have not specifically opted in will see the item. + if ( TFGameRules() ? TFGameRules()->IsHolidayActive( kHoliday_HalloweenOrFullMoon ) : TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) ) + { + m_pVisionRestrictionImage->SetImage( "viewmode_spooky" ); + } + else + { + m_pVisionRestrictionImage->SetImage( "viewmode_spooky_off" ); + } + m_pVisionRestrictionImage->SetVisible( true ); + break; + case 4: + m_pVisionRestrictionImage->SetVisible( false ); + break; +#endif + } + } + + // Strange Icon + static CSchemaAttributeDefHandle pAttrDef_StatTrakModule( "weapon_uses_stattrak_module" ); + if ( m_pIsStrangeImage ) + { + m_pIsStrangeImage->SetVisible( false ); + + if ( !m_bIsMouseOverPanel ) + { + // Allow for already strange items + bool bIsStrange = false; + if ( m_ItemData.GetQuality() == AE_STRANGE ) + { + bIsStrange = true; + } + + if ( !bIsStrange ) + { + // Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply + for ( int i = 0; i < GetKillEaterAttrCount(); i++ ) + { + if ( m_ItemData.FindAttribute( GetKillEaterAttr_Score( i ) ) ) + { + bIsStrange = true; + break; + } + } + } + if ( bIsStrange ) + { + if ( pAttrDef_StatTrakModule && m_ItemData.FindAttribute( pAttrDef_StatTrakModule ) ) + { + m_pIsStrangeImage->SetImage( "viewmode_statclock" ); + } + else + { + m_pIsStrangeImage->SetImage( "viewmode_strange" ); + + } + m_pIsStrangeImage->SetVisible( true ); + } + } + } + + // Unusual Icon + if ( m_pIsUnusualImage ) + { + m_pIsUnusualImage->SetVisible( false ); + + static CSchemaAttributeDefHandle pAttrDef_ParticleEffect( "attach particle effect" ); + static CSchemaAttributeDefHandle pAttrDef_TauntParticle( "on taunt attach particle index" ); + if ( pAttrDef_ParticleEffect && pAttrDef_TauntParticle && !m_bIsMouseOverPanel ) + { + // Cant use quality cause of old legacy items. Quality is just a quick test + if ( m_ItemData.FindAttribute( pAttrDef_ParticleEffect ) || m_ItemData.FindAttribute( pAttrDef_TauntParticle ) ) + { + m_pIsUnusualImage->SetImage( "viewmode_unusual" ); + m_pIsUnusualImage->SetVisible( true ); + } + } + } + + if ( m_pIsLoanerImage ) + { + m_pIsLoanerImage->SetVisible( false ); + if ( !m_bIsMouseOverPanel && GetAssociatedQuestItemID( &m_ItemData ) != INVALID_ITEM_ID ) + { + m_pIsLoanerImage->SetImage( "viewmode_loaner" ); + m_pIsLoanerImage->SetVisible( true ); + } + } + + InvalidateLayout(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CItemModelPanel::IsEquipped( void ) +{ + if ( !HasItem() ) + return false; + + return m_ItemData.IsEquipped(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetGreyedOut( const char *pszGreyedOutReason ) +{ + m_pszGreyedOutReason = pszGreyedOutReason; + if ( m_pModelPanel ) + { + m_pModelPanel->SetGreyedOut( m_pszGreyedOutReason != NULL ); + } + UpdateEquippedLabel(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CItemModelPanel::HasItem( void ) +{ + return m_ItemData.IsValid(); +} + +void CItemModelPanel::SetModelIsHidden( bool bHideModel ) +{ + m_bHideModel = bHideModel; + if ( m_pModelPanel ) + { + m_pModelPanel->SetModelHidden( bHideModel ); + } +} + +void CItemModelPanel::OnTick() +{ + bool bStillWorking = LoadData(); + if ( m_pContainedItemPanel ) + { + bStillWorking |= m_pContainedItemPanel->LoadData(); + } + + // If we're done working, we dont need to tick anymore + if ( !bStillWorking ) + { + LoadDataCompleted(); + } + + BaseClass::OnTick(); +} + +void CItemModelPanel::SetNeedsToLoad() +{ + vgui::ivgui()->AddTickSignalToHead( GetVPanel() ); +} + +bool CItemModelPanel::LoadData() +{ + // Different frame? + if ( sm_nCurrentDecriptionUpdateFrame != gpGlobals->framecount ) + { + // Reset + sm_nCurrentDecriptionUpdateFrame = gpGlobals->framecount; + sm_flLoadingTimeThisFrame = 0.f; + + // Figure out which loading we're going to do. We want to load + // certain things sooner (visual things, ie icons) than we start + // figuring out recipe matches. + eLoadingType_t type = NUM_LOADING_TYPES; + for( int i=0; i < NUM_LOADING_TYPES; ++i ) + { + if ( sai_NumLoadingRequests[i] > 0 && eLoadingType_t(i) < type ) + { + type = eLoadingType_t(i); + } + sai_NumLoadingRequests[i] = 0; + } + + se_CurrentLoadingTask = type; + } + + bool bStillWorking = CheckRecipeMatches(); + + if ( !m_bHideModel && m_pModelPanel ) + { + bool bImageLoaded = true; + bool bLoadingWeaponSkin = m_pModelPanel->IsLoadingWeaponSkin(); + bool bLoadingBackpackIcon = m_pModelPanel->IsImageNotLoaded(); + + if ( bLoadingWeaponSkin || bLoadingBackpackIcon ) + { + // We still need to load icons + sai_NumLoadingRequests[LOADING_ICONS]++; + if ( sm_flLoadingTimeThisFrame < tf_time_loading_item_panels.GetFloat() && se_CurrentLoadingTask == LOADING_ICONS ) + { + float flTime = Plat_FloatTime(); + + // no need to load texture if we're doing composite weapon skin + if ( bLoadingWeaponSkin ) + { + g_pMatSystemSurface->BeginSkinCompositionPainting(); + m_pModelPanel->Paint(); + g_pMatSystemSurface->EndSkinCompositionPainting(); + } + + if ( bLoadingBackpackIcon ) + { + m_pModelPanel->LoadInventoryImage(); + } + + // Accumulate time + sm_flLoadingTimeThisFrame += ( Plat_FloatTime() - flTime ); + } + + bStillWorking = m_pModelPanel->IsLoadingWeaponSkin() || m_pModelPanel->IsImageNotLoaded(); + bImageLoaded = !bStillWorking; + } + + // Hide the spinner and show the main container + if ( bImageLoaded ) + { + if ( m_pMainContentContainer && !m_pMainContentContainer->IsVisible() ) + { + m_pMainContentContainer->SetVisible( true ); + } + + if ( m_pLoadingSpinner && m_pLoadingSpinner->IsVisible() ) + { + m_pLoadingSpinner->SetVisible( false ); + } + } + } + + if ( m_bDescriptionDirty && !IsContainedItem() ) + { + // We still need to load our description + sai_NumLoadingRequests[LOADING_DESCRIPTIONS]++; + // Check if we're clear to update. We only want to eat up a little slice of time. + if ( sm_flLoadingTimeThisFrame < tf_time_loading_item_panels.GetFloat() && se_CurrentLoadingTask == LOADING_DESCRIPTIONS ) + { + float flTime = Plat_FloatTime(); + // Update! + UpdateDescription(); + + // Accumulate time + sm_flLoadingTimeThisFrame += ( Plat_FloatTime() - flTime ); + } + + bStillWorking |= m_bDescriptionDirty; + } + + return bStillWorking; +} + +void CItemModelPanel::LoadDataCompleted() +{ + vgui::ivgui()->RemoveTickSignal( GetVPanel() ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetActAsButton( bool bClickable, bool bMouseOver ) +{ + m_bClickable = bClickable; + m_bMouseOver = bMouseOver; + + SetMouseInputEnabled( m_bClickable || m_bMouseOver ); +} + +void CItemModelPanel::NavigateTo() +{ + BaseClass::NavigateTo(); + + if ( IsPC() ) + { + RequestFocus( 0 ); + } +} + +void CItemModelPanel::NavigateFrom() +{ + BaseClass::NavigateFrom(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnCursorEntered( void ) +{ + if ( !m_bMouseOver ) + return; + + if ( m_bShouldSendPanelEnterExits ) + { + PostActionSignal( new KeyValues("ItemPanelEntered") ); + } + + if ( IsEnabled() && !IsSelected() ) + { + NavigateTo(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnCursorExited( void ) +{ + if ( !m_bMouseOver ) + return; + + if ( m_bShouldSendPanelEnterExits ) + { + PostActionSignal( new KeyValues("ItemPanelExited") ); + } + + if ( IsSelected() ) + { + NavigateFrom(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +extern ISoundEmitterSystemBase *soundemitterbase; +void CItemModelPanel::OnMousePressed(vgui::MouseCode code) +{ + if ( code == MOUSE_RIGHT ) + { + PostActionSignal( new KeyValues("ItemPanelMouseRightRelease") ); + } + + if ( !m_bClickable || code != MOUSE_LEFT ) + return; + + PostActionSignal( new KeyValues("ItemPanelMousePressed") ); + + // audible feedback + const char *soundFilename = "ui/buttonclick.wav"; + + if ( m_bUseItemSounds ) + { + CEconItemView *item = GetItem(); + if ( item ) + { + soundFilename = item->GetDefinitionString( "mouse_pressed_sound", "ui/item_default_pickup.wav" ); + } + } + + const char *pszSound = UTIL_GetRandomSoundFromEntry( soundFilename ); + if ( pszSound && pszSound[0] ) + { + vgui::surface()->PlaySound( pszSound ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnMouseReleased(vgui::MouseCode code) +{ + if ( !m_bClickable || code != MOUSE_LEFT ) + return; + + PostActionSignal( new KeyValues("ItemPanelMouseReleased") ); + + // audible feedback + // we're not using item sounds here because they are better handled by the drag/drop code elsewhere + if ( !m_bUseItemSounds ) + { + vgui::surface()->PlaySound( "ui/buttonclickrelease.wav" ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnMouseDoublePressed(vgui::MouseCode code) +{ + if ( !m_bClickable || code != MOUSE_LEFT ) + return; + + PostActionSignal( new KeyValues("ItemPanelMouseDoublePressed") ); + + // audible feedback + const char *soundFilename = "ui/buttonclickrelease.wav"; + + if ( m_bUseItemSounds ) + { + CEconItemView *item = GetItem(); + if ( item ) + { + soundFilename = item->GetDefinitionString( "mouse_double_pressed_sound", "ui/item_default_drop.wav" ); + } + } + + vgui::surface()->PlaySound( soundFilename ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnCursorMoved( int x, int y ) +{ + if ( !m_bClickable ) + return; + + // Add our own xpos/ypos offset + int iXPos; + int iYPos; + GetPos( iXPos, iYPos ); + PostActionSignal( new KeyValues("ItemPanelCursorMoved", "x", x + iXPos, "y", y + iYPos) ); +} + +void CItemModelPanel::OnKeyCodePressed( vgui::KeyCode code ) +{ + BaseClass::OnKeyCodePressed( code ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::OnCommand( const char *command ) +{ + if ( FStrEq( command, "sellitem" ) ) + { + if ( HasItem() && steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() ) + { + const char *pszPrefix = ""; + if ( GetUniverse() == k_EUniverseBeta ) + { + pszPrefix = "beta."; + } + uint32 nAssetContext = 2; // k_EEconContextBackpack + char szURL[512]; + V_snprintf( szURL, sizeof(szURL), "http://%ssteamcommunity.com/my/inventory/?sellOnLoad=1#%d_%d_%llu", pszPrefix, engine->GetAppID(), nAssetContext, GetItem()->GetItemID() ); + steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( szURL ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::UpdateEquippedLabel( void ) +{ + if ( !m_pItemEquippedLabel ) + return; + + if ( IsGreyedOut() ) + { + m_pItemEquippedLabel->SetFgColor( Color(96,96,96,255) ); + } + else + { + m_pItemEquippedLabel->SetFgColor( Color(200,80,60,255) ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanel::SetSkin( int iSkin ) +{ + if ( m_pModelPanel ) + { + m_pModelPanel->SetSkin( iSkin ); + } +} + + +itempanel_tooltippos_t g_iTooltipStrategies[NUM_IPTTP_STRATEGIES][NUM_POSITIONS_PER_STRATEGY] = +{ + { IPTTP_LEFT, IPTTP_LEFT_CENTERED, IPTTP_ABOVE, IPTTP_BELOW, IPTTP_RIGHT_CENTERED, IPTTP_RIGHT }, // IPTTP_LEFT_SIDE + { IPTTP_RIGHT, IPTTP_RIGHT_CENTERED, IPTTP_ABOVE, IPTTP_BELOW, IPTTP_LEFT_CENTERED, IPTTP_LEFT }, // IPTTP_RIGHT_SIDE + { IPTTP_ABOVE, IPTTP_LEFT_CENTERED, IPTTP_RIGHT_CENTERED, IPTTP_LEFT, IPTTP_RIGHT, IPTTP_ABOVE }, // IPTTP_TOP_SIDE + { IPTTP_BELOW, IPTTP_LEFT_CENTERED, IPTTP_RIGHT_CENTERED, IPTTP_LEFT, IPTTP_RIGHT, IPTTP_ABOVE }, // IPTTP_BOTTOM_SIDE +}; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CItemModelPanelToolTip::CItemModelPanelToolTip( vgui::Panel *parent, const char *text ) +: vgui::BaseTooltip( parent, text ) +, m_pMouseOverItemPanel( NULL ) +, m_iPositioningStrategy( IPTTP_BOTTOM_SIDE ) +{ + m_hCurrentPanel = NULL; + SetTooltipDelay( 100 ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanelToolTip::GetPosition( itempanel_tooltippos_t iTooltipPosition, CItemModelPanel *pItemPanel, int iItemX, int iItemY, int *iXPos, int *iYPos ) +{ + switch ( iTooltipPosition ) + { + case IPTTP_LEFT: + *iXPos = (iItemX - m_pMouseOverItemPanel->GetWide() + XRES(18)); + *iYPos = iItemY - YRES(7); + break; + case IPTTP_RIGHT: + *iXPos = (iItemX + pItemPanel->GetWide() - XRES(20)); + *iYPos = iItemY - YRES(7); + break; + case IPTTP_LEFT_CENTERED: + *iXPos = (iItemX - m_pMouseOverItemPanel->GetWide()) - XRES(4); + *iYPos = (iItemY - (m_pMouseOverItemPanel->GetTall() * 0.5)); + break; + case IPTTP_RIGHT_CENTERED: + *iXPos = (iItemX + pItemPanel->GetWide()) + XRES(4); + *iYPos = (iItemY - (m_pMouseOverItemPanel->GetTall() * 0.5)); + break; + case IPTTP_ABOVE: + *iXPos = (iItemX + (pItemPanel->GetWide() * 0.5)) - (m_pMouseOverItemPanel->GetWide() * 0.5); + *iYPos = (iItemY - m_pMouseOverItemPanel->GetTall() - YRES(4)); + break; + case IPTTP_BELOW: + *iXPos = (iItemX + (pItemPanel->GetWide() * 0.5)) - (m_pMouseOverItemPanel->GetWide() * 0.5); + *iYPos = (iItemY + pItemPanel->GetTall() + YRES(4)); + break; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CItemModelPanelToolTip::ValidatePosition( CItemModelPanel *pItemPanel, int iItemX, int iItemY, int *iXPos, int *iYPos ) +{ + bool bSucceeded = true; + + // Make sure the popup stays onscreen. + if ( *iXPos < 0 ) + { + *iXPos = 0; + } + else if ( (*iXPos + m_pMouseOverItemPanel->GetWide()) > m_pParentPanel->GetWide() ) + { + int iXPosNew = m_pParentPanel->GetWide() - m_pMouseOverItemPanel->GetWide(); + // make sure it is still on the screen + if ( iXPosNew >= 0 ) + { + *iXPos = iXPosNew; + } + else + { + bSucceeded = false; + } + } + + if ( *iYPos < 0 ) + { + *iYPos = 0; + } + else if ( (*iYPos + m_pMouseOverItemPanel->GetTall() + YRES(32)) > m_pParentPanel->GetTall() ) + { + // Move it up above our item + int iYPosNew = iItemY - m_pMouseOverItemPanel->GetTall() - YRES(4); + // make sure it is still on the screen + if ( iYPosNew >= 0 ) + { + *iYPos = iYPosNew; + } + else + { + bSucceeded = false; + } + } + + if ( bSucceeded ) + { + // We also fail if moving it to keep it on screen moved it over the item panel itself + Vector2D vecToolTipMin, vecToolTipMax, vecItemMin, vecItemMax; + vecToolTipMin.x = *iXPos; + vecToolTipMin.y = *iYPos; + vecToolTipMax.x = vecToolTipMin.x + m_pMouseOverItemPanel->GetWide(); + vecToolTipMax.y = vecToolTipMin.y + m_pMouseOverItemPanel->GetTall(); + + vecItemMin.x = iItemX; + vecItemMin.y = iItemY; + vecItemMax.x = vecItemMin.x + m_hCurrentPanel->GetWide(); + vecItemMax.y = vecItemMin.y + m_hCurrentPanel->GetTall(); + + bSucceeded = !( vecToolTipMin.x < vecItemMax.x && vecToolTipMax.x > vecItemMin.x && vecToolTipMin.y < vecItemMax.y && vecToolTipMax.y > vecItemMin.y ); + } + + return bSucceeded; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanelToolTip::PerformLayout() +{ + BaseClass::PerformLayout(); + + if ( !ShouldLayout() ) + return; + + _isDirty = false; + + CItemModelPanel *pItemPanel = m_hCurrentPanel.Get(); + if ( m_pMouseOverItemPanel && pItemPanel ) + { + CEconItemView *pItem = pItemPanel->GetItem(); + if ( pItem && pItemPanel->ShouldShowTooltip() /*&& !IsIgnoringItemPanelEnters()*/ ) + { + m_pMouseOverItemPanel->SetGreyedOut( pItemPanel->GetGreyedOutReason() ); + m_pMouseOverItemPanel->SetItem( pItem ); + m_pMouseOverItemPanel->DirtyDescription(); // Force rebuilding the description when we first display + m_pMouseOverItemPanel->UpdateDescription(); + m_pMouseOverItemPanel->HideContainedItemPanel(); + m_pMouseOverItemPanel->InvalidateLayout(true); + + int x,y; + + // If the panel is somewhere in a derived class, we need to get its position in our space + if ( pItemPanel->GetParent() != m_pMouseOverItemPanel->GetParent() ) + { + int iItemAbsX, iItemAbsY; + vgui::ipanel()->GetAbsPos( pItemPanel->GetVPanel(), iItemAbsX, iItemAbsY ); + int iParentAbsX, iParentAbsY; + vgui::ipanel()->GetAbsPos( m_pMouseOverItemPanel->GetParent()->GetVPanel(), iParentAbsX, iParentAbsY ); + + x = (iItemAbsX - iParentAbsX); + y = (iItemAbsY - iParentAbsY); + } + else + { + pItemPanel->GetPos( x, y ); + } + + int iXPos = 0; + int iYPos = 0; + + // Loop through the positions in our strategy, and hope we find a valid spot + for ( int i = 0; i < NUM_POSITIONS_PER_STRATEGY; i++ ) + { + itempanel_tooltippos_t iPos = g_iTooltipStrategies[m_iPositioningStrategy][i]; + GetPosition( iPos, pItemPanel, x, y, &iXPos, &iYPos ); + + if ( ValidatePosition( pItemPanel, x, y, &iXPos, &iYPos ) ) + break; + } + + m_pMouseOverItemPanel->SetPos( iXPos, iYPos ); + m_pMouseOverItemPanel->SetVisible( true ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanelToolTip::ShowTooltip( Panel *currentPanel ) +{ + if ( m_pMouseOverItemPanel && currentPanel != m_hCurrentPanel.Get() ) + { + CItemModelPanel *pItemPanel = assert_cast<CItemModelPanel *>(currentPanel); + m_hCurrentPanel.Set( pItemPanel ); + pItemPanel->PostActionSignal( new KeyValues("ItemPanelEntered") ); + vgui::surface()->PlaySound( "ui/item_info_mouseover.wav" ); + + m_pMouseOverItemPanel->HideContainedItemPanel(); + } + BaseClass::ShowTooltip( currentPanel ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CItemModelPanelToolTip::HideTooltip() +{ + if ( m_pMouseOverItemPanel ) + { + m_pMouseOverItemPanel->SetVisible( false ); + } + + if ( m_hCurrentPanel ) + { + m_hCurrentPanel.Get()->PostActionSignal( new KeyValues("ItemPanelExited") ); + m_hCurrentPanel = NULL; + } +} |