Fix line endings. WHAMMY.

1 files changed, 582 insertions, 582 deletions

diff --git a/mp/src/game/client/camomaterialproxy.cpp b/mp/src/game/client/camomaterialproxy.cpp
index 0e0d5df0..77828c89 100644
--- a/mp/src/game/client/camomaterialproxy.cpp
+++ b/mp/src/game/client/camomaterialproxy.cpp
@@ -1,582 +1,582 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-// $NoKeywords: $

-//=============================================================================//

-

-

-#include "cbase.h"

-// identifier was truncated to '255' characters in the debug information

-#pragma warning(disable: 4786)

-

-#include "proxyentity.h"

-#include "materialsystem/imaterialvar.h"

-#include "materialsystem/itexture.h"

-#include "bitmap/tgaloader.h"

-#include "view.h"

-#include "datacache/idatacache.h"

-#include "materialsystem/imaterial.h"

-#include "vtf/vtf.h"

-

-// memdbgon must be the last include file in a .cpp file!!!

-#include "tier0/memdbgon.h"

-

-class CCamoMaterialProxy;

-

-class CCamoTextureRegen : public ITextureRegenerator

-{

-public:

-	CCamoTextureRegen( CCamoMaterialProxy *pProxy ) : m_pProxy(pProxy) {} 

-	virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect );

-	virtual void Release() {}

-

-private:

-	CCamoMaterialProxy *m_pProxy;

-};

-

-class CCamoMaterialProxy : public CEntityMaterialProxy

-{

-public:

-	CCamoMaterialProxy();

-	virtual ~CCamoMaterialProxy();

-	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );

-	virtual void OnBind(C_BaseEntity *pC_BaseEntity );

-	virtual IMaterial *GetMaterial();

-

-	// Procedurally generates the camo texture...

-	void GenerateCamoTexture( ITexture* pTexture, IVTFTexture *pVTFTexture );

-

-protected:

-#if 0

-	virtual void SetInstanceDataSize( int size );

-	virtual void *FindInstanceData( C_BaseEntity *pEntity );

-	virtual void *AllocateInstanceData( C_BaseEntity *pEntity );

-#endif

-

-private:

-	void LoadCamoPattern( void );

-	void GenerateRandomPointsInNormalizedCube( void );

-	void GetColors( Vector &lighting, Vector &base, int index, 

-						  const Vector &boxMin, const Vector &boxExtents, 

-						  const Vector &forward, const Vector &right, const Vector &up,

-						  const Vector& entityPosition );

-	// this needs to go in a base class

-

-private:

-#if 0

-	// stuff that needs to be in a base class.

-	struct InstanceData_t

-	{

-		C_BaseEntity *pEntity;

-		void *data;

-		struct InstanceData_s *next;

-	};

-	

-	struct CamoInstanceData_t

-	{

-		int dummy;

-	};

-#endif

-	

-	unsigned char *m_pCamoPatternImage;

-

-#if 0

-	int m_InstanceDataSize;

-	InstanceData_t *m_InstanceDataListHead;

-#endif

-

-	IMaterial *m_pMaterial;

-	IMaterialVar *m_pCamoTextureVar;

-	IMaterialVar *m_pCamoPatternTextureVar;

-	Vector *m_pointsInNormalizedBox; // [m_CamoPatternNumColors]

-

-	int m_CamoPatternNumColors;

-	int m_CamoPatternWidth;

-	int m_CamoPatternHeight;

-#if 0

-	cache_user_t m_camoImageDataCache;

-#endif

-	unsigned char m_CamoPalette[256][3];

-	// these represent that part of the entitiy's bounding box that we 

-	// want to cast rays through to get colors for the camo

-	Vector m_SubBoundingBoxMin; // normalized

-	Vector m_SubBoundingBoxMax; // normalized

-

-	CCamoTextureRegen m_TextureRegen;

-	C_BaseEntity *m_pEnt;

-};

-

-

-void CCamoTextureRegen::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )

-{

-	m_pProxy->GenerateCamoTexture( pTexture, pVTFTexture );

-}

-

-

-#pragma warning (disable:4355)

-

-CCamoMaterialProxy::CCamoMaterialProxy() : m_TextureRegen(this)

-{

-#if 0

-	m_InstanceDataSize = 0;

-#endif

-#if 0

-	memset( &m_camoImageDataCache, 0,sizeof( m_camoImageDataCache ) );

-#endif

-	m_pointsInNormalizedBox = NULL;

-#if 0

-	m_InstanceDataListHead = NULL;

-#endif

-	m_pCamoPatternImage = NULL;

-	m_pMaterial = NULL;

-	m_pCamoTextureVar = NULL;

-	m_pCamoPatternTextureVar = NULL;

-	m_pointsInNormalizedBox = NULL;

-	m_pEnt = NULL;

-}

-

-#pragma warning (default:4355)

-

-CCamoMaterialProxy::~CCamoMaterialProxy()

-{

-#if 0

-	InstanceData_t *curr = m_InstanceDataListHead;

-	while( curr )

-	{

-		InstanceData_t *next;

-		next = curr->next;

-		delete curr;

-		curr = next;

-	}

-	m_InstanceDataListHead = NULL;

-#endif

-

-	// Disconnect the texture regenerator...

-	if (m_pCamoTextureVar)

-	{

-		ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();

-		if (pCamoTexture)

-			pCamoTexture->SetTextureRegenerator( NULL );

-	}

-

-	delete m_pCamoPatternImage;

-	delete m_pointsInNormalizedBox;

-}

-

-

-#if 0

-void CCamoMaterialProxy::SetInstanceDataSize( int size )

-{

-	m_InstanceDataSize = size;

-}

-#endif

-

-#if 0

-void *CCamoMaterialProxy::FindInstanceData( C_BaseEntity *pEntity )

-{

-	InstanceData_t *curr = m_InstanceDataListHead;

-	while( curr )

-	{

-		if( pEntity == curr->pEntity )

-		{

-			return curr->data;

-		}

-		curr = curr->next;

-	}

-	return NULL;

-}

-#endif

-

-#if 0

-void *CCamoMaterialProxy::AllocateInstanceData( C_BaseEntity *pEntity )

-{

-	InstanceData_t *newData = new InstanceData_t;

-	newData->pEntity = pEntity;

-	newData->next = m_InstanceDataListHead;

-	m_InstanceDataListHead = newData;

-	newData->data = new unsigned char[m_InstanceDataSize];

-	return newData->data;

-}

-#endif

-

-bool CCamoMaterialProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )

-{

-	return false; // hack!  Need to make sure that the TGA loader has a valid filesystem before trying

-			// to load the camo pattern.

-

-#if 0

-	// set how big our instance data is.

-	SetInstanceDataSize( sizeof( CamoInstanceData_t ) );

-#endif

-	// remember what material we belong to.

-	m_pMaterial = pMaterial;

-	// get pointers to material vars.

-	bool found;

-	m_pCamoTextureVar = m_pMaterial->FindVar( "$baseTexture", &found );

-	if( !found )

-	{

-		m_pCamoTextureVar = NULL;

-		return false;

-	}

-	ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();

-	if (pCamoTexture)

-		pCamoTexture->SetTextureRegenerator( &m_TextureRegen );

-	

-	// Need to get the palettized texture to create the procedural texture from

-	// somewhere.

-	m_pCamoPatternTextureVar = m_pMaterial->FindVar( "$camoPatternTexture", &found );

-	if( !found )

-	{

-		m_pCamoTextureVar = NULL;

-		return false;

-	}

-	

-	IMaterialVar *subBoundingBoxMinVar, *subBoundingBoxMaxVar;

-

-	subBoundingBoxMinVar = m_pMaterial->FindVar( "$camoBoundingBoxMin", &found, false );

-	if( !found )

-	{

-		m_SubBoundingBoxMin = Vector( 0.0f, 0.0f, 0.0f );

-	}

-	else

-	{

-		subBoundingBoxMinVar->GetVecValue( m_SubBoundingBoxMin.Base(), 3 );

-	}

-

-	subBoundingBoxMaxVar = m_pMaterial->FindVar( "$camoBoundingBoxMax", &found, false );

-	if( !found )

-	{

-		m_SubBoundingBoxMax = Vector( 1.0f, 1.0f, 1.0f );

-	}

-	else

-	{

-		subBoundingBoxMaxVar->GetVecValue( m_SubBoundingBoxMax.Base(), 3 );

-	}

-	

-	LoadCamoPattern();

-	GenerateRandomPointsInNormalizedCube();

-

-	return true;

-}

-

-void CCamoMaterialProxy::GetColors( Vector &diffuseColor, Vector &baseColor, int index, 

-										  const Vector &boxMin, const Vector &boxExtents, 

-										  const Vector &forward, const Vector &right, const Vector &up,

-										  const Vector& entityPosition )

-{

-	Vector position, transformedPosition;

-	

-	// hack

-//	m_pointsInNormalizedBox[index] = Vector( 0.5f, 0.5f, 1.0f );

-	

-	position[0] = m_pointsInNormalizedBox[index][0] * boxExtents[0] + boxMin[0];

-	position[1] = m_pointsInNormalizedBox[index][1] * boxExtents[1] + boxMin[1];

-	position[2] = m_pointsInNormalizedBox[index][2] * boxExtents[2] + boxMin[2];

-	transformedPosition[0] = right[0] * position[0] + forward[0] * position[1] + up[0] * position[2];

-	transformedPosition[1] = right[1] * position[0] + forward[1] * position[1] + up[1] * position[2];

-	transformedPosition[2] = right[2] * position[0] + forward[2] * position[1] + up[2] * position[2];

-	transformedPosition = transformedPosition + entityPosition;

-	Vector direction = transformedPosition - CurrentViewOrigin();

-	VectorNormalize( direction );

-	direction = direction * ( COORD_EXTENT * 1.74f );

-	Vector endPoint = position + direction;

-	

-	// baseColor is already in gamma space

-//	engine->TraceLineMaterialAndLighting( g_vecInstantaneousRenderOrigin, endPoint, diffuseColor, baseColor );

-	engine->TraceLineMaterialAndLighting( transformedPosition, endPoint, diffuseColor, baseColor );

-

-	// hack - optimize! - convert from linear to gamma space - this should be hidden

-	diffuseColor[0] = pow( diffuseColor[0], 1.0f / 2.2f );

-	diffuseColor[1] = pow( diffuseColor[1], 1.0f / 2.2f );

-	diffuseColor[2] = pow( diffuseColor[2], 1.0f / 2.2f );

-

-#if 0

-	Msg( "%f %f %f\n", 

-		diffuseColor[0], 

-		diffuseColor[1], 

-		diffuseColor[2] );

-#endif

-	

-#if 0

-	float max;

-	max = diffuseColor[0];

-	if( diffuseColor[1] > max )

-	{

-		max = diffuseColor[1];

-	}

-	if( diffuseColor[2] > max )

-	{

-		max = diffuseColor[2];

-	}

-	if( max > 1.0f )

-	{

-		max = 1.0f / max;

-		diffuseColor = diffuseColor * max;

-	}

-#else

-	if( diffuseColor[0] > 1.0f )

-	{

-		diffuseColor[0] = 1.0f;

-	}

-	if( diffuseColor[1] > 1.0f )

-	{

-		diffuseColor[1] = 1.0f;

-	}

-	if( diffuseColor[2] > 1.0f )

-	{

-		diffuseColor[2] = 1.0f;

-	}

-#endif

-	// hack

-	//baseColor = Vector( 1.0f, 1.0f, 1.0f );

-	//diffuseColor = Vector( 1.0f, 1.0f, 1.0f );

-}

-

-

-//-----------------------------------------------------------------------------

-// Procedurally generates the camo texture...

-//-----------------------------------------------------------------------------

-void CCamoMaterialProxy::GenerateCamoTexture( ITexture* pTexture, IVTFTexture *pVTFTexture )

-{

-	if (!m_pEnt)

-		return;

-

-#if 0

-	CamoInstanceData_t *pInstanceData;

-	pInstanceData = ( CamoInstanceData_t * )FindInstanceData( pEnt );

-	if( !pInstanceData )

-	{

-		pInstanceData = ( CamoInstanceData_t * )AllocateInstanceData( pEnt );

-		if( !pInstanceData )

-		{

-			return;

-		}

-		// init the instance data

-	}

-#endif

-

-	Vector entityPosition;

-	entityPosition = m_pEnt->GetAbsOrigin();

-

-	QAngle entityAngles;

-	entityAngles = m_pEnt->GetAbsAngles();

-

-	// Get the bounding box for the entity

-	Vector mins, maxs;

-	mins = m_pEnt->WorldAlignMins();

-	maxs = m_pEnt->WorldAlignMaxs();

-	

-	Vector traceDirection;

-	Vector traceEnd;

-	trace_t	traceResult;

-	

-	Vector forward, right, up;

-	AngleVectors( entityAngles, &forward, &right, &up );

-	

-	Vector position, transformedPosition;

-	Vector maxsMinusMins = maxs - mins;

-

-	Vector diffuseColor[256];

-	Vector baseColor;

-

-	unsigned char camoPalette[256][3];

-	// Calculate the camo palette

-	//Msg( "start of loop\n" );

-	int i;

-	for( i = 0; i < m_CamoPatternNumColors; i++ )

-	{

-		GetColors( diffuseColor[i], baseColor, i,

-			mins, maxsMinusMins, forward, right, up, entityPosition );

-#if 1

-		camoPalette[i][0] = diffuseColor[i][0] * baseColor[0] * 255.0f;

-		camoPalette[i][1] = diffuseColor[i][1] * baseColor[1] * 255.0f;

-		camoPalette[i][2] = diffuseColor[i][2] * baseColor[2] * 255.0f;

-#endif

-#if 0

-		camoPalette[i][0] = baseColor[0] * 255.0f;

-		camoPalette[i][1] = baseColor[1] * 255.0f;

-		camoPalette[i][2] = baseColor[2] * 255.0f;

-#endif

-#if 0

-		camoPalette[i][0] = diffuseColor[i][0] * 255.0f;

-		camoPalette[i][1] = diffuseColor[i][1] * 255.0f;

-		camoPalette[i][2] = diffuseColor[i][2] * 255.0f;

-#endif

-	}

-	

-	int width = pVTFTexture->Width();

-	int height = pVTFTexture->Height();

-	if( width != m_CamoPatternWidth || height != m_CamoPatternHeight )

-	{

-		return;

-	}

-	

-	unsigned char *imageData = pVTFTexture->ImageData( 0, 0, 0 );

-	enum ImageFormat imageFormat = pVTFTexture->Format();

-	if( imageFormat != IMAGE_FORMAT_RGB888 )

-	{

-		return;

-	}

-	// optimize

-#if 1

-	int x, y;

-	for( y = 0; y < height; y++ )

-	{

-		for( x = 0; x < width; x++ )

-		{

-			int offset = 3 * ( x + y * width );

-			assert( offset < width * height * 3 );

-			int paletteID = m_pCamoPatternImage[x + y * width];

-			assert( paletteID < 256 );

-#if 1

-			imageData[offset + 0] = camoPalette[paletteID][0];

-			imageData[offset + 1] = camoPalette[paletteID][1];

-			imageData[offset + 2] = camoPalette[paletteID][2];

-#else

-			imageData[offset] = 255;

-			imageData[offset + 1] = 0;

-			imageData[offset + 2] = 0;

-#endif

-		}

-	}

-#endif

-}

-

-

-//-----------------------------------------------------------------------------

-// Called when the texture is bound...

-//-----------------------------------------------------------------------------

-void CCamoMaterialProxy::OnBind( C_BaseEntity *pEntity )

-{

-	if( !m_pCamoTextureVar )

-	{

-		return;

-	}

-	

-	m_pEnt = pEntity;	

-	ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();

-	pCamoTexture->Download();

-

-	// Mark it so it doesn't get regenerated on task switch

-	m_pEnt = NULL;

-}

-

-void CCamoMaterialProxy::LoadCamoPattern( void )

-{

-#if 0

-	// hack - need to figure out a name to attach that isn't too long.

-	m_pCamoPatternImage = 

-		( unsigned char * )datacache->FindByName( &m_camoImageDataCache, "camopattern" );

-	

-	if( m_pCamoPatternImage )

-	{

-		// is already in the cache.

-		return m_pCamoPatternImage;

-	}

-#endif

-	

-	enum ImageFormat indexImageFormat;

-	int indexImageSize;

-#ifndef _XBOX

-	float dummyGamma;

-	if( !TGALoader::GetInfo( m_pCamoPatternTextureVar->GetStringValue(), 

-		&m_CamoPatternWidth, &m_CamoPatternHeight, &indexImageFormat, &dummyGamma ) )

-	{

-		//Warning( "Can't get tga info for hl2/materials/models/combine_elite/camo7paletted.tga for camo material\n" );

-		m_pCamoTextureVar = NULL;

-		return;

-	}

-#else

-	// xboxissue - no tga support, why implemented this way

-	Assert( 0 );

-	m_pCamoTextureVar = NULL;

-	return;

-#endif

-	

-	if( indexImageFormat != IMAGE_FORMAT_I8 )

-	{

-		//	Warning( "Camo material texture hl2/materials/models/combine_elite/camo7paletted.tga must be 8-bit greyscale\n" );

-		m_pCamoTextureVar = NULL;

-		return;

-	}

-	

-	indexImageSize = ImageLoader::GetMemRequired( m_CamoPatternWidth, m_CamoPatternHeight, 1, indexImageFormat, false );

-#if 0

-	m_pCamoPatternImage = ( unsigned char * )

-		datacache->Alloc( &m_camoImageDataCache, indexImageSize, "camopattern" );

-#endif

-	m_pCamoPatternImage = ( unsigned char * )new unsigned char[indexImageSize];

-	if( !m_pCamoPatternImage )

-	{

-		m_pCamoTextureVar = NULL;

-		return;

-	}

-	

-#ifndef _XBOX

-	if( !TGALoader::Load( m_pCamoPatternImage, m_pCamoPatternTextureVar->GetStringValue(),

-		m_CamoPatternWidth, m_CamoPatternHeight, IMAGE_FORMAT_I8, dummyGamma, false ) )

-	{

-		//			Warning( "camo texture hl2/materials/models/combine_elite/camo7paletted.tga must be grey-scale" );

-		m_pCamoTextureVar = NULL;

-		return;

-	}

-#else

-	// xboxissue - no tga support, why is the camo done this way?

-	Assert( 0 );

-#endif

-	

-	bool colorUsed[256];

-	int colorRemap[256];

-	// count the number of colors used in the image.

-	int i;

-	for( i = 0; i < 256; i++ )

-	{

-		colorUsed[i] = false;

-	}

-	for( i = 0; i < indexImageSize; i++ )

-	{

-		colorUsed[m_pCamoPatternImage[i]] = true;

-	}

-	m_CamoPatternNumColors = 0;

-	for( i = 0; i < 256; i++ )

-	{

-		if( colorUsed[i] )

-		{

-			colorRemap[i] = m_CamoPatternNumColors;

-			m_CamoPatternNumColors++;

-		}

-	}

-	// remap the color to the beginning of the palette.

-	for( i = 0; i < indexImageSize; i++ )

-	{

-		m_pCamoPatternImage[i] = colorRemap[m_pCamoPatternImage[i]];

-		// hack

-//		m_pCamoPatternImage[i] = 0;

-	}

-}

-

-void CCamoMaterialProxy::GenerateRandomPointsInNormalizedCube( void )

-{

-	m_pointsInNormalizedBox = new Vector[m_CamoPatternNumColors];

-	if( !m_pointsInNormalizedBox )

-	{

-		m_pCamoTextureVar = NULL;

-		return;

-	}

-	

-	int i;

-	for( i = 0; i < m_CamoPatternNumColors; i++ )

-	{

-		m_pointsInNormalizedBox[i][0] = random->RandomFloat( m_SubBoundingBoxMin[0], m_SubBoundingBoxMax[0] );

-		m_pointsInNormalizedBox[i][1] = random->RandomFloat( m_SubBoundingBoxMin[1], m_SubBoundingBoxMax[1] );

-		m_pointsInNormalizedBox[i][2] = random->RandomFloat( m_SubBoundingBoxMin[2], m_SubBoundingBoxMax[2] );

-	}

-}

-

-IMaterial *CCamoMaterialProxy::GetMaterial()

-{

-	return m_pMaterial;

-}

-

-EXPOSE_INTERFACE( CCamoMaterialProxy, IMaterialProxy, "Camo" IMATERIAL_PROXY_INTERFACE_VERSION );

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+
+#include "cbase.h"
+// identifier was truncated to '255' characters in the debug information
+#pragma warning(disable: 4786)
+
+#include "proxyentity.h"
+#include "materialsystem/imaterialvar.h"
+#include "materialsystem/itexture.h"
+#include "bitmap/tgaloader.h"
+#include "view.h"
+#include "datacache/idatacache.h"
+#include "materialsystem/imaterial.h"
+#include "vtf/vtf.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class CCamoMaterialProxy;
+
+class CCamoTextureRegen : public ITextureRegenerator
+{
+public:
+	CCamoTextureRegen( CCamoMaterialProxy *pProxy ) : m_pProxy(pProxy) {} 
+	virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect );
+	virtual void Release() {}
+
+private:
+	CCamoMaterialProxy *m_pProxy;
+};
+
+class CCamoMaterialProxy : public CEntityMaterialProxy
+{
+public:
+	CCamoMaterialProxy();
+	virtual ~CCamoMaterialProxy();
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind(C_BaseEntity *pC_BaseEntity );
+	virtual IMaterial *GetMaterial();
+
+	// Procedurally generates the camo texture...
+	void GenerateCamoTexture( ITexture* pTexture, IVTFTexture *pVTFTexture );
+
+protected:
+#if 0
+	virtual void SetInstanceDataSize( int size );
+	virtual void *FindInstanceData( C_BaseEntity *pEntity );
+	virtual void *AllocateInstanceData( C_BaseEntity *pEntity );
+#endif
+
+private:
+	void LoadCamoPattern( void );
+	void GenerateRandomPointsInNormalizedCube( void );
+	void GetColors( Vector &lighting, Vector &base, int index, 
+						  const Vector &boxMin, const Vector &boxExtents, 
+						  const Vector &forward, const Vector &right, const Vector &up,
+						  const Vector& entityPosition );
+	// this needs to go in a base class
+
+private:
+#if 0
+	// stuff that needs to be in a base class.
+	struct InstanceData_t
+	{
+		C_BaseEntity *pEntity;
+		void *data;
+		struct InstanceData_s *next;
+	};
+	
+	struct CamoInstanceData_t
+	{
+		int dummy;
+	};
+#endif
+	
+	unsigned char *m_pCamoPatternImage;
+
+#if 0
+	int m_InstanceDataSize;
+	InstanceData_t *m_InstanceDataListHead;
+#endif
+
+	IMaterial *m_pMaterial;
+	IMaterialVar *m_pCamoTextureVar;
+	IMaterialVar *m_pCamoPatternTextureVar;
+	Vector *m_pointsInNormalizedBox; // [m_CamoPatternNumColors]
+
+	int m_CamoPatternNumColors;
+	int m_CamoPatternWidth;
+	int m_CamoPatternHeight;
+#if 0
+	cache_user_t m_camoImageDataCache;
+#endif
+	unsigned char m_CamoPalette[256][3];
+	// these represent that part of the entitiy's bounding box that we 
+	// want to cast rays through to get colors for the camo
+	Vector m_SubBoundingBoxMin; // normalized
+	Vector m_SubBoundingBoxMax; // normalized
+
+	CCamoTextureRegen m_TextureRegen;
+	C_BaseEntity *m_pEnt;
+};
+
+
+void CCamoTextureRegen::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
+{
+	m_pProxy->GenerateCamoTexture( pTexture, pVTFTexture );
+}
+
+
+#pragma warning (disable:4355)
+
+CCamoMaterialProxy::CCamoMaterialProxy() : m_TextureRegen(this)
+{
+#if 0
+	m_InstanceDataSize = 0;
+#endif
+#if 0
+	memset( &m_camoImageDataCache, 0,sizeof( m_camoImageDataCache ) );
+#endif
+	m_pointsInNormalizedBox = NULL;
+#if 0
+	m_InstanceDataListHead = NULL;
+#endif
+	m_pCamoPatternImage = NULL;
+	m_pMaterial = NULL;
+	m_pCamoTextureVar = NULL;
+	m_pCamoPatternTextureVar = NULL;
+	m_pointsInNormalizedBox = NULL;
+	m_pEnt = NULL;
+}
+
+#pragma warning (default:4355)
+
+CCamoMaterialProxy::~CCamoMaterialProxy()
+{
+#if 0
+	InstanceData_t *curr = m_InstanceDataListHead;
+	while( curr )
+	{
+		InstanceData_t *next;
+		next = curr->next;
+		delete curr;
+		curr = next;
+	}
+	m_InstanceDataListHead = NULL;
+#endif
+
+	// Disconnect the texture regenerator...
+	if (m_pCamoTextureVar)
+	{
+		ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();
+		if (pCamoTexture)
+			pCamoTexture->SetTextureRegenerator( NULL );
+	}
+
+	delete m_pCamoPatternImage;
+	delete m_pointsInNormalizedBox;
+}
+
+
+#if 0
+void CCamoMaterialProxy::SetInstanceDataSize( int size )
+{
+	m_InstanceDataSize = size;
+}
+#endif
+
+#if 0
+void *CCamoMaterialProxy::FindInstanceData( C_BaseEntity *pEntity )
+{
+	InstanceData_t *curr = m_InstanceDataListHead;
+	while( curr )
+	{
+		if( pEntity == curr->pEntity )
+		{
+			return curr->data;
+		}
+		curr = curr->next;
+	}
+	return NULL;
+}
+#endif
+
+#if 0
+void *CCamoMaterialProxy::AllocateInstanceData( C_BaseEntity *pEntity )
+{
+	InstanceData_t *newData = new InstanceData_t;
+	newData->pEntity = pEntity;
+	newData->next = m_InstanceDataListHead;
+	m_InstanceDataListHead = newData;
+	newData->data = new unsigned char[m_InstanceDataSize];
+	return newData->data;
+}
+#endif
+
+bool CCamoMaterialProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	return false; // hack!  Need to make sure that the TGA loader has a valid filesystem before trying
+			// to load the camo pattern.
+
+#if 0
+	// set how big our instance data is.
+	SetInstanceDataSize( sizeof( CamoInstanceData_t ) );
+#endif
+	// remember what material we belong to.
+	m_pMaterial = pMaterial;
+	// get pointers to material vars.
+	bool found;
+	m_pCamoTextureVar = m_pMaterial->FindVar( "$baseTexture", &found );
+	if( !found )
+	{
+		m_pCamoTextureVar = NULL;
+		return false;
+	}
+	ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();
+	if (pCamoTexture)
+		pCamoTexture->SetTextureRegenerator( &m_TextureRegen );
+	
+	// Need to get the palettized texture to create the procedural texture from
+	// somewhere.
+	m_pCamoPatternTextureVar = m_pMaterial->FindVar( "$camoPatternTexture", &found );
+	if( !found )
+	{
+		m_pCamoTextureVar = NULL;
+		return false;
+	}
+	
+	IMaterialVar *subBoundingBoxMinVar, *subBoundingBoxMaxVar;
+
+	subBoundingBoxMinVar = m_pMaterial->FindVar( "$camoBoundingBoxMin", &found, false );
+	if( !found )
+	{
+		m_SubBoundingBoxMin = Vector( 0.0f, 0.0f, 0.0f );
+	}
+	else
+	{
+		subBoundingBoxMinVar->GetVecValue( m_SubBoundingBoxMin.Base(), 3 );
+	}
+
+	subBoundingBoxMaxVar = m_pMaterial->FindVar( "$camoBoundingBoxMax", &found, false );
+	if( !found )
+	{
+		m_SubBoundingBoxMax = Vector( 1.0f, 1.0f, 1.0f );
+	}
+	else
+	{
+		subBoundingBoxMaxVar->GetVecValue( m_SubBoundingBoxMax.Base(), 3 );
+	}
+	
+	LoadCamoPattern();
+	GenerateRandomPointsInNormalizedCube();
+
+	return true;
+}
+
+void CCamoMaterialProxy::GetColors( Vector &diffuseColor, Vector &baseColor, int index, 
+										  const Vector &boxMin, const Vector &boxExtents, 
+										  const Vector &forward, const Vector &right, const Vector &up,
+										  const Vector& entityPosition )
+{
+	Vector position, transformedPosition;
+	
+	// hack
+//	m_pointsInNormalizedBox[index] = Vector( 0.5f, 0.5f, 1.0f );
+	
+	position[0] = m_pointsInNormalizedBox[index][0] * boxExtents[0] + boxMin[0];
+	position[1] = m_pointsInNormalizedBox[index][1] * boxExtents[1] + boxMin[1];
+	position[2] = m_pointsInNormalizedBox[index][2] * boxExtents[2] + boxMin[2];
+	transformedPosition[0] = right[0] * position[0] + forward[0] * position[1] + up[0] * position[2];
+	transformedPosition[1] = right[1] * position[0] + forward[1] * position[1] + up[1] * position[2];
+	transformedPosition[2] = right[2] * position[0] + forward[2] * position[1] + up[2] * position[2];
+	transformedPosition = transformedPosition + entityPosition;
+	Vector direction = transformedPosition - CurrentViewOrigin();
+	VectorNormalize( direction );
+	direction = direction * ( COORD_EXTENT * 1.74f );
+	Vector endPoint = position + direction;
+	
+	// baseColor is already in gamma space
+//	engine->TraceLineMaterialAndLighting( g_vecInstantaneousRenderOrigin, endPoint, diffuseColor, baseColor );
+	engine->TraceLineMaterialAndLighting( transformedPosition, endPoint, diffuseColor, baseColor );
+
+	// hack - optimize! - convert from linear to gamma space - this should be hidden
+	diffuseColor[0] = pow( diffuseColor[0], 1.0f / 2.2f );
+	diffuseColor[1] = pow( diffuseColor[1], 1.0f / 2.2f );
+	diffuseColor[2] = pow( diffuseColor[2], 1.0f / 2.2f );
+
+#if 0
+	Msg( "%f %f %f\n", 
+		diffuseColor[0], 
+		diffuseColor[1], 
+		diffuseColor[2] );
+#endif
+	
+#if 0
+	float max;
+	max = diffuseColor[0];
+	if( diffuseColor[1] > max )
+	{
+		max = diffuseColor[1];
+	}
+	if( diffuseColor[2] > max )
+	{
+		max = diffuseColor[2];
+	}
+	if( max > 1.0f )
+	{
+		max = 1.0f / max;
+		diffuseColor = diffuseColor * max;
+	}
+#else
+	if( diffuseColor[0] > 1.0f )
+	{
+		diffuseColor[0] = 1.0f;
+	}
+	if( diffuseColor[1] > 1.0f )
+	{
+		diffuseColor[1] = 1.0f;
+	}
+	if( diffuseColor[2] > 1.0f )
+	{
+		diffuseColor[2] = 1.0f;
+	}
+#endif
+	// hack
+	//baseColor = Vector( 1.0f, 1.0f, 1.0f );
+	//diffuseColor = Vector( 1.0f, 1.0f, 1.0f );
+}
+
+
+//-----------------------------------------------------------------------------
+// Procedurally generates the camo texture...
+//-----------------------------------------------------------------------------
+void CCamoMaterialProxy::GenerateCamoTexture( ITexture* pTexture, IVTFTexture *pVTFTexture )
+{
+	if (!m_pEnt)
+		return;
+
+#if 0
+	CamoInstanceData_t *pInstanceData;
+	pInstanceData = ( CamoInstanceData_t * )FindInstanceData( pEnt );
+	if( !pInstanceData )
+	{
+		pInstanceData = ( CamoInstanceData_t * )AllocateInstanceData( pEnt );
+		if( !pInstanceData )
+		{
+			return;
+		}
+		// init the instance data
+	}
+#endif
+
+	Vector entityPosition;
+	entityPosition = m_pEnt->GetAbsOrigin();
+
+	QAngle entityAngles;
+	entityAngles = m_pEnt->GetAbsAngles();
+
+	// Get the bounding box for the entity
+	Vector mins, maxs;
+	mins = m_pEnt->WorldAlignMins();
+	maxs = m_pEnt->WorldAlignMaxs();
+	
+	Vector traceDirection;
+	Vector traceEnd;
+	trace_t	traceResult;
+	
+	Vector forward, right, up;
+	AngleVectors( entityAngles, &forward, &right, &up );
+	
+	Vector position, transformedPosition;
+	Vector maxsMinusMins = maxs - mins;
+
+	Vector diffuseColor[256];
+	Vector baseColor;
+
+	unsigned char camoPalette[256][3];
+	// Calculate the camo palette
+	//Msg( "start of loop\n" );
+	int i;
+	for( i = 0; i < m_CamoPatternNumColors; i++ )
+	{
+		GetColors( diffuseColor[i], baseColor, i,
+			mins, maxsMinusMins, forward, right, up, entityPosition );
+#if 1
+		camoPalette[i][0] = diffuseColor[i][0] * baseColor[0] * 255.0f;
+		camoPalette[i][1] = diffuseColor[i][1] * baseColor[1] * 255.0f;
+		camoPalette[i][2] = diffuseColor[i][2] * baseColor[2] * 255.0f;
+#endif
+#if 0
+		camoPalette[i][0] = baseColor[0] * 255.0f;
+		camoPalette[i][1] = baseColor[1] * 255.0f;
+		camoPalette[i][2] = baseColor[2] * 255.0f;
+#endif
+#if 0
+		camoPalette[i][0] = diffuseColor[i][0] * 255.0f;
+		camoPalette[i][1] = diffuseColor[i][1] * 255.0f;
+		camoPalette[i][2] = diffuseColor[i][2] * 255.0f;
+#endif
+	}
+	
+	int width = pVTFTexture->Width();
+	int height = pVTFTexture->Height();
+	if( width != m_CamoPatternWidth || height != m_CamoPatternHeight )
+	{
+		return;
+	}
+	
+	unsigned char *imageData = pVTFTexture->ImageData( 0, 0, 0 );
+	enum ImageFormat imageFormat = pVTFTexture->Format();
+	if( imageFormat != IMAGE_FORMAT_RGB888 )
+	{
+		return;
+	}
+	// optimize
+#if 1
+	int x, y;
+	for( y = 0; y < height; y++ )
+	{
+		for( x = 0; x < width; x++ )
+		{
+			int offset = 3 * ( x + y * width );
+			assert( offset < width * height * 3 );
+			int paletteID = m_pCamoPatternImage[x + y * width];
+			assert( paletteID < 256 );
+#if 1
+			imageData[offset + 0] = camoPalette[paletteID][0];
+			imageData[offset + 1] = camoPalette[paletteID][1];
+			imageData[offset + 2] = camoPalette[paletteID][2];
+#else
+			imageData[offset] = 255;
+			imageData[offset + 1] = 0;
+			imageData[offset + 2] = 0;
+#endif
+		}
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Called when the texture is bound...
+//-----------------------------------------------------------------------------
+void CCamoMaterialProxy::OnBind( C_BaseEntity *pEntity )
+{
+	if( !m_pCamoTextureVar )
+	{
+		return;
+	}
+	
+	m_pEnt = pEntity;	
+	ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();
+	pCamoTexture->Download();
+
+	// Mark it so it doesn't get regenerated on task switch
+	m_pEnt = NULL;
+}
+
+void CCamoMaterialProxy::LoadCamoPattern( void )
+{
+#if 0
+	// hack - need to figure out a name to attach that isn't too long.
+	m_pCamoPatternImage = 
+		( unsigned char * )datacache->FindByName( &m_camoImageDataCache, "camopattern" );
+	
+	if( m_pCamoPatternImage )
+	{
+		// is already in the cache.
+		return m_pCamoPatternImage;
+	}
+#endif
+	
+	enum ImageFormat indexImageFormat;
+	int indexImageSize;
+#ifndef _XBOX
+	float dummyGamma;
+	if( !TGALoader::GetInfo( m_pCamoPatternTextureVar->GetStringValue(), 
+		&m_CamoPatternWidth, &m_CamoPatternHeight, &indexImageFormat, &dummyGamma ) )
+	{
+		//Warning( "Can't get tga info for hl2/materials/models/combine_elite/camo7paletted.tga for camo material\n" );
+		m_pCamoTextureVar = NULL;
+		return;
+	}
+#else
+	// xboxissue - no tga support, why implemented this way
+	Assert( 0 );
+	m_pCamoTextureVar = NULL;
+	return;
+#endif
+	
+	if( indexImageFormat != IMAGE_FORMAT_I8 )
+	{
+		//	Warning( "Camo material texture hl2/materials/models/combine_elite/camo7paletted.tga must be 8-bit greyscale\n" );
+		m_pCamoTextureVar = NULL;
+		return;
+	}
+	
+	indexImageSize = ImageLoader::GetMemRequired( m_CamoPatternWidth, m_CamoPatternHeight, 1, indexImageFormat, false );
+#if 0
+	m_pCamoPatternImage = ( unsigned char * )
+		datacache->Alloc( &m_camoImageDataCache, indexImageSize, "camopattern" );
+#endif
+	m_pCamoPatternImage = ( unsigned char * )new unsigned char[indexImageSize];
+	if( !m_pCamoPatternImage )
+	{
+		m_pCamoTextureVar = NULL;
+		return;
+	}
+	
+#ifndef _XBOX
+	if( !TGALoader::Load( m_pCamoPatternImage, m_pCamoPatternTextureVar->GetStringValue(),
+		m_CamoPatternWidth, m_CamoPatternHeight, IMAGE_FORMAT_I8, dummyGamma, false ) )
+	{
+		//			Warning( "camo texture hl2/materials/models/combine_elite/camo7paletted.tga must be grey-scale" );
+		m_pCamoTextureVar = NULL;
+		return;
+	}
+#else
+	// xboxissue - no tga support, why is the camo done this way?
+	Assert( 0 );
+#endif
+	
+	bool colorUsed[256];
+	int colorRemap[256];
+	// count the number of colors used in the image.
+	int i;
+	for( i = 0; i < 256; i++ )
+	{
+		colorUsed[i] = false;
+	}
+	for( i = 0; i < indexImageSize; i++ )
+	{
+		colorUsed[m_pCamoPatternImage[i]] = true;
+	}
+	m_CamoPatternNumColors = 0;
+	for( i = 0; i < 256; i++ )
+	{
+		if( colorUsed[i] )
+		{
+			colorRemap[i] = m_CamoPatternNumColors;
+			m_CamoPatternNumColors++;
+		}
+	}
+	// remap the color to the beginning of the palette.
+	for( i = 0; i < indexImageSize; i++ )
+	{
+		m_pCamoPatternImage[i] = colorRemap[m_pCamoPatternImage[i]];
+		// hack
+//		m_pCamoPatternImage[i] = 0;
+	}
+}
+
+void CCamoMaterialProxy::GenerateRandomPointsInNormalizedCube( void )
+{
+	m_pointsInNormalizedBox = new Vector[m_CamoPatternNumColors];
+	if( !m_pointsInNormalizedBox )
+	{
+		m_pCamoTextureVar = NULL;
+		return;
+	}
+	
+	int i;
+	for( i = 0; i < m_CamoPatternNumColors; i++ )
+	{
+		m_pointsInNormalizedBox[i][0] = random->RandomFloat( m_SubBoundingBoxMin[0], m_SubBoundingBoxMax[0] );
+		m_pointsInNormalizedBox[i][1] = random->RandomFloat( m_SubBoundingBoxMin[1], m_SubBoundingBoxMax[1] );
+		m_pointsInNormalizedBox[i][2] = random->RandomFloat( m_SubBoundingBoxMin[2], m_SubBoundingBoxMax[2] );
+	}
+}
+
+IMaterial *CCamoMaterialProxy::GetMaterial()
+{
+	return m_pMaterial;
+}
+
+EXPOSE_INTERFACE( CCamoMaterialProxy, IMaterialProxy, "Camo" IMATERIAL_PROXY_INTERFACE_VERSION );