engine: again fix static prop lump version 10 loading

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.AddMultipleToTail(count);
-	m_StaticProps.EnsureCapacity(count);
 	for ( int i = 0; i < count; ++i )
 	{
-		// Reset every loop.
-		bSkip = false;
-
 		StaticPropLump_t lump;
 		switch ( nLumpVersion )
 		{
-		case 4:
+			case 4: UnserializeLump<StaticPropLumpV4_t>(&lump, buf); break;
-			buf.Get( &lump, sizeof(StaticPropLumpV4_t) );
+			case 5: UnserializeLump<StaticPropLumpV5_t>(&lump, buf); break;
-			lump.m_flForcedFadeScale = 1.0f;
+			case 6: UnserializeLump<StaticPropLumpV6_t>(&lump, buf); break;
-			lump.m_nMinCPULevel = lump.m_nMaxCPULevel = lump.m_nMinGPULevel = lump.m_nMaxGPULevel = 0;
+			case 7: // Falls down to version 10. We promoted TF to version 10 to deal with SFM. 
-			lump.m_DiffuseModulation.r = lump.m_DiffuseModulation.g = lump.m_DiffuseModulation.b = lump.m_DiffuseModulation.a = 255; // default color/alpha modulation to identity
+			case 9: UnserializeLump<StaticPropLumpV9_t>(&lump, buf); break;
-			lump.m_bDisableX360 = false;
+			case 10:
-			lump.m_FlagsEx = 0;
+			{
-			break;
+				if( s_MapHeader.version == 21 )
-
+					UnserializeLump<StaticPropLumpV10_21_t>(&lump, buf);
-		case 5:
+				else
-			buf.Get( &lump, sizeof(StaticPropLumpV5_t) );
+					UnserializeLump<StaticPropLumpV10_t>(&lump, buf);
-			lump.m_nMinCPULevel = lump.m_nMaxCPULevel = lump.m_nMinGPULevel = lump.m_nMaxGPULevel = 0;
+				break;
-			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;
+			default:
-			lump.m_FlagsEx = 0;
+				Assert("Unexpected version while deserializing lumps.");
-			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;
 		}
 
-		int j = m_StaticProps.AddToTail();
+		m_StaticProps[i].Init( i, lump, m_StaticPropDict[lump.m_PropType].m_pModel );
-		m_StaticProps[j].Init( j, 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

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<const StaticPropLumpV4_t&>(_rhs);
+
+		m_flForcedFadeScale = _rhs.m_flForcedFadeScale;
+		return *this;
+	}
+
+	inline StaticPropLump_t& operator=(const StaticPropLumpV6_t& _rhs)
+	{
+		(*this) = reinterpret_cast<const StaticPropLumpV5_t&>(_rhs);
+
+		m_nMinDXLevel = _rhs.m_nMinDXLevel;
+		m_nMaxDXLevel = _rhs.m_nMaxDXLevel;
+		return *this;
+	}
+
+	inline StaticPropLump_t& operator=(const StaticPropLumpV9_t& _rhs)
+	{
+		(*this) = reinterpret_cast<const StaticPropLumpV5_t&>(_rhs);
+
+		m_DiffuseModulation = _rhs.m_DiffuseModulation;
+		return *this;
+	}
+
+	inline StaticPropLump_t& operator=(const StaticPropLumpV10_t& _rhs)
+	{
+		(*this) = reinterpret_cast<const StaticPropLumpV6_t&>(_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<const StaticPropLumpV9_t&>(_rhs);
+
+		m_FlagsEx = _rhs.m_FlagsEx;
+		return *this;
+	}
+};
+
 struct StaticPropLeafLump_t
 {
 	DECLARE_BYTESWAP_DATADESC();