From 1d39be1a97a2248c9fda3d6ed8a891c370941419 Mon Sep 17 00:00:00 2001 From: nillerusr Date: Fri, 17 Feb 2023 01:41:55 +0300 Subject: [PATCH] engine: again fix static prop lump version 10 loading --- engine/staticpropmgr.cpp | 81 +++++++----------------------- public/gamebspfile.h | 104 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 121 insertions(+), 64 deletions(-) diff --git a/engine/staticpropmgr.cpp b/engine/staticpropmgr.cpp index 1605ebf5..fb298443 100644 --- a/engine/staticpropmgr.cpp +++ b/engine/staticpropmgr.cpp @@ -536,12 +536,12 @@ bool CStaticProp::Init( int index, StaticPropLump_t &lump, model_t *pModel ) m_Flags = ( lump.m_Flags & (STATIC_PROP_SCREEN_SPACE_FADE | STATIC_PROP_FLAG_FADES | STATIC_PROP_NO_PER_VERTEX_LIGHTING) ); int nCurrentDXLevel = g_pMaterialSystemHardwareConfig->GetDXSupportLevel(); -/* bool bNoDraw = ( lump.m_nMinDXLevel && lump.m_nMinDXLevel > nCurrentDXLevel ); + bool bNoDraw = ( lump.m_nMinDXLevel && lump.m_nMinDXLevel > nCurrentDXLevel ); bNoDraw = bNoDraw || ( lump.m_nMaxDXLevel && lump.m_nMaxDXLevel < nCurrentDXLevel ); if ( bNoDraw ) { m_Flags |= STATIC_PROP_NO_DRAW; - }*/ + } // Cache the model to world matrix since it never changes. AngleMatrix( lump.m_Angles, lump.m_Origin, m_ModelToWorld ); @@ -1329,73 +1329,30 @@ void CStaticPropMgr::UnserializeModels( CUtlBuffer& buf ) // Gotta preallocate the static props here so no rellocations take place // the leaf list stores pointers to these tricky little guys. - bool bSkip = false; - m_StaticProps.EnsureCapacity(count); + m_StaticProps.AddMultipleToTail(count); for ( int i = 0; i < count; ++i ) { - // Reset every loop. - bSkip = false; - StaticPropLump_t lump; switch ( nLumpVersion ) { - case 4: - buf.Get( &lump, sizeof(StaticPropLumpV4_t) ); - lump.m_flForcedFadeScale = 1.0f; - lump.m_nMinCPULevel = lump.m_nMaxCPULevel = lump.m_nMinGPULevel = lump.m_nMaxGPULevel = 0; - lump.m_DiffuseModulation.r = lump.m_DiffuseModulation.g = lump.m_DiffuseModulation.b = lump.m_DiffuseModulation.a = 255; // default color/alpha modulation to identity - lump.m_bDisableX360 = false; - lump.m_FlagsEx = 0; - break; - - case 5: - buf.Get( &lump, sizeof(StaticPropLumpV5_t) ); - lump.m_nMinCPULevel = lump.m_nMaxCPULevel = lump.m_nMinGPULevel = lump.m_nMaxGPULevel = 0; - lump.m_DiffuseModulation.r = lump.m_DiffuseModulation.g = lump.m_DiffuseModulation.b = lump.m_DiffuseModulation.a = 255; // default color/alpha modulation to identity - lump.m_bDisableX360 = false; - lump.m_FlagsEx = 0; - break; - - case 6: - buf.Get( &lump, sizeof( StaticPropLumpV6_t ) ); - lump.m_nMinCPULevel = lump.m_nMaxCPULevel = lump.m_nMinGPULevel = lump.m_nMaxGPULevel = 0; - lump.m_DiffuseModulation.r = lump.m_DiffuseModulation.g = lump.m_DiffuseModulation.b = lump.m_DiffuseModulation.a = 255; // default color/alpha modulation to identity - lump.m_bDisableX360 = false; - lump.m_FlagsEx = 0; - break; - - case 7: - buf.Get( &lump, sizeof( StaticPropLumpV7_t ) ); - lump.m_nMinCPULevel = lump.m_nMaxCPULevel = lump.m_nMinGPULevel = lump.m_nMaxGPULevel = 0; - lump.m_bDisableX360 = false; - lump.m_FlagsEx = 0; - break; - - case 8: - buf.Get( &lump, sizeof( StaticPropLumpV8_t ) ); - lump.m_bDisableX360 = false; - lump.m_FlagsEx = 0; - break; - - case 9: - buf.Get( &lump, sizeof( StaticPropLumpV9_t ) ); - lump.m_FlagsEx = 0; - break; - - case 10: - if( s_MapHeader.version >= 21 ) - buf.Get( &lump, sizeof( StaticPropLumpV10_21_t ) ); - else - buf.Get( &lump, sizeof( StaticPropLumpV10_t ) ); - break; - - case 11: - buf.Get( &lump, sizeof( StaticPropLump_t ) ); - break; + case 4: UnserializeLump(&lump, buf); break; + case 5: UnserializeLump(&lump, buf); break; + case 6: UnserializeLump(&lump, buf); break; + case 7: // Falls down to version 10. We promoted TF to version 10 to deal with SFM. + case 9: UnserializeLump(&lump, buf); break; + case 10: + { + if( s_MapHeader.version == 21 ) + UnserializeLump(&lump, buf); + else + UnserializeLump(&lump, buf); + break; + } + default: + Assert("Unexpected version while deserializing lumps."); } - int j = m_StaticProps.AddToTail(); - m_StaticProps[j].Init( j, lump, m_StaticPropDict[lump.m_PropType].m_pModel ); + m_StaticProps[i].Init( i, lump, m_StaticPropDict[lump.m_PropType].m_pModel ); // For distance-based fading, keep a list of the things that need // to be faded out. Not sure if this is the optimal way of doing it diff --git a/public/gamebspfile.h b/public/gamebspfile.h index 2e05262e..151d160e 100644 --- a/public/gamebspfile.h +++ b/public/gamebspfile.h @@ -292,7 +292,7 @@ struct StaticPropLumpV10_t unsigned short m_nLightmapResolutionY; }; -// version 10 +// version 10 bsp21 struct StaticPropLumpV10_21_t { DECLARE_BYTESWAP_DATADESC(); @@ -319,7 +319,7 @@ struct StaticPropLumpV10_21_t }; // version 11 -struct StaticPropLump_t +struct StaticPropLumpV11_t { DECLARE_BYTESWAP_DATADESC(); Vector m_Origin; @@ -345,6 +345,106 @@ struct StaticPropLump_t float m_flPropScale; }; +struct StaticPropLump_t +{ + DECLARE_BYTESWAP_DATADESC(); + Vector m_Origin; + QAngle m_Angles; + unsigned short m_PropType; + unsigned short m_FirstLeaf; + unsigned short m_LeafCount; + unsigned char m_Solid; + int m_Skin; + float m_FadeMinDist; + float m_FadeMaxDist; + Vector m_LightingOrigin; + float m_flForcedFadeScale; + unsigned short m_nMinDXLevel; + unsigned short m_nMaxDXLevel; + // int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump + unsigned int m_Flags; + unsigned short m_nLightmapResolutionX; + unsigned short m_nLightmapResolutionY; + + color32 m_DiffuseModulation; // per instance color and alpha modulation + bool m_bDisableX360; + int m_FlagsEx; // more flags (introduced in v10) + + inline StaticPropLump_t& operator=(const StaticPropLumpV4_t& _rhs) + { + m_Origin = _rhs.m_Origin; + m_Angles = _rhs.m_Angles; + m_PropType = _rhs.m_PropType; + m_FirstLeaf = _rhs.m_FirstLeaf; + m_LeafCount = _rhs.m_LeafCount; + m_Solid = _rhs.m_Solid; + m_Flags = _rhs.m_Flags; + m_Skin = _rhs.m_Skin; + m_FadeMinDist = _rhs.m_FadeMinDist; + m_FadeMaxDist = _rhs.m_FadeMaxDist; + m_LightingOrigin = _rhs.m_LightingOrigin; + + // These get potentially set twice--once here and once in the caller. + // Value judgement: This makes the code easier to work with, so unless it's a perf issue... + m_flForcedFadeScale = 1.0f; + m_nMinDXLevel = 0; + m_nMaxDXLevel = 0; + m_nLightmapResolutionX = 0; + m_nLightmapResolutionY = 0; + m_DiffuseModulation.r = 0; + m_DiffuseModulation.g = 0; + m_DiffuseModulation.b = 0; + m_DiffuseModulation.a = 0; + + // Older versions don't want this. + m_Flags |= STATIC_PROP_NO_PER_TEXEL_LIGHTING; + return *this; + } + + inline StaticPropLump_t& operator=(const StaticPropLumpV5_t& _rhs) + { + (*this) = reinterpret_cast(_rhs); + + m_flForcedFadeScale = _rhs.m_flForcedFadeScale; + return *this; + } + + inline StaticPropLump_t& operator=(const StaticPropLumpV6_t& _rhs) + { + (*this) = reinterpret_cast(_rhs); + + m_nMinDXLevel = _rhs.m_nMinDXLevel; + m_nMaxDXLevel = _rhs.m_nMaxDXLevel; + return *this; + } + + inline StaticPropLump_t& operator=(const StaticPropLumpV9_t& _rhs) + { + (*this) = reinterpret_cast(_rhs); + + m_DiffuseModulation = _rhs.m_DiffuseModulation; + return *this; + } + + inline StaticPropLump_t& operator=(const StaticPropLumpV10_t& _rhs) + { + (*this) = reinterpret_cast(_rhs); + + m_Flags = _rhs.m_Flags; + m_nLightmapResolutionX = _rhs.m_nLightmapResolutionX; + m_nLightmapResolutionY = _rhs.m_nLightmapResolutionY; + return *this; + } + + inline StaticPropLump_t& operator=(const StaticPropLumpV10_21_t& _rhs) + { + (*this) = reinterpret_cast(_rhs); + + m_FlagsEx = _rhs.m_FlagsEx; + return *this; + } +}; + struct StaticPropLeafLump_t { DECLARE_BYTESWAP_DATADESC();