1HEADmaster

1 files changed, 737 insertions, 0 deletions

diff --git a/utils/vbsp/textures.cpp b/utils/vbsp/textures.cpp
new file mode 100644
index 0000000..4f49c5d
--- /dev/null
+++ b/utils/vbsp/textures.cpp
@@ -0,0 +1,737 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "vbsp.h"
+#include "utilmatlib.h"
+#include "physdll.h"
+#include <assert.h>
+#include <malloc.h>
+#include "tier1/strtools.h"
+#include "materialpatch.h"
+#include "KeyValues.h"
+
+void LoadSurfaceProperties( void );
+
+IPhysicsSurfaceProps *physprops = NULL;
+
+int		nummiptex;
+textureref_t	textureref[MAX_MAP_TEXTURES];
+
+bool g_bHasWater = false;
+
+extern qboolean onlyents;
+
+dtexdata_t *GetTexData( int index )
+{
+	if ( index < 0 )
+		return NULL;
+	Assert( !onlyents );
+	return &dtexdata[ index ];
+}
+
+static qboolean StringIsTrue( const char *str )
+{
+	if( Q_strcasecmp( str, "true" ) == 0 )
+	{
+		return true;
+	}
+	if( Q_strcasecmp( str, "1" ) == 0 )
+	{
+		return true;
+	}
+	return false;
+}
+
+int	FindMiptex (const char *name)
+{
+	int		i;
+	MaterialSystemMaterial_t matID;
+	const char *propVal, *propVal2;
+	int opacity;
+	bool found;
+		
+	for (i=0 ; i<nummiptex ; i++)
+	{
+		if (!strcmp (name, textureref[i].name))
+		{
+			return i;
+		}
+	}
+	if (nummiptex == MAX_MAP_TEXTURES)
+		Error ("Too many unique textures, max %d", MAX_MAP_TEXTURES);
+	strcpy (textureref[i].name, name);
+
+	textureref[i].lightmapWorldUnitsPerLuxel = 0.0f;
+	textureref[i].flags = 0;
+	textureref[i].contents = 0;
+
+	matID = FindOriginalMaterial( name, &found );
+	if( matID == MATERIAL_NOT_FOUND )
+	{
+		return 0;
+	}
+
+	if (!found)
+		Warning("Material not found!: %s\n", name );
+
+	// HANDLE ALL OF THE STUFF THAT ISN'T RENDERED WITH THE MATERIAL THAT IS ONE IT.
+	
+	// handle sky
+	if( ( propVal = GetMaterialVar( matID, "%compileSky" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].flags |= SURF_SKY | SURF_NOLIGHT;
+	}
+	else if( ( propVal = GetMaterialVar( matID, "%compile2DSky" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].flags |= SURF_SKY | SURF_SKY2D | SURF_NOLIGHT;
+	}
+	// handle hint brushes
+	else if ( ( propVal = GetMaterialVar( matID, "%compileHint" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT | SURF_HINT;
+	}
+	// handle skip faces
+	else if ( ( propVal = GetMaterialVar( matID, "%compileSkip" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT | SURF_SKIP;
+	}
+	// handle origin brushes
+	else if ( ( propVal = GetMaterialVar( matID, "%compileOrigin" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].contents |= CONTENTS_ORIGIN | CONTENTS_DETAIL;
+		textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT;
+	}
+	// handle clip brushes
+	else if ( ( propVal = GetMaterialVar( matID, "%compileClip" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].contents |= CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP;
+		textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT;
+	}
+	else if ( ( propVal = GetMaterialVar( matID, "%playerClip" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].contents |= CONTENTS_PLAYERCLIP;
+		textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT;
+	}
+	// handle npc clip brushes
+	else if ( ( propVal = GetMaterialVar( matID, "%compileNpcClip" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].contents |= CONTENTS_MONSTERCLIP;
+		textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT;
+	}
+	// handle surface lights which are meant to 
+	else if ( ( propVal = GetMaterialVar( matID, "%compileNoChop" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].flags |= SURF_NOCHOP;
+	}
+	// handle triggers
+	else if ( ( propVal = GetMaterialVar( matID, "%compileTrigger" ) ) &&
+		StringIsTrue( propVal ) )
+	{
+		textureref[i].flags |= ( SURF_NOLIGHT | SURF_TRIGGER );
+		if ( g_NodrawTriggers )
+		{
+			textureref[i].flags |= SURF_NODRAW;
+		}
+	}
+	// handle nolight surfs (except water)
+	else if ( (( propVal = GetMaterialVar( matID, "%compileNoLight" ) ) && StringIsTrue( propVal )) && 
+		!(( propVal2 = GetMaterialVar( matID, "%compileWater" ) ) && StringIsTrue( propVal2 ) ) )
+	{
+		textureref[i].flags |= SURF_NOLIGHT;
+	}
+	else
+	{
+		// HANDLE ALL OF THE STUFF THAT IS RENDERED WITH THE MATERIAL THAT IS ON IT.
+
+		// Handle ladders.
+		if ( ( propVal = GetMaterialVar( matID, "%compileLadder" ) ) &&	StringIsTrue( propVal ) )
+		{
+			textureref[i].contents |= CONTENTS_LADDER;
+		}
+
+		// handle wet materials
+		if ( ( propVal = GetMaterialVar( matID, "%noPortal" ) ) &&
+			StringIsTrue( propVal ) )
+		{
+			textureref[i].flags |= SURF_NOPORTAL;
+		}
+
+		if ( ( propVal = GetMaterialVar( matID, "%compilePassBullets" ) ) && StringIsTrue( propVal ) )
+		{
+			// change contents to grate, so bullets pass through
+			// NOTE: This has effects on visibility too!
+			textureref[i].contents &= ~CONTENTS_SOLID;
+			textureref[i].contents |= CONTENTS_GRATE;
+		}
+
+		if( g_BumpAll || GetMaterialShaderPropertyBool( matID, UTILMATLIB_NEEDS_BUMPED_LIGHTMAPS ) )
+		{
+			textureref[i].flags |= SURF_BUMPLIGHT;
+		}
+		
+		if( GetMaterialShaderPropertyBool( matID, UTILMATLIB_NEEDS_LIGHTMAP ) )
+		{
+			textureref[i].flags &= ~SURF_NOLIGHT;
+		}
+		else if( !g_bLightIfMissing )
+		{
+			textureref[i].flags |= SURF_NOLIGHT;
+		}
+		// handle nodraw faces/brushes
+		if ( ( propVal = GetMaterialVar( matID, "%compileNoDraw" ) ) && StringIsTrue( propVal ) )
+		{								    
+			//		textureref[i].contents |= CONTENTS_DETAIL;
+			textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT;
+		}
+
+		// Just a combination of nodraw + pass bullets, makes things easier
+		if ( ( propVal = GetMaterialVar( matID, "%compileInvisible" ) ) && StringIsTrue( propVal ) )
+		{								    
+			// change contents to grate, so bullets pass through
+			// NOTE: This has effects on visibility too!
+			textureref[i].contents &= ~CONTENTS_SOLID;
+			textureref[i].contents |= CONTENTS_GRATE;
+			textureref[i].flags |= SURF_NODRAW | SURF_NOLIGHT;
+		}
+
+		bool checkWindow = true;
+		// handle non solid
+		if ( ( propVal = GetMaterialVar( matID, "%compileNonsolid" ) ) && StringIsTrue( propVal ) )
+		{
+			textureref[i].contents = CONTENTS_OPAQUE;
+			// Non-Solid can't be a window either!
+			checkWindow = false;
+		}
+		// handle block LOS
+		if ( ( propVal = GetMaterialVar( matID, "%compileBlockLOS" ) ) && StringIsTrue( propVal ) )
+		{
+			textureref[i].contents = CONTENTS_BLOCKLOS;
+
+			// BlockLOS can't be a window either!
+			checkWindow = false;
+		}
+
+		if ( ( propVal = GetMaterialVar( matID, "%compileDetail" ) ) &&
+			StringIsTrue( propVal ) )
+		{
+			textureref[i].contents |= CONTENTS_DETAIL;
+		}
+
+		bool bKeepLighting = ( ( propVal = GetMaterialVar( matID, "%compileKeepLight" ) ) &&
+			StringIsTrue( propVal ) );
+
+		// handle materials that want to be treated as water.
+		if ( ( propVal = GetMaterialVar( matID, "%compileWater" ) ) &&
+			StringIsTrue( propVal ) )
+		{
+			textureref[i].contents &= ~(CONTENTS_SOLID|CONTENTS_DETAIL);
+			textureref[i].contents |= CONTENTS_WATER;
+			textureref[i].flags |= SURF_WARP | SURF_NOSHADOWS | SURF_NODECALS;
+
+			if ( g_DisableWaterLighting && !bKeepLighting )
+			{
+				textureref[i].flags |= SURF_NOLIGHT;
+			}
+
+			// Set this so that we can check at the end of the process the presence of a a WaterLODControl entity.
+			g_bHasWater = true;
+		}
+		const char *pShaderName = GetMaterialShaderName(matID);
+		if ( !bKeepLighting && !Q_strncasecmp( pShaderName, "water", 5 ) || !Q_strncasecmp( pShaderName, "UnlitGeneric", 12 ) )
+		{
+			//if ( !(textureref[i].flags & SURF_NOLIGHT) )
+			//	Warning("Forcing lit materal %s to nolight\n", name );
+			textureref[i].flags |= SURF_NOLIGHT;
+		}
+
+		if ( ( propVal = GetMaterialVar( matID, "%compileSlime" ) ) &&
+			StringIsTrue( propVal ) )
+		{
+			textureref[i].contents &= ~(CONTENTS_SOLID|CONTENTS_DETAIL);
+			textureref[i].contents |= CONTENTS_SLIME;
+			textureref[i].flags |= SURF_NODECALS;
+			// Set this so that we can check at the end of the process the presence of a a WaterLODControl entity.
+			g_bHasWater = true;
+		}
+	
+		opacity = GetMaterialShaderPropertyInt( matID, UTILMATLIB_OPACITY );
+		
+		if ( checkWindow && opacity != UTILMATLIB_OPAQUE )
+		{
+			// transparent *and solid* brushes that aren't grates or water must be windows
+			if ( !(textureref[i].contents & (CONTENTS_GRATE|CONTENTS_WATER)) )
+			{
+				textureref[i].contents |= CONTENTS_WINDOW;
+			}
+
+			textureref[i].contents &= ~CONTENTS_SOLID;
+			
+			// this affects engine primitive sorting, SURF_TRANS means sort as a translucent primitive
+			if ( opacity == UTILMATLIB_TRANSLUCENT )
+			{
+				textureref[i].flags |= SURF_TRANS;
+			}
+			
+		}
+		if ( textureref[i].flags & SURF_NOLIGHT )
+		{
+			textureref[i].flags &= ~SURF_BUMPLIGHT;
+		}
+	}
+
+	nummiptex++;
+
+	return i;
+}
+
+/*
+==================
+textureAxisFromPlane
+==================
+*/
+Vector	baseaxis[18] =
+{
+	Vector(0,0,1), Vector(1,0,0), Vector(0,-1,0),			// floor
+	Vector(0,0,-1), Vector(1,0,0), Vector(0,-1,0),		// ceiling
+	Vector(1,0,0), Vector(0,1,0), Vector(0,0,-1),			// west wall
+	Vector(-1,0,0), Vector(0,1,0), Vector(0,0,-1),		// east wall
+	Vector(0,1,0), Vector(1,0,0), Vector(0,0,-1),			// south wall
+	Vector(0,-1,0), Vector(1,0,0), Vector(0,0,-1)			// north wall
+};
+
+void TextureAxisFromPlane(plane_t *pln, Vector& xv, Vector& yv)
+{
+	int		bestaxis;
+	vec_t	dot,best;
+	int		i;
+	
+	best = 0;
+	bestaxis = 0;
+	
+	for (i=0 ; i<6 ; i++)
+	{
+		dot = DotProduct (pln->normal, baseaxis[i*3]);
+		if (dot > best)
+		{
+			best = dot;
+			bestaxis = i;
+		}
+	}
+	
+	VectorCopy (baseaxis[bestaxis*3+1], xv);
+	VectorCopy (baseaxis[bestaxis*3+2], yv);
+}
+
+
+
+int g_SurfaceProperties[MAX_MAP_TEXDATA];
+
+
+int GetSurfaceProperties( MaterialSystemMaterial_t matID, const char *pMatName )
+{
+	const char *pPropString = NULL;
+	int surfaceIndex = -1;
+
+	if ( physprops )
+	{
+		pPropString = GetMaterialVar( matID, "$surfaceprop" );
+		if ( pPropString )
+		{
+			surfaceIndex = physprops->GetSurfaceIndex( pPropString );
+			if ( surfaceIndex < 0 )
+			{
+				Msg("Can't find surfaceprop %s for material %s, using default\n", pPropString, pMatName );
+				surfaceIndex = physprops->GetSurfaceIndex( pPropString );
+				surfaceIndex = physprops->GetSurfaceIndex( "default" );
+			}
+		}
+	}
+
+	return surfaceIndex;
+}
+
+int GetSurfaceProperties2( MaterialSystemMaterial_t matID, const char *pMatName )
+{
+	const char *pPropString = NULL;
+	int surfaceIndex = -1;
+
+	if ( physprops )
+	{
+		pPropString = GetMaterialVar( matID, "$surfaceprop2" );
+		if ( pPropString )
+		{
+			surfaceIndex = physprops->GetSurfaceIndex( pPropString );
+			if ( surfaceIndex < 0 )
+			{
+				Msg("Can't find surfacepropblend %s for material %s, using default\n", pPropString, pMatName );
+				surfaceIndex = physprops->GetSurfaceIndex( "default" );
+			}
+		}
+		else
+		{
+			// No surface property 2.
+			return -1;
+		}
+	}
+
+	return surfaceIndex;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds or adds a texdata for the specified name ( same as below except
+//   instead of finding the named texture, copies the settings from the passed
+//  in sourceTexture. )
+// Used for creation of one off .vmt files for water surface textures
+// Input  : *pName - texture name
+// Output : int index into dtexdata array
+//-----------------------------------------------------------------------------
+int FindAliasedTexData( const char *pName_, dtexdata_t *sourceTexture )
+{
+	char *pName = ( char * )_alloca( strlen( pName_ ) + 1 );
+	strcpy( pName, pName_ );
+	strlwr( pName );
+	int i, output;
+	bool found;
+	dtexdata_t *pTexData;
+	MaterialSystemMaterial_t matID;
+
+	for ( i = 0; i < numtexdata; i++ )
+	{
+		if ( !strcmp( pName, TexDataStringTable_GetString( GetTexData( i )->nameStringTableID ) ) )
+			return i;
+	}
+
+
+	output = numtexdata;
+	if ( numtexdata >= MAX_MAP_TEXDATA )
+	{
+		Error( "Too many unique texture mappings, max = %d\n", MAX_MAP_TEXDATA );
+	}
+	pTexData = GetTexData( output );
+	numtexdata++;
+
+	// Save the name of the material.
+	pTexData->nameStringTableID = TexDataStringTable_AddOrFindString( pName );
+
+	// Get the width, height, view_width, view_height, and reflectivity from the material system.
+	matID = FindOriginalMaterial( TexDataStringTable_GetString( sourceTexture->nameStringTableID ), &found, false );
+	if( matID == MATERIAL_NOT_FOUND || (!found) )
+	{
+		qprintf( "WARNING: material not found: \"%s\"\n", pName );
+		return -1;
+	}
+
+	GetMaterialDimensions( matID, &pTexData->width, &pTexData->height );
+	pTexData->view_width = pTexData->width;  // undone: what is this?
+	pTexData->view_height = pTexData->height;  // undone: what is this?
+	
+	GetMaterialReflectivity( matID, pTexData->reflectivity.Base() );
+	g_SurfaceProperties[output] = GetSurfaceProperties( matID, pName );
+
+	return output;
+}
+
+
+//-----------------------------------------------------------------------------
+// Finds a texdata for the specified name, returns -1 if not found
+//-----------------------------------------------------------------------------
+int FindTexData( const char *pName )
+{
+	// Make sure the texdata doesn't already exist.
+	for( int i = 0; i < numtexdata; i++ )
+	{
+		char const *pTexDataName = TexDataStringTable_GetString( GetTexData( i )->nameStringTableID );
+		if ( !Q_stricmp( pTexDataName, pName ) )
+			return i;
+	}
+	return -1;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds or adds a texdata for the specified name
+// Input  : *pName - texture name
+// Output : int index into dtexdata array
+//-----------------------------------------------------------------------------
+int FindOrCreateTexData( const char *pName_ )
+{
+	char *pName = ( char * )_alloca( strlen( pName_ ) + 1 );
+	strcpy( pName, pName_ );
+
+	int nOutput = FindTexData( pName );
+	if ( nOutput >= 0 )
+		return nOutput;
+
+	// Didn't find it, add a new one
+	nOutput = numtexdata;
+	if ( numtexdata >= MAX_MAP_TEXDATA )
+	{
+		Error( "Too many unique texture mappings, max = %d\n", MAX_MAP_TEXDATA );
+	}
+	dtexdata_t *pTexData = GetTexData( nOutput );
+	numtexdata++;
+
+	// Save the name of the material.
+	pTexData->nameStringTableID = TexDataStringTable_AddOrFindString( pName );
+
+	// Get the width, height, view_width, view_height, and reflectivity from the material system.
+	bool bFound;
+	MaterialSystemMaterial_t matID = FindOriginalMaterial( pName, &bFound );
+	if ( matID == MATERIAL_NOT_FOUND || (!bFound) )
+	{
+		qprintf( "WARNING: material not found: \"%s\"\n", pName );
+		return nOutput;
+	}
+
+	GetMaterialDimensions( matID, &pTexData->width, &pTexData->height );
+	pTexData->view_width = pTexData->width;  // undone: what is this?
+	pTexData->view_height = pTexData->height;  // undone: what is this?
+	
+	GetMaterialReflectivity( matID, pTexData->reflectivity.Base() );
+	g_SurfaceProperties[nOutput] = GetSurfaceProperties( matID, pName );
+
+#if 0
+	Msg( "reflectivity: %f %f %f\n", 
+		pTexData->reflectivity[0],
+		pTexData->reflectivity[1],
+		pTexData->reflectivity[2] );
+#endif
+
+	return nOutput;
+}
+
+int AddCloneTexData( dtexdata_t *pExistingTexData, char const *cloneTexDataName )
+{
+	int existingIndex = pExistingTexData - GetTexData( 0 );
+	dtexdata_t *pNewTexData = GetTexData( numtexdata );
+	int newIndex = numtexdata;
+	numtexdata++;
+
+	*pNewTexData = *pExistingTexData;
+	pNewTexData->nameStringTableID = TexDataStringTable_AddOrFindString( cloneTexDataName );
+	g_SurfaceProperties[newIndex] = g_SurfaceProperties[existingIndex];
+
+	return newIndex;
+}
+
+
+//-----------------------------------------------------------------------------
+// Finds a texinfo that exactly matches the passed in texinfo
+//-----------------------------------------------------------------------------
+int FindTexInfo( const texinfo_t &searchTexInfo )
+{
+	for( int i = 0; i < texinfo.Count(); i++ )
+	{
+		// Just an early-out for performance
+		if ( texinfo[i].texdata != searchTexInfo.texdata )
+			continue;
+
+		if ( !memcmp( &texinfo[i], &searchTexInfo, sizeof( texinfo_t ) ) )
+			return i;
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Finds or creates a texinfo that exactly matches the passed in texinfo
+//-----------------------------------------------------------------------------
+int FindOrCreateTexInfo( const texinfo_t &searchTexInfo )
+{
+	int i = FindTexInfo( searchTexInfo );
+	if ( i >= 0 )
+		return i;
+
+	i = texinfo.AddToTail( searchTexInfo );
+
+	if ( onlyents )
+	{
+		Error( "FindOrCreateTexInfo:  Tried to create new texinfo during -onlyents compile!\nMust compile without -onlyents" );
+	}
+
+	return i;
+}
+
+int TexinfoForBrushTexture (plane_t *plane, brush_texture_t *bt, const Vector& origin)
+{
+	Vector	vecs[2];
+	int		sv, tv;
+	vec_t	ang, sinv, cosv;
+	vec_t	ns, nt;
+	texinfo_t	tx;
+	int		i, j;
+
+	if (!bt->name[0])
+		return 0;
+
+	memset (&tx, 0, sizeof(tx));
+
+	// HLTOOLS - add support for texture vectors stored in the map file
+	if (g_nMapFileVersion < 220)
+	{
+		TextureAxisFromPlane(plane, vecs[0], vecs[1]);
+	}
+
+	if (!bt->textureWorldUnitsPerTexel[0])
+		bt->textureWorldUnitsPerTexel[0] = 1;
+	if (!bt->textureWorldUnitsPerTexel[1])
+		bt->textureWorldUnitsPerTexel[1] = 1;
+
+
+	float shiftScaleU = 1.0f / 16.0f;
+	float shiftScaleV = 1.0f / 16.0f;
+
+	if (g_nMapFileVersion < 220)
+	{
+	// rotate axis
+		if (bt->rotate == 0)
+			{ sinv = 0 ; cosv = 1; }
+		else if (bt->rotate == 90)
+			{ sinv = 1 ; cosv = 0; }
+		else if (bt->rotate == 180)
+			{ sinv = 0 ; cosv = -1; }
+		else if (bt->rotate == 270)
+			{ sinv = -1 ; cosv = 0; }
+		else
+		{	
+			ang = bt->rotate / 180 * M_PI;
+			sinv = sin(ang);
+			cosv = cos(ang);
+		}
+
+		if (vecs[0][0])
+			sv = 0;
+		else if (vecs[0][1])
+			sv = 1;
+		else
+			sv = 2;
+					
+		if (vecs[1][0])
+			tv = 0;
+		else if (vecs[1][1])
+			tv = 1;
+		else
+			tv = 2;
+						
+		for (i=0 ; i<2 ; i++)
+		{
+			ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
+			nt = sinv * vecs[i][sv] +  cosv * vecs[i][tv];
+			vecs[i][sv] = ns;
+			vecs[i][tv] = nt;
+		}
+
+		for (i=0 ; i<2 ; i++)
+		{
+			for (j=0 ; j<3 ; j++)
+			{
+				tx.textureVecsTexelsPerWorldUnits[i][j] = vecs[i][j] / bt->textureWorldUnitsPerTexel[i];
+				tx.lightmapVecsLuxelsPerWorldUnits[i][j] = tx.textureVecsTexelsPerWorldUnits[i][j] / 16.0f;
+			}
+		}
+	}
+	else
+	{
+		tx.textureVecsTexelsPerWorldUnits[0][0] = bt->UAxis[0] / bt->textureWorldUnitsPerTexel[0];
+		tx.textureVecsTexelsPerWorldUnits[0][1] = bt->UAxis[1] / bt->textureWorldUnitsPerTexel[0];
+		tx.textureVecsTexelsPerWorldUnits[0][2] = bt->UAxis[2] / bt->textureWorldUnitsPerTexel[0];
+
+		tx.textureVecsTexelsPerWorldUnits[1][0] = bt->VAxis[0] / bt->textureWorldUnitsPerTexel[1];
+		tx.textureVecsTexelsPerWorldUnits[1][1] = bt->VAxis[1] / bt->textureWorldUnitsPerTexel[1];
+		tx.textureVecsTexelsPerWorldUnits[1][2] = bt->VAxis[2] / bt->textureWorldUnitsPerTexel[1];
+
+		tx.lightmapVecsLuxelsPerWorldUnits[0][0] = bt->UAxis[0] / bt->lightmapWorldUnitsPerLuxel;
+		tx.lightmapVecsLuxelsPerWorldUnits[0][1] = bt->UAxis[1] / bt->lightmapWorldUnitsPerLuxel;
+		tx.lightmapVecsLuxelsPerWorldUnits[0][2] = bt->UAxis[2] / bt->lightmapWorldUnitsPerLuxel;
+		
+		tx.lightmapVecsLuxelsPerWorldUnits[1][0] = bt->VAxis[0] / bt->lightmapWorldUnitsPerLuxel;
+		tx.lightmapVecsLuxelsPerWorldUnits[1][1] = bt->VAxis[1] / bt->lightmapWorldUnitsPerLuxel;
+		tx.lightmapVecsLuxelsPerWorldUnits[1][2] = bt->VAxis[2] / bt->lightmapWorldUnitsPerLuxel;
+
+		shiftScaleU = bt->textureWorldUnitsPerTexel[0] / bt->lightmapWorldUnitsPerLuxel;
+		shiftScaleV = bt->textureWorldUnitsPerTexel[1] / bt->lightmapWorldUnitsPerLuxel;
+	}
+
+	tx.textureVecsTexelsPerWorldUnits[0][3] = bt->shift[0] + 
+		DOT_PRODUCT( origin, tx.textureVecsTexelsPerWorldUnits[0] );
+	tx.textureVecsTexelsPerWorldUnits[1][3] = bt->shift[1] + 
+		DOT_PRODUCT( origin, tx.textureVecsTexelsPerWorldUnits[1] );
+	
+	tx.lightmapVecsLuxelsPerWorldUnits[0][3] = shiftScaleU * bt->shift[0] +
+		DOT_PRODUCT( origin, tx.lightmapVecsLuxelsPerWorldUnits[0] );
+	tx.lightmapVecsLuxelsPerWorldUnits[1][3] = shiftScaleV * bt->shift[1] +
+		DOT_PRODUCT( origin, tx.lightmapVecsLuxelsPerWorldUnits[1] );
+	
+	tx.flags = bt->flags;
+	tx.texdata = FindOrCreateTexData( bt->name );
+
+	// find the texinfo
+	return FindOrCreateTexInfo( tx );
+}
+
+
+void LoadSurfacePropFile( const char *pMaterialFilename )
+{
+	FileHandle_t fp = g_pFileSystem->Open( pMaterialFilename, "rb" );
+
+	if ( fp == FILESYSTEM_INVALID_HANDLE )
+	{
+		return;
+	}
+
+	int len = g_pFileSystem->Size( fp );
+
+	char *pText = new char[len];
+	g_pFileSystem->Read( pText, len, fp );
+	g_pFileSystem->Close( fp );
+
+	physprops->ParseSurfaceData( pMaterialFilename, pText );
+
+	delete[] pText;
+}
+//-----------------------------------------------------------------------------
+// Purpose: Loads the surface properties database into the physics DLL
+//-----------------------------------------------------------------------------
+void LoadSurfaceProperties( void )
+{
+	CreateInterfaceFn physicsFactory = GetPhysicsFactory();
+	if ( !physicsFactory )
+		return;
+
+	physprops = (IPhysicsSurfaceProps *)physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL );
+
+	const char *SURFACEPROP_MANIFEST_FILE = "scripts/surfaceproperties_manifest.txt";
+	KeyValues *manifest = new KeyValues( SURFACEPROP_MANIFEST_FILE );
+	if ( manifest->LoadFromFile( g_pFileSystem, SURFACEPROP_MANIFEST_FILE, "GAME" ) )
+	{
+		for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
+		{
+			if ( !Q_stricmp( sub->GetName(), "file" ) )
+			{
+				// Add
+				LoadSurfacePropFile( sub->GetString() );
+				continue;
+			}
+		}
+	}
+
+	manifest->deleteThis();
+}
+
+