1HEADmaster

1 files changed, 1336 insertions, 0 deletions

diff --git a/game/client/c_func_breakablesurf.cpp b/game/client/c_func_breakablesurf.cpp
new file mode 100644
index 0000000..3118cd5
--- /dev/null
+++ b/game/client/c_func_breakablesurf.cpp
@@ -0,0 +1,1336 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "particles_simple.h"
+#include "iviewrender.h"
+#include "proxyentity.h"
+#include "materialsystem/imaterialvar.h"
+#include "model_types.h"
+#include "engine/ivmodelinfo.h"
+#include "clienteffectprecachesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define MAX_NUM_PANELS 16
+
+extern IVDebugOverlay *debugoverlay;
+
+
+enum WinSide_t 
+{
+	WIN_SIDE_BOTTOM,
+	WIN_SIDE_RIGHT,
+	WIN_SIDE_TOP,
+	WIN_SIDE_LEFT,
+};
+
+enum WinEdge_t 
+{
+	EDGE_NOT	= -1,		// No edge
+	EDGE_NONE,				/* No edge on both sides	/##\  */
+	EDGE_FULL,				// Edge on both sides		|##| 
+	EDGE_LEFT,				/* Edge is on left only		|##\  */
+	EDGE_RIGHT,				// Edge is on right only	/##|
+};
+
+#define STYLE_HIGHLIGHT = -1;
+
+#define NUM_EDGE_TYPES		4
+#define NUM_EDGE_STYLES		3
+
+
+//==================================================
+// C_BreakableSurface
+//==================================================
+
+//-----------------------------------------------------------------------------
+// All the information associated with a particular handle
+//-----------------------------------------------------------------------------
+struct Panel_t
+{
+	char			m_nWidth;
+	char			m_nHeight;
+	char			m_nSide;
+	char			m_nEdgeType;
+	char			m_nStyle;
+};
+
+struct EdgeTexture_t
+{
+	int					m_nRenderIndex;
+	int					m_nStyle;
+	CMaterialReference	m_pMaterialEdge;
+	CTextureReference	m_pMaterialEdgeTexture;
+};
+
+// Bits for m_nPanelBits
+#define BITS_PANEL_IS_SOLID		(1<<0)
+#define BITS_PANEL_IS_STALE		(1<<1)
+
+
+class C_BreakableSurface : public C_BaseEntity, public IBrushRenderer
+{
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_CLASS( C_BreakableSurface, C_BaseEntity );
+	DECLARE_DATADESC();
+
+	int				m_nNumWide;
+	int				m_nNumHigh;
+	float			m_flPanelWidth;
+	float			m_flPanelHeight;
+	Vector			m_vNormal;
+	Vector			m_vCorner;
+	bool			m_bIsBroken;
+	int				m_nSurfaceType;
+
+						
+	// This is the texture we're going to use to multiply by the cracked base texture
+	ITexture*	m_pCurrentDetailTexture;
+
+	// Stores linked list of edges to render
+	CUtlLinkedList< Panel_t, unsigned short >		m_RenderList;
+
+
+	C_BreakableSurface();
+	~C_BreakableSurface();
+
+public:
+	void		InitMaterial(WinEdge_t nEdgeType, int nEdgeStyle, char const* pMaterialName);
+	virtual void		OnDataChanged( DataUpdateType_t updateType );
+	virtual void		OnPreDataChanged( DataUpdateType_t updateType );
+
+	bool		IsTransparent( void );
+	bool		HavePanel(int nWidth, int nHeight);
+	bool		RenderBrushModelSurface( IClientEntity* pBaseEntity, IBrushSurface* pBrushSurface ); 
+	int			DrawModel( int flags );
+	void		DrawSolidBlocks( IBrushSurface* pBrushSurface );
+
+	virtual void	OnRestore();
+
+	virtual bool	ShouldReceiveProjectedTextures( int flags );
+
+private:
+	// One bit per pane
+	CNetworkArray( bool, m_RawPanelBitVec, MAX_NUM_PANELS * MAX_NUM_PANELS );
+	bool m_PrevRawPanelBitVec[ MAX_NUM_PANELS * MAX_NUM_PANELS ];
+	
+	// 2 bits of flags and 2 bits of edge type
+	byte		m_nPanelBits[MAX_NUM_PANELS][MAX_NUM_PANELS];	//UNDONE: allocate this dynamically?
+	CMaterialReference	m_pMaterialBox;	
+	EdgeTexture_t	m_pSolid;
+	EdgeTexture_t	m_pEdge[NUM_EDGE_TYPES][NUM_EDGE_STYLES];
+
+	inline bool InLegalRange(int nWidth, int nHeight);
+	inline bool	IsPanelSolid(int nWidth, int nHeight);
+	inline bool	IsPanelStale(int nWidth, int nHeight);
+	inline void	SetPanelSolid(int nWidth, int nHeight, bool value);
+	inline void	SetPanelStale(int nWidth, int nHeight, bool value);
+
+	void		DrawOneEdge( IBrushSurface* pBrushSurface, IMesh* pMesh, 
+					CMeshBuilder *pMeshBuilder, const Vector &vStartPos,  
+					const Vector &vWStep, const Vector &vHstep, WinSide_t nEdge);
+	void		DrawOneHighlight( IBrushSurface* pBrushSurface, IMesh* pMesh, 
+					CMeshBuilder *pMeshBuilder, const Vector &vStartPos,  
+					const Vector &vWStep, const Vector &vHstep, WinSide_t nEdge);
+	void		DrawOneBlock(IBrushSurface* pBrushSurface, IMesh* pMesh, 
+					CMeshBuilder *pMeshBuilder, const Vector &vPosition, 
+					const Vector &vWidth, const Vector &vHeight);
+
+	void		DrawRenderList( IBrushSurface* pBrushSurface);
+	void		DrawRenderListHighlights( IBrushSurface* pBrushSurface );
+	int			FindRenderPanel(int nWidth, int nHeight, WinSide_t nSide);
+	void		AddToRenderList(int nWidth, int nHeight, WinSide_t nSide, WinEdge_t nEdgeType, int forceStyle);
+	int			FindFirstRenderTexture(WinEdge_t nEdgeType, int nStyle);
+
+	inline void SetStyleType( int w, int h, int type )
+	{
+		Assert( type < NUM_EDGE_STYLES );
+		Assert( type >= 0 );
+		// Clear old value
+		m_nPanelBits[ w ][ h ] &= 0xF0; // ( ~0x03 << 2 ); Left shifting a negative value has undefined behavior. Use the constant 0xF0 instead.
+		// Insert new value
+		m_nPanelBits[ w ][ h ] |= ( type << 2 );
+	}
+
+	inline int GetStyleType( int w, int h )
+	{
+		int value = m_nPanelBits[ w ][ h ];
+		value = ( value >> 2 ) & 0x03;
+		Assert( value < NUM_EDGE_STYLES );
+		return value;
+	}
+
+	// Gets at the cracked version of the material
+	void FindCrackedMaterial();
+
+	CMaterialReference	m_pCrackedMaterial;
+	CTextureReference	m_pMaterialBoxTexture;
+
+
+	void		UpdateEdgeType(int nWidth, int nHeight, int forceStyle = -1 );
+};
+
+BEGIN_DATADESC( C_BreakableSurface )
+
+	DEFINE_ARRAY( m_nPanelBits, FIELD_CHARACTER, MAX_NUM_PANELS * MAX_NUM_PANELS ),
+
+//	DEFINE_FIELD( m_nNumWide, FIELD_INTEGER ),
+//	DEFINE_FIELD( m_nNumHigh, FIELD_INTEGER ),
+//	DEFINE_FIELD( m_flPanelWidth, FIELD_FLOAT ),
+//	DEFINE_FIELD( m_flPanelHeight, FIELD_FLOAT ),
+//	DEFINE_FIELD( m_vNormal, FIELD_VECTOR ),
+//	DEFINE_FIELD( m_vCorner, FIELD_VECTOR ),
+//	DEFINE_FIELD( m_bIsBroken, FIELD_BOOLEAN ),
+//	DEFINE_FIELD( m_nSurfaceType, FIELD_INTEGER ),
+	// DEFINE_FIELD( m_pCurrentDetailTexture, ITexture* ),
+	// DEFINE_FIELD( m_RenderList, CUtlLinkedList < Panel_t , unsigned short > ),
+	// DEFINE_FIELD( m_pMaterialBox, CMaterialReference ),
+	// DEFINE_FIELD( m_pSolid, EdgeTexture_t ),
+	// DEFINE_ARRAY( m_pEdge, EdgeTexture_t, NUM_EDGE_TYPES][NUM_EDGE_STYLES ),
+	// DEFINE_FIELD( m_pCrackedMaterial, CMaterialReference ),
+	// DEFINE_FIELD( m_pMaterialBoxTexture, CTextureReference ),
+
+END_DATADESC()
+
+bool C_BreakableSurface::InLegalRange(int nWidth, int nHeight)
+{ 
+	return (nWidth < m_nNumWide && nHeight < m_nNumHigh && 
+		nWidth >=0 && nHeight >= 0 );
+}
+
+bool C_BreakableSurface::IsPanelSolid(int nWidth, int nHeight)
+{ 
+	return ( BITS_PANEL_IS_SOLID & m_nPanelBits[nWidth][nHeight] )!=0 ;
+}
+
+bool C_BreakableSurface::IsPanelStale(int nWidth, int nHeight)
+{ 
+	return ( BITS_PANEL_IS_STALE & m_nPanelBits[nWidth][nHeight] )!=0 ; 
+}
+
+void C_BreakableSurface::SetPanelSolid(int nWidth, int nHeight, bool value)
+{ 
+	if ( !InLegalRange( nWidth, nHeight ) )
+		return;
+
+	if ( value )
+	{
+		m_nPanelBits[nWidth][nHeight] |= BITS_PANEL_IS_SOLID;
+	}
+	else
+	{
+		m_nPanelBits[nWidth][nHeight] &= ~BITS_PANEL_IS_SOLID;
+	}
+}
+
+void C_BreakableSurface::SetPanelStale(int nWidth, int nHeight, bool value)
+{ 
+	if ( !InLegalRange( nWidth, nHeight) )
+		return;
+
+	if ( value )
+	{
+		m_nPanelBits[nWidth][nHeight] |= BITS_PANEL_IS_STALE;
+	}
+	else
+	{
+		m_nPanelBits[nWidth][nHeight] &= ~BITS_PANEL_IS_STALE;
+	}
+}
+
+void C_BreakableSurface::OnRestore()
+{
+	BaseClass::OnRestore();
+
+	// FIXME:  This restores the general state, but not the random edge bits
+	//  those would need to be serialized separately...
+	// traverse everthing and restore bits
+	// Initialize panels
+	for (int w=0;w<m_nNumWide;w++)
+	{ 
+		for (int h=0;h<m_nNumHigh;h++)
+		{
+			// Force recomputation
+			SetPanelSolid(w,h,IsPanelSolid(w,h));
+			SetPanelStale(w,h,true);
+			UpdateEdgeType( w, h, GetStyleType(w,h ) );
+		}
+	}
+}
+
+
+//Receive datatable
+IMPLEMENT_CLIENTCLASS_DT( C_BreakableSurface, DT_BreakableSurface, CBreakableSurface )
+	RecvPropInt( RECVINFO( m_nNumWide ) ),
+	RecvPropInt( RECVINFO( m_nNumHigh ) ),
+	RecvPropFloat( RECVINFO( m_flPanelWidth) ),
+	RecvPropFloat( RECVINFO( m_flPanelHeight) ),
+	RecvPropVector( RECVINFO( m_vNormal ) ),
+	RecvPropVector( RECVINFO( m_vCorner ) ),
+	RecvPropInt( RECVINFO( m_bIsBroken )),
+	RecvPropInt( RECVINFO( m_nSurfaceType )),
+	RecvPropArray3( RECVINFO_ARRAY(m_RawPanelBitVec), RecvPropInt( RECVINFO( m_RawPanelBitVec[ 0 ] ))),
+
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Gets at the cracked version of the material
+//-----------------------------------------------------------------------------
+void C_BreakableSurface::FindCrackedMaterial()
+{
+	m_pCrackedMaterial = 0;
+
+	// First time we've seen it, get the material on the brush model
+	int materialCount = modelinfo->GetModelMaterialCount( const_cast<model_t*>(GetModel()) );
+	if( materialCount != 1 )
+	{
+		Warning( "Encountered func_breakablesurf that has a material applied to more than one surface!\n" );
+		m_pCrackedMaterial.Init( "debug/debugempty", TEXTURE_GROUP_OTHER );
+		return;
+	}
+
+	// Get at the first material; even if there are more than one.
+	IMaterial* pMaterial;
+	modelinfo->GetModelMaterials( const_cast<model_t*>(GetModel()), 1, &pMaterial );
+
+	// The material should point to a cracked version of itself
+	bool foundVar;
+	IMaterialVar* pCrackName = pMaterial->FindVar( "$crackmaterial", &foundVar, false );
+	if (foundVar)
+	{
+		m_pCrackedMaterial.Init( pCrackName->GetStringValue(), TEXTURE_GROUP_CLIENT_EFFECTS );
+	}
+	else
+	{
+		m_pCrackedMaterial.Init( pMaterial );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets at the base texture 
+//-----------------------------------------------------------------------------
+
+static ITexture* GetBaseTexture( IMaterial* pMaterial )
+{
+	bool foundVar;
+	IMaterialVar* pTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
+	if (!foundVar)
+		return 0;
+
+	return pTextureVar->GetTextureValue();
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::InitMaterial(WinEdge_t nEdgeType, int nEdgeStyle, char const* pMaterialName)
+{
+	m_pEdge[nEdgeType][nEdgeStyle].m_nRenderIndex  = m_RenderList.InvalidIndex();
+	m_pEdge[nEdgeType][nEdgeStyle].m_nStyle		   = nEdgeStyle;
+	m_pEdge[nEdgeType][nEdgeStyle].m_pMaterialEdge.Init(pMaterialName, TEXTURE_GROUP_CLIENT_EFFECTS);
+	m_pEdge[nEdgeType][nEdgeStyle].m_pMaterialEdgeTexture.Init( GetBaseTexture( m_pEdge[nEdgeType][nEdgeStyle].m_pMaterialEdge ) );
+}
+
+//-----------------------------------------------------------------------------
+// constructor, destructor
+//-----------------------------------------------------------------------------
+
+C_BreakableSurface::C_BreakableSurface()
+{
+	m_vNormal.Init();
+	m_vCorner.Init();
+	m_bIsBroken = false;
+
+	m_pCurrentDetailTexture = NULL;
+
+	Q_memset( m_PrevRawPanelBitVec, 0xff, sizeof( m_PrevRawPanelBitVec ) );
+}
+
+C_BreakableSurface::~C_BreakableSurface()
+{
+}
+
+void C_BreakableSurface::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		// Initialize panels
+		m_nNumWide = MAX_NUM_PANELS;
+		m_nNumHigh = MAX_NUM_PANELS;
+		for (int w=0;w<MAX_NUM_PANELS;w++)
+		{ 
+			for (int h=0;h<MAX_NUM_PANELS;h++)
+			{
+				SetPanelSolid(w,h,true);
+				SetPanelStale(w,h,false);
+
+				m_RawPanelBitVec.Set( w + h * MAX_NUM_PANELS, true );
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bnewentity - 
+//-----------------------------------------------------------------------------
+void C_BreakableSurface::OnDataChanged( DataUpdateType_t updateType )
+{
+	C_BaseEntity::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		// Get at the cracked material
+		FindCrackedMaterial();
+
+		// Use same solid box for all breakable surfaces
+		m_pMaterialBox.Init( "models/brokenglass/glassbroken_solid", TEXTURE_GROUP_MODEL );
+		m_pMaterialBoxTexture.Init( GetBaseTexture( m_pMaterialBox ) );
+
+		// NOTE: If you add or change this list of materials, change
+		// the precache list on func_breakablesurf.cpp on the server.
+
+		// Load the edge types and styles for the specific surface type
+		if (m_nSurfaceType == SHATTERSURFACE_TILE)
+		{
+			InitMaterial(EDGE_NONE,	0,"models/brokentile/tilebroken_03a");
+			InitMaterial(EDGE_FULL,	0,"models/brokentile/tilebroken_03b");
+			InitMaterial(EDGE_LEFT,	0,"models/brokentile/tilebroken_03c");
+			InitMaterial(EDGE_RIGHT,0,"models/brokentile/tilebroken_03d");
+
+			InitMaterial(EDGE_NONE,	1,"models/brokentile/tilebroken_02a");
+			InitMaterial(EDGE_FULL,	1,"models/brokentile/tilebroken_02b");
+			InitMaterial(EDGE_LEFT,	1,"models/brokentile/tilebroken_02c");
+			InitMaterial(EDGE_RIGHT,1,"models/brokentile/tilebroken_02d");
+
+			InitMaterial(EDGE_NONE,	2,"models/brokentile/tilebroken_01a");
+			InitMaterial(EDGE_FULL,	2,"models/brokentile/tilebroken_01b");
+			InitMaterial(EDGE_LEFT,	2,"models/brokentile/tilebroken_01c");
+			InitMaterial(EDGE_RIGHT,2,"models/brokentile/tilebroken_01d");
+		}
+		else 
+		{
+			InitMaterial(EDGE_NONE,	0,"models/brokenglass/glassbroken_03a");
+			InitMaterial(EDGE_FULL,	0,"models/brokenglass/glassbroken_03b");
+			InitMaterial(EDGE_LEFT,	0,"models/brokenglass/glassbroken_03c");
+			InitMaterial(EDGE_RIGHT,0,"models/brokenglass/glassbroken_03d");
+
+			InitMaterial(EDGE_NONE,	1,"models/brokenglass/glassbroken_02a");
+			InitMaterial(EDGE_FULL,	1,"models/brokenglass/glassbroken_02b");
+			InitMaterial(EDGE_LEFT,	1,"models/brokenglass/glassbroken_02c");
+			InitMaterial(EDGE_RIGHT,1,"models/brokenglass/glassbroken_02d");
+
+			InitMaterial(EDGE_NONE,	2,"models/brokenglass/glassbroken_01a");
+			InitMaterial(EDGE_FULL,	2,"models/brokenglass/glassbroken_01b");
+			InitMaterial(EDGE_LEFT,	2,"models/brokenglass/glassbroken_01c");
+			InitMaterial(EDGE_RIGHT,2,"models/brokenglass/glassbroken_01d");
+		}
+	}
+	
+	bool changed = false;
+
+	for ( int j = 0; j < m_nNumHigh; j++ )
+	{
+		for ( int i = 0; i < m_nNumWide; i++ )
+		{
+			int offset = i + j * m_nNumWide;
+
+			bool newVal = m_RawPanelBitVec[ offset ];
+			bool oldVal = m_PrevRawPanelBitVec[ offset ];
+
+			if ( newVal != oldVal )
+			{
+				changed = true;
+			}
+
+			SetPanelSolid(i,j,newVal);
+
+			if ( !newVal && changed )
+			{
+					
+				// Mark these panels and being stale (need edge type updated)
+				// We update them in one fell swoop rather than as each panel
+				// is updated, so we don't have to do duplicate operations
+				SetPanelStale(i,	j ,true);
+				SetPanelStale(i,   j+1,true);
+				SetPanelStale(i,   j-1,true);
+				SetPanelStale(i-1, j  ,true);
+				SetPanelStale(i+1, j  ,true);
+				SetPanelStale(i+1, j+1,true);
+				SetPanelStale(i-1, j+1,true);
+				SetPanelStale(i+1, j-1,true);
+				SetPanelStale(i-1, j-1,true);
+			}
+		}
+	}
+
+	if ( changed )
+	{
+		for (int width=0;width<m_nNumWide;width++)
+		{
+			for (int height=0;height<m_nNumHigh;height++)
+			{
+				if ( IsPanelStale(width,height) )
+				{
+					UpdateEdgeType( width, height );
+				}
+			}
+		}
+	}
+
+	Q_memcpy( m_PrevRawPanelBitVec, m_RawPanelBitVec.Base(), sizeof( m_PrevRawPanelBitVec ) );
+}
+
+bool C_BreakableSurface::IsTransparent( void )
+{
+	// Not an identity brush if it's broken
+	if (m_bIsBroken)
+		return true;
+
+	return C_BaseEntity::IsTransparent();
+}
+  
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+int C_BreakableSurface::DrawModel( int flags )
+{
+	if ( !m_bReadyToDraw )
+		return 0;
+
+	// If I'm not broken draw normally
+	if (m_bIsBroken)
+		render->InstallBrushSurfaceRenderer( this );
+
+	// If it's broken, always draw it translucent
+	BaseClass::DrawModel( m_bIsBroken ? flags | STUDIO_TRANSPARENCY : flags );
+
+	// Remove our nonstandard brush surface renderer...
+	render->InstallBrushSurfaceRenderer( 0 );
+
+	return 0;
+}
+
+bool C_BreakableSurface::RenderBrushModelSurface( IClientEntity* pBaseEntity, IBrushSurface* pBrushSurface )
+{
+	// If tile draw highlight for grout
+	if (m_nSurfaceType == SHATTERSURFACE_TILE)
+	{
+		DrawRenderListHighlights(pBrushSurface);
+	}
+	DrawSolidBlocks(pBrushSurface);
+	DrawRenderList(pBrushSurface);
+
+	// Don't draw decals
+	return false;
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::DrawRenderList(IBrushSurface* pBrushSurface)
+{
+	// Get width and height steps
+	QAngle vAngles;
+	VectorAngles(-1*m_vNormal,vAngles);
+	Vector vWidthStep,vHeightStep;
+	AngleVectors(vAngles,NULL,&vWidthStep,&vHeightStep);
+	vWidthStep	*= m_flPanelWidth;
+	vHeightStep *= m_flPanelHeight;
+
+	CMeshBuilder	pMeshBuilder;
+	IMesh*			pMesh			= NULL;
+	int				nCurStyle		= -1;
+	int				nCurEdgeType	= -1;
+	CMatRenderContextPtr pRenderContext( materials );
+	for( unsigned short i = m_RenderList.Head(); i != m_RenderList.InvalidIndex(); i = m_RenderList.Next(i) )
+	{
+	
+		if (nCurStyle		!= m_RenderList[i].m_nStyle		||
+			nCurEdgeType	!= m_RenderList[i].m_nEdgeType	)
+		{
+			nCurStyle	 = m_RenderList[i].m_nStyle;
+			nCurEdgeType = m_RenderList[i].m_nEdgeType;
+
+			m_pCurrentDetailTexture = m_pEdge[nCurEdgeType][nCurStyle].m_pMaterialEdgeTexture;
+			pRenderContext->Flush(false);
+			pRenderContext->Bind(m_pCrackedMaterial, (IClientRenderable*)this);
+			pMesh = pRenderContext->GetDynamicMesh( );
+		}
+
+		Vector vRenderPos = m_vCorner + 
+							(m_RenderList[i].m_nWidth*vWidthStep)	+ 
+							(m_RenderList[i].m_nHeight*vHeightStep);
+
+		DrawOneEdge(pBrushSurface, pMesh,&pMeshBuilder,vRenderPos,vWidthStep,vHeightStep,(WinSide_t)m_RenderList[i].m_nSide);
+	}
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::DrawRenderListHighlights(IBrushSurface* pBrushSurface)
+{
+	// Get width and height steps
+	QAngle vAngles;
+	VectorAngles(-1*m_vNormal,vAngles);
+	Vector vWidthStep,vHeightStep;
+	AngleVectors(vAngles,NULL,&vWidthStep,&vHeightStep);
+	vWidthStep	*= m_flPanelWidth;
+	vHeightStep *= m_flPanelHeight;
+
+
+	CMeshBuilder	pMeshBuilder;
+	IMesh*			pMesh			= NULL;
+	int				nCurStyle		= -1;
+	int				nCurEdgeType	= -1;
+	CMatRenderContextPtr pRenderContext( materials );
+	for( unsigned short i = m_RenderList.Head(); i != m_RenderList.InvalidIndex(); i = m_RenderList.Next(i) )
+	{
+	
+		if (nCurStyle		!= m_RenderList[i].m_nStyle		||
+			nCurEdgeType	!= m_RenderList[i].m_nEdgeType	)
+		{
+			nCurStyle	 = m_RenderList[i].m_nStyle;
+			nCurEdgeType = m_RenderList[i].m_nEdgeType;
+			
+			IMaterial *pMat = m_pEdge[nCurEdgeType][nCurStyle].m_pMaterialEdge;
+			pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMat );
+		}
+
+		Vector vRenderPos = m_vCorner + 
+							(m_RenderList[i].m_nWidth*vWidthStep)	+ 
+							(m_RenderList[i].m_nHeight*vHeightStep) +
+							(0.30*m_vNormal);
+
+		DrawOneHighlight(pBrushSurface, pMesh,&pMeshBuilder,vRenderPos,vWidthStep,vHeightStep,(WinSide_t)m_RenderList[i].m_nSide);
+	}
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+bool C_BreakableSurface::HavePanel(int nWidth, int nHeight)
+{
+	// If I'm off the edge, always give support
+	if (!InLegalRange(nWidth,nHeight))
+	{
+		return true;
+	}
+	return (IsPanelSolid(nWidth,nHeight));
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::UpdateEdgeType(int nWidth, int nHeight, int forceStyle /*=-1*/ )
+{
+	Assert( forceStyle < NUM_EDGE_STYLES );
+
+	// -----------------------------------
+	//  Check edge conditions
+	// -----------------------------------
+	if (!InLegalRange(nWidth,nHeight))
+	{
+		return;
+	}
+
+	// ----------------------------------
+	//  If solid has no edges
+	// ----------------------------------
+	if (IsPanelSolid(nWidth,nHeight))
+	{
+		return;
+	}
+	
+	// Panel is no longer stale
+	SetPanelStale(nWidth, nHeight,false);
+
+	// ----------------------------------
+	//  Set edge type base on neighbors
+	// ----------------------------------
+	bool bUp		= HavePanel(nWidth,   nHeight+1);
+	bool bDown		= HavePanel(nWidth,   nHeight-1);
+	bool bLeft		= HavePanel(nWidth-1, nHeight  );
+	bool bRight		= HavePanel(nWidth+1, nHeight  );
+
+	bool bUpLeft	= HavePanel(nWidth-1,  nHeight+1);
+	bool bUpRight	= HavePanel(nWidth+1,  nHeight+1);
+	bool bDownLeft	= HavePanel(nWidth-1,  nHeight-1);
+	bool bDownRight	= HavePanel(nWidth+1,  nHeight-1);
+
+	//-------------
+	// Top
+	//-------------
+	if (bUp)
+	{
+		bool bLeftEdge		= !bLeft  && bUpLeft;
+		bool bRightEdge		= !bRight && bUpRight;
+
+		if (bLeftEdge && bRightEdge)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_TOP, EDGE_FULL, forceStyle );
+		}
+		else if (bLeftEdge)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_TOP, EDGE_LEFT, forceStyle );
+		}
+		else if (bRightEdge)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_TOP, EDGE_RIGHT, forceStyle );
+		}
+		else
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_TOP, EDGE_NONE, forceStyle );
+		}
+	}
+	else
+	{
+		AddToRenderList(nWidth, nHeight, WIN_SIDE_TOP, EDGE_NOT, forceStyle );
+	}
+	//-------------
+	// Bottom
+	//-------------
+	if (bDown)
+	{
+		bool bLeftEdge		= !bLeft  && bDownLeft;
+		bool bRightEdge		= !bRight && bDownRight;
+
+		if (bLeftEdge && bRightEdge)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_BOTTOM, EDGE_FULL, forceStyle );
+		}
+		else if (bLeftEdge)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_BOTTOM, EDGE_RIGHT, forceStyle );
+		}
+		else if (bRightEdge)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_BOTTOM, EDGE_LEFT, forceStyle );
+		}
+		else
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_BOTTOM, EDGE_NONE, forceStyle );
+		}
+	}
+	else
+	{
+		AddToRenderList(nWidth, nHeight, WIN_SIDE_BOTTOM, EDGE_NOT, forceStyle );
+	}
+	//-------------
+	// Left
+	//-------------
+	if (bLeft)
+	{
+		bool bTop		= !bUp 	 && bUpLeft;
+		bool bBottom	= !bDown && bDownLeft;
+
+		if (bTop && bBottom)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_LEFT, EDGE_FULL, forceStyle );
+		}
+		else if (bTop)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_LEFT, EDGE_RIGHT, forceStyle );
+		}
+		else if (bBottom)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_LEFT, EDGE_LEFT, forceStyle );
+		}
+		else
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_LEFT, EDGE_NONE, forceStyle );
+		}
+	}
+	else
+	{
+		AddToRenderList(nWidth, nHeight, WIN_SIDE_LEFT, EDGE_NOT, forceStyle );
+	}
+	//-------------
+	// Right
+	//-------------
+	if (bRight)
+	{
+		bool bTop		= !bUp 	 && bUpRight;
+		bool bBottom	= !bDown && bDownRight;
+
+		if (bTop && bBottom)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_RIGHT, EDGE_FULL, forceStyle );
+		}
+		else if (bTop)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_RIGHT, EDGE_LEFT, forceStyle );
+		}
+		else if (bBottom)
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_RIGHT, EDGE_RIGHT, forceStyle );
+		}
+		else
+		{
+			AddToRenderList(nWidth, nHeight, WIN_SIDE_RIGHT, EDGE_NONE, forceStyle );
+		}
+	}
+	else
+	{
+		AddToRenderList(nWidth, nHeight, WIN_SIDE_RIGHT, EDGE_NOT, forceStyle );
+	}
+}
+
+//--------------------------------------------------------------------------------
+// Purpose : Return index to panel in render list that meets these qualifications
+// Input   :
+// Output  :
+//--------------------------------------------------------------------------------
+int C_BreakableSurface::FindRenderPanel(int nWidth, int nHeight, WinSide_t nWinSide)
+{
+	for( unsigned short i = m_RenderList.Head(); i != m_RenderList.InvalidIndex(); i = m_RenderList.Next(i) )
+	{
+		if (m_RenderList[i].m_nSide			== nWinSide	&&
+			m_RenderList[i].m_nWidth		== nWidth		&&
+			m_RenderList[i].m_nHeight		== nHeight)
+		{
+			return i;
+		}
+	}
+	return m_RenderList.InvalidIndex();
+}
+
+//----------------------------------------------------------------------------------
+// Purpose : Returns first element in render list with the same edge type and style
+// Input   :
+// Output  :
+//----------------------------------------------------------------------------------
+int C_BreakableSurface::FindFirstRenderTexture(WinEdge_t nEdgeType, int nStyle)
+{
+	for( unsigned short i = m_RenderList.Head(); i != m_RenderList.InvalidIndex(); i = m_RenderList.Next(i) )
+	{
+		if (m_RenderList[i].m_nStyle		== nStyle		&&
+			m_RenderList[i].m_nEdgeType		== nEdgeType	)
+		{
+			return i;
+		}
+	}
+	return m_RenderList.InvalidIndex();
+}
+
+//------------------------------------------------------------------------------
+// Purpose : Add a edge to be rendered to the render list
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::AddToRenderList(int nWidth, int nHeight, WinSide_t nSide, WinEdge_t nEdgeType, int forceStyle )
+{
+	// -----------------------------------------------------
+	// Try to find old panel
+	int nOldPanelIndex = FindRenderPanel(nWidth,nHeight,nSide);
+
+	// -----------------------------------------------------
+	// If I have an old panel, get it's style and remove it
+	// otherwise randomly chose a style
+	int nStyle;
+	if (m_RenderList.IsValidIndex(nOldPanelIndex) )
+	{
+		nStyle = m_RenderList[nOldPanelIndex].m_nStyle;
+		m_RenderList.Remove(nOldPanelIndex);
+	}
+	else
+	{
+		nStyle = random->RandomInt(0,NUM_EDGE_STYLES-1);
+	}
+		
+	if ( forceStyle != -1 )
+	{
+		nStyle = forceStyle;
+	}
+
+	// -----------------------------------------------------
+	// If my new panel has an edge, add it to render list
+	if (nEdgeType != EDGE_NOT)
+	{
+		// Renderlist is sorted by texture type.  Find first element
+		// that shares the same texture as the new panel
+		unsigned short nTexIndex = FindFirstRenderTexture(nEdgeType, nStyle);
+
+		// If texture was already in list, add after last use
+		unsigned short nNewIndex;
+		if (m_RenderList.IsValidIndex(nTexIndex))
+		{
+			nNewIndex = m_RenderList.InsertAfter(nTexIndex);
+		}
+		// Otherwise add to send of render list
+		else
+		{
+			nNewIndex = m_RenderList.AddToTail();
+		}
+
+		// Now fill out my data
+		m_RenderList[nNewIndex].m_nHeight	= nHeight;
+		m_RenderList[nNewIndex].m_nWidth	= nWidth;
+		m_RenderList[nNewIndex].m_nEdgeType	= nEdgeType;
+		m_RenderList[nNewIndex].m_nSide		= nSide;
+		m_RenderList[nNewIndex].m_nStyle	= nStyle;
+
+		Assert( nStyle < NUM_EDGE_STYLES );
+		SetStyleType( nWidth, nHeight, nStyle );
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::DrawSolidBlocks(IBrushSurface* pBrushSurface)
+{
+	CMatRenderContextPtr pRenderContext( materials );
+
+	m_pCurrentDetailTexture = m_pMaterialBoxTexture;
+
+	// Gotta flush (in a non-stalling way) because we effectively 
+	// have a new material due to the new base texture
+	pRenderContext->Flush(false);
+	pRenderContext->Bind(m_pCrackedMaterial, (IClientRenderable*)this);
+	IMesh* pMesh = pRenderContext->GetDynamicMesh( );
+	CMeshBuilder pMeshBuilder;
+
+	// ---------------
+	// Create panels
+	// ---------------
+	QAngle vAngles;
+	VectorAngles(-1*m_vNormal,vAngles);
+	Vector vWidthStep,vHeightStep;
+	AngleVectors(vAngles,NULL,&vWidthStep,&vHeightStep);
+	vWidthStep	*= m_flPanelWidth;
+	vHeightStep *= m_flPanelHeight;
+
+	Vector vCurPos = m_vCorner;
+	for (int width=0;width<m_nNumWide;width++)
+	{
+		int height;
+		int nHCount = 0;
+		for (height=0;height<m_nNumHigh;height++)
+		{
+			// Keep count of how many panes there are in a row
+			if (IsPanelSolid(width,height))
+			{
+				nHCount++;
+			}
+
+			// Drow the strip and start counting again
+			else if (nHCount > 0)
+			{
+				vCurPos = m_vCorner + vWidthStep*width + vHeightStep*(height-nHCount);
+				DrawOneBlock(pBrushSurface, pMesh, &pMeshBuilder, vCurPos,vWidthStep,vHeightStep*nHCount);
+				nHCount = 0;
+			}
+		}
+		if (nHCount)
+		{
+			vCurPos = m_vCorner + vWidthStep*width + vHeightStep*(height-nHCount);
+			DrawOneBlock(pBrushSurface, pMesh, &pMeshBuilder, vCurPos,vWidthStep,vHeightStep*nHCount);
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::DrawOneBlock(IBrushSurface* pBrushSurface, IMesh* pMesh, 
+	CMeshBuilder *pMeshBuilder,  const Vector &vCurPos, const Vector &vWidthStep, 
+	const Vector &vHeightStep)
+{
+	pMeshBuilder->Begin( pMesh, MATERIAL_QUADS, 1 );
+
+	Vector2D texCoord, lightCoord;
+	pBrushSurface->ComputeTextureCoordinate( vCurPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vCurPos, lightCoord );
+
+	pMeshBuilder->Position3f( vCurPos.x, vCurPos.y, vCurPos.z );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2f( 0, 0, 1 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+ 	pMeshBuilder->AdvanceVertex();
+
+	Vector vNextPos = vCurPos + vWidthStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x, vNextPos.y, vNextPos.z );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2f( 0, 0, 0 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+ 	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->AdvanceVertex();
+
+	vNextPos = vNextPos + vHeightStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x , vNextPos.y, vNextPos.z );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2f( 0, 1, 0 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+ 	pMeshBuilder->AdvanceVertex();
+
+	vNextPos = vNextPos - vWidthStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x, vNextPos.y , vNextPos.z);
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2f( 0, 1, 1 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+ 	pMeshBuilder->AdvanceVertex();
+
+	pMeshBuilder->End();
+	pMesh->Draw();
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::DrawOneEdge( IBrushSurface* pBrushSurface, IMesh* pMesh, 
+	CMeshBuilder *pMeshBuilder,  const Vector &vStartPos,  const Vector &vWStep, 
+	const Vector &vHStep, WinSide_t nEdge )
+{
+	pMeshBuilder->Begin( pMesh, MATERIAL_QUADS, 1 );
+
+	Vector2D texCoord, lightCoord;
+	pBrushSurface->ComputeTextureCoordinate( vStartPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vStartPos, lightCoord );
+
+	pMeshBuilder->Position3f( vStartPos.x, vStartPos.y, vStartPos.z);
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+	
+	Vector vNextPos = vStartPos + vWStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x , vNextPos.y , vNextPos.z);
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+
+	vNextPos = vNextPos + vHStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x, vNextPos.y, vNextPos.z );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+
+	vNextPos = vNextPos - vWStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x, vNextPos.y, vNextPos.z );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4ub( 255, 255, 255, 255 );
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	pMeshBuilder->TexCoord2fv( 2, texCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+
+	pMeshBuilder->End();
+	pMesh->Draw();
+}
+
+
+
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void C_BreakableSurface::DrawOneHighlight( IBrushSurface* pBrushSurface, IMesh* pMesh, 
+	CMeshBuilder *pMeshBuilder,  const Vector &vStartPos,  const Vector &vWStep, 
+	const Vector &vHStep, WinSide_t nEdge )
+{
+	Vector vColor = Vector(0.41,0.35,0.24);
+
+	pMeshBuilder->Begin( pMesh, MATERIAL_QUADS, 1 );
+
+	Vector2D texCoord, lightCoord;
+	pBrushSurface->ComputeTextureCoordinate( vStartPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vStartPos, lightCoord );
+
+	pMeshBuilder->Position3f( vStartPos.x, vStartPos.y, vStartPos.z);
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4f( vColor[0], vColor[1], vColor[2], 1.0);
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+	
+	Vector vNextPos = vStartPos + vWStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x , vNextPos.y , vNextPos.z);
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4f( vColor[0], vColor[1], vColor[2], 1.0);
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+
+	vNextPos = vNextPos + vHStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x, vNextPos.y, vNextPos.z );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4f( vColor[0], vColor[1], vColor[2], 1.0);
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+
+	vNextPos = vNextPos - vWStep;
+
+	pBrushSurface->ComputeTextureCoordinate( vNextPos, texCoord );
+	pBrushSurface->ComputeLightmapCoordinate( vNextPos, lightCoord );
+
+	pMeshBuilder->Position3f( vNextPos.x, vNextPos.y, vNextPos.z );
+	pMeshBuilder->Normal3fv( m_vNormal.Base() );
+	pMeshBuilder->Color4f( vColor[0], vColor[1], vColor[2], 1.0);
+	pMeshBuilder->TexCoord2fv( 1, lightCoord.Base() );
+	switch (nEdge)
+	{
+		case WIN_SIDE_RIGHT:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 0.0f );
+			break;
+		case WIN_SIDE_BOTTOM:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 0.0f );
+			break;
+		case WIN_SIDE_LEFT:
+			pMeshBuilder->TexCoord2f( 0, 1.0f, 1.0f );
+			break;
+		case WIN_SIDE_TOP:
+			pMeshBuilder->TexCoord2f( 0, 0.0f, 1.0f );
+			break;
+	}
+ 	pMeshBuilder->AdvanceVertex();
+
+	pMeshBuilder->End();
+	pMesh->Draw();
+}
+
+bool C_BreakableSurface::ShouldReceiveProjectedTextures( int flags )
+{
+	return false;
+}
+
+
+//------------------------------------------------------------------------------
+// A material proxy that resets the texture to use the original surface texture
+//------------------------------------------------------------------------------
+class CBreakableSurfaceProxy : public CEntityMaterialProxy
+{
+public:
+	CBreakableSurfaceProxy();
+	virtual ~CBreakableSurfaceProxy();
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( C_BaseEntity *pC_BaseEntity );
+	virtual IMaterial *GetMaterial();
+
+private:
+	// get at the material whose texture we're going to steal
+	void AcquireSourceMaterial( C_BaseEntity* pEnt );
+
+	IMaterialVar* m_BaseTextureVar;
+};
+
+CBreakableSurfaceProxy::CBreakableSurfaceProxy()
+{
+	m_BaseTextureVar = NULL;
+}
+
+CBreakableSurfaceProxy::~CBreakableSurfaceProxy()
+{
+}
+
+
+bool CBreakableSurfaceProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	bool foundVar;
+	m_BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
+	return foundVar;
+}
+
+void CBreakableSurfaceProxy::OnBind( C_BaseEntity *pC_BaseEntity )
+{
+	C_BreakableSurface *pEnt = dynamic_cast< C_BreakableSurface * >(pC_BaseEntity);
+	if( !pEnt )
+	{
+		return;
+	}
+
+	// Use the current base texture specified by the suface
+	m_BaseTextureVar->SetTextureValue( pEnt->m_pCurrentDetailTexture );
+}
+
+IMaterial *CBreakableSurfaceProxy::GetMaterial()
+{
+	if ( !m_BaseTextureVar )
+		return NULL;
+
+	return m_BaseTextureVar->GetOwningMaterial();
+}
+
+EXPOSE_INTERFACE( CBreakableSurfaceProxy, IMaterialProxy, "BreakableSurface" IMATERIAL_PROXY_INTERFACE_VERSION );