First version of the SOurce SDK 2013

1 files changed, 737 insertions, 0 deletions

diff --git a/mp/src/utils/vbsp/textures.cpp b/mp/src/utils/vbsp/textures.cpp
new file mode 100644
index 00000000..fc2034eb
--- /dev/null
+++ b/mp/src/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();

+}

+

+