GTASource/game/shaders/CustomShaderEffectVehicle.cpp

//
// Filename:	CustomShaderEffectVehicle.h
// Description:	Takes care of all gta_vehicle shader variables (supports vehicle body colours);
// Written by:	Andrzej
//
//
//	07/10/2005	-	Andrzej:	- initial;
//	02/11/2005	-	Andrzej:	- body colours support added;
//	29/01/2007	-	Andrzej:	- Specular2Color support added;
//	12/03/2007	-	Andrzej:	- editable shader values for Jo added:
//	22/06/2007	-	Andrzej:	- storing original Specular added;
//	02/09/2007	-	Andrzej:	- burnout texture support added (burnout texture replaces dirt texture);
//	10/09/2007	-	Andrzej:	- tyre deform control added;
//	20/09/2007	-	Andrzej:	- bodycolor5 added;
//	12/10/2007	-	Andrzej:	- Editable Tire Inner Radius stuff added (__BANK only);
//
//
//
#include "system/nelem.h"
#include "grcore/effect_config.h"

// Framework headers
//#include "fwmaths/maths.h"
#include "fwscene/stores/fragmentstore.h"
#include "fwsys/timer.h"
#include "fwdrawlist/drawlistmgr.h"
#include "streaming/streamingengine.h"
#include "streaming/streaming.h"

// Game headers:
#include "CustomShaderEffectVehicle.h"
#include "camera/CamInterface.h"
#include "control/replay/replay.h"
#include "control/replay/ReplayExtensions.h"
#include "debug/debug.h"
#include "debug/DebugGlobals.h"		// gbDontDisplayDirtOnVehicles...
#include "game/weather.h"			// g_weather
#include "scene/Entity.h"
#include "modelinfo/ModelInfo.h"
#include "modelinfo/VehicleModelInfo.h"
#include "modelinfo/VehicleModelInfoColors.h"
#include "physics/physics.h" // for CPhysics::GetGlassTxdSlot
#include "renderer/DrawLists/drawlist.h"
#include "renderer/Lights/lights.h"
#include "shaders/shaderlib.h"
#include "vfx/misc/Coronas.h"
#include "vehicles/Vehicle.h"
#include "vehicles/wheel.h"
#if !__FINAL
	PARAM(novehicledirt, "Don't display vehicle dirt");
#endif


// #include "system/findsize.h"
// FindSize(CCustomShaderEffectVehicle); was 240 before license plate cleanup, now 156.
// FindSize(CCustomShaderEffectVehicleType); - 20 bytes.

//
//
// body colour remapping:
//
#define BODYCOLOR1		Vector3(2.0f, 1.0f, 1.0f)
#define BODYCOLOR2		Vector3(2.0f, 2.0f, 2.0f)
#define BODYCOLOR3		Vector3(2.0f, 3.0f, 3.0f)
#define BODYCOLOR4		Vector3(2.0f, 4.0f, 4.0f)
#define BODYCOLOR5		Vector3(2.0f, 5.0f, 5.0f)		// special color for interiors
#define BODYCOLOR6		Vector3(2.0f, 6.0f, 6.0f)		// special color for interiors
#define BODYCOLOR7		Vector3(2.0f, 7.0f, 7.0f)		// special color for interiors

#define DEFAULT_DIRTMODWET										(0.60f)		// default dirt mod intensity when et

// --- Globals ------------------------------------------------------------------
#if CSE_VEHICLE_EDITABLEVALUES
	bool	CCustomShaderEffectVehicle::ms_bEVEnabled				= FALSE;
	float	CCustomShaderEffectVehicle::ms_fEVSpecFalloff			= 100.0f;
	float	CCustomShaderEffectVehicle::ms_fEVSpecFresnel			= 0.75f;
	float	CCustomShaderEffectVehicle::ms_fEVSpecIntensity			= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVSpecTexTileUV			= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVSpec2Falloff			= 5.0f;
	float	CCustomShaderEffectVehicle::ms_fEVSpec2Intensity		= 0.0f;
	bool	CCustomShaderEffectVehicle::ms_bEVSpec2DirLerpOverride	= FALSE;
	float	CCustomShaderEffectVehicle::ms_fEVSpec2DirLerp			= 0.0f;
	float	CCustomShaderEffectVehicle::ms_fEVReflectivity			= 0.45f;
	float	CCustomShaderEffectVehicle::ms_fEVBumpiness				= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVDiffuseTexTileUV		= 8.0f;
	float	CCustomShaderEffectVehicle::ms_fEVEnvEffThickness		= 25.0f;
	float	CCustomShaderEffectVehicle::ms_fEVEnvEffScale			= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVEnvEffTexTileUV		= 8.0f;

	bool	CCustomShaderEffectVehicle::ms_fEVOverrideBodyColor		= FALSE;
	Vector3 CCustomShaderEffectVehicle::ms_fEVBodyColor				= Vector3(1.0f, 0.5f, 1.0f);
	bool	CCustomShaderEffectVehicle::ms_fEVOverrideDiffuseColorTint= FALSE;
	Vector3 CCustomShaderEffectVehicle::ms_fEVDiffuseColorTint		= Vector3(1.0f, 0.0f, 0.0f);
	float	CCustomShaderEffectVehicle::ms_fEVDiffuseColorTintAlpha = 0.5f;
	float	CCustomShaderEffectVehicle::ms_fEVDirtLevel				= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVDirtModDry			= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVDirtModWet			= DEFAULT_DIRTMODWET;
	s32		CCustomShaderEffectVehicle::ms_fEVDirtOrBurnout			= 1;
	Vector3	CCustomShaderEffectVehicle::ms_fEVDirtColor				= Vector3(59.0f/255.0f, 57.0f/255.0f, 52.0f/255.0f);	// dirtColor RGB=(59,57,52)

	// editable inner wheel radius stuff:
	bool	CCustomShaderEffectVehicle::ms_bEWREnabled			= FALSE;
	bool	CCustomShaderEffectVehicle::ms_bEWRTyreEnabled		= TRUE;
	float	CCustomShaderEffectVehicle::ms_fEWRInnerRadius		= 1.500f;

	// editables for sunglare:
	bool	CCustomShaderEffectVehicle::ms_bEVSunGlareEnabled			= FALSE;
	float	CCustomShaderEffectVehicle::ms_fEVSunGlareDistMin			= 65.0f;
	float	CCustomShaderEffectVehicle::ms_fEVSunGlareDistMax			= 75.0f;
	u32		CCustomShaderEffectVehicle::ms_nEVSunGlarePow				= 1;
	float	CCustomShaderEffectVehicle::ms_fEVSunGlareSpriteSize		= 0.55f;
	float	CCustomShaderEffectVehicle::ms_fEVSunGlareSpriteZShiftScale	= 0.2f;
	float	CCustomShaderEffectVehicle::ms_fEVSunGlareHdrMult			= 8.0f;
	
	Vector4	CCustomShaderEffectVehicle::ms_fEVLetterIndex1					= Vector4(10, 21, 10, 23);
	Vector4	CCustomShaderEffectVehicle::ms_fEVLetterIndex2					= Vector4(63, 63, 62, 0);
	Vector2	CCustomShaderEffectVehicle::ms_fEVLetterSize					= Vector2(1.0f / 16.0f, 1.0f / 4.0f);
	Vector2	CCustomShaderEffectVehicle::ms_fEVNumLetters					= Vector2(16.0f,4.0f);
	Vector4	CCustomShaderEffectVehicle::ms_fEVLicensePlateFontExtents		= Vector4(0.043f, 0.38f, 0.945f, 0.841f);
	Vector4	CCustomShaderEffectVehicle::ms_fEVLicensePlateFontTint			= Vector4(1.0f, 1.0f, 1.0f, 0.0f);
	float	CCustomShaderEffectVehicle::ms_fEVFontNormalScale				= 1.0f;
	float	CCustomShaderEffectVehicle::ms_fEVDistMapCenterVal				= 0.5f;
	Vector4	CCustomShaderEffectVehicle::ms_fEVDistEpsilonScaleMin			= Vector4(1.0f, 1.0f, 0.0f, 0.0f);
	Vector3	CCustomShaderEffectVehicle::ms_fEVFontOutlineMinMaxDepthEnabled	= Vector3(0.475f, 0.5, 0.0f);
	Vector3	CCustomShaderEffectVehicle::ms_fEVFontOutlineColor				= Vector3(0.0f, 0.0f, 0.0f);

	float	CCustomShaderEffectVehicle::ms_fEVBurnoutSpeed					= 0.01f;	// minimum increase step is 1/255
#endif //CSE_VEHICLE_EDITABLEVALUES...
#if __DEV
	s32		CCustomShaderEffectVehicle::ms_nForceColorCars		= 2;
#endif

#if USE_DISKBRAKEGLOW
	#define DISKBRAKEGLOW_V2 0 
	#define DISKBRAKEGLOW_DEBUG_TEXT 0
	#define DISKBRAKEGLOW_DEBUG_TEXT_FULLWHEELDETAIL 0
	#define DISKBRAKEGLOW_DEBUG_SHADER 0

#if DISKBRAKEGLOW_V2	
	static dev_float g_fDiskBrake_MaxHeatingRate = 3.0f;
	static dev_float g_fDiskBrake_CoolingRate = 0.15f;
	static dev_float g_fDiskBrake_SpeedCap = 80.0f/3.6f; // From kmh-1 to ms-1
#else // DISKBRAKEGLOW_V2
	static dev_float g_fDiskBrake_CoolingRate = 0.15f;
	static dev_float g_fDiskBrake_TempMagicNumber = 1.5f;
	static dev_float g_fDiskBrake_SpeedCap = 70.0f/3.6f; // From kmh-1 to ms-1
#endif // DISKBRAKEGLOW_V2
	static dev_float g_fDiskBrake_EngineAge = 5.0f * 60.0f * 1000.0f;
#endif // USE_DISKBRAKEGLOW

//
// global burnout texture for vehicles:
//
//
#define VEHICLE_GENERIC_BURNOUT_TEXNAME			"vehicle_generic_burnt_out"
#define VEHICLE_GENERIC_BURNOUT_INT_TEXNAME		"vehicle_generic_burnt_int"
#define VEHICLE_GENERIC_BURNOUT_TRUCK_TEXNAME	"vehicle_generic_burnt_out_truck"

// Default initialization to zero, which means NULL
grcTextureIndex CCustomShaderEffectVehicleType::ms_pBurnoutTexture;
grcTextureIndex CCustomShaderEffectVehicleType::ms_pBurnoutIntTexture;
grcTextureIndex CCustomShaderEffectVehicleType::ms_pBurnoutTruckTexture;
s32				CCustomShaderEffectVehicleType::ms_nBurnoutTruckTextureRef	= 0;

#if VEHICLE_SUPPORT_PAINT_RAMP
#define VEHICLE_PAINT_RAMP_DISABLED_VALUE (-1.0f)
static strLocalIndex s_RampTxdId;
#if __BANK
static bool s_RampDiffuseEnabled = true;
static bool s_RampSpecularEnabled = true;
#endif

void CCustomShaderEffectVehicle::LoadRampTxd()
{
	s_RampTxdId = g_TxdStore.FindSlot(strStreamingObjectName("vehicle_paint_ramps"));
	if(s_RampTxdId.IsValid())
	{
		CStreaming::LoadObject(s_RampTxdId, g_TxdStore.GetStreamingModuleId());
		g_TxdStore.AddRef(s_RampTxdId, REF_OTHER);
	}
}

void CCustomShaderEffectVehicle::UnloadRampTxd()
{
	if (s_RampTxdId.IsValid())
	{
		g_TxdStore.RemoveRef(s_RampTxdId, REF_OTHER);
		s_RampTxdId = strLocalIndex();
	}
}

fwTxd * CCustomShaderEffectVehicle::GetRampTxd()
{
	fwTxd *result = s_RampTxdId.IsValid() ? g_TxdStore.Get(s_RampTxdId) : 0;
	return result;
}

#if __BANK
static bool s_DebugRampTextureEnabled = false;
static char s_DebugRampTexturePath[256] = { "C:/Temp/vehicle_paint_ramp" };
static grcTexture* s_DebugRampTexture = 0;
static void ReloadDebugRampTexture()
{
	if(s_DebugRampTextureEnabled)
	{
		sysMemStartTemp();
		grcImage* img = grcImage::LoadDDS(s_DebugRampTexturePath);
		if(!img)
		{
			img = grcImage::LoadJPEG(s_DebugRampTexturePath);
		}
		sysMemEndTemp();

		if(img)
		{
			grcTextureFactory::TextureCreateParams params(grcTextureFactory::TextureCreateParams::VIDEO, grcTextureFactory::TextureCreateParams::TILED);
			s_DebugRampTexture = grcTextureFactory::GetInstance().Create(img, &params);

			sysMemStartTemp();
			img->Release();
			img = 0;
			sysMemEndTemp();
		}
	}
}
#endif
#endif

//
//
//
//
CCustomShaderEffectVehicleType* CCustomShaderEffectVehicleType::Create(rmcDrawable *pDrawable, CVehicleModelInfo *pVehicleMI, grmShaderGroup *pClonedShaderGroup)
{
	Assert(pDrawable);

	// Initialize structure to all zero.
	CCustomShaderEffectVehicleType *pType = rage_new CCustomShaderEffectVehicleType();

	// BS#2551385: vehicle mods: use cloned shaderGroup (if exists) rather than drawable's original shaderGroup:
	grmShaderGroup* shaderGroup	= pClonedShaderGroup? pClonedShaderGroup : &pDrawable->GetShaderGroup();
	const s32 shaderCount		= shaderGroup->GetCount();
	atArray<CCustomShaderEffectVehicleType::structDiffColEffect>	tmpTabDiffCol(0, shaderCount);		// temp table to gather all variable info's
	atArray<CCustomShaderEffectVehicleType::structSpecColEffect>	tmpTabSpecularCol(0, shaderCount);
	atArray<CCustomShaderEffectVehicleType::structDirtTexEffect>	tmpTabDirtTex(0, shaderCount);
	atArray<CCustomShaderEffectVehicleType::structTex2Effect>		tmpTabTex2(0, shaderCount);

	pType->m_bHasBodyColor1 =
	pType->m_bHasBodyColor2 =
	pType->m_bHasBodyColor3 =
	pType->m_bHasBodyColor4 =
	pType->m_bHasBodyColor5 =
	pType->m_bHasBodyColor6 =
	pType->m_bHasBodyColor7 = false;

	
	bool bFoundEmissiveMult		= false;
	pType->m_DefEmissiveMult	= 1.0f;

	if(pVehicleMI)
	{	
		const u32 vehNameHash = pVehicleMI->GetModelNameHash();
		if(	(vehNameHash == 0xE7D2A16E)	||	// "shotaro"
			(vehNameHash == 0x3AF76F4A)	||	// "voltic2"
			(vehNameHash == 0xE6E967F8)	||	// "patriot2"
			(vehNameHash == 0x93F09558)	)	// "deathbike2"
		{
			// enable only for shotaro & voltic2:
			Assert(pType->m_idVarEmissiveMult != grmsgvNONE);
		}
		else
		{
			// disable for everything else
			pType->m_idVarEmissiveMult = grmsgvNONE;
		}
	}
	else
	{
		// disable for everything else
		pType->m_idVarEmissiveMult = grmsgvNONE;
	}


	for(s32 i=0; i<shaderCount; i++)
	{
		grmShader *pShader = shaderGroup->GetShaderPtr(i);
		Assert(pShader);
		// grcEffect *pEffect = &pShader->GetEffect();

		u8 colorIdx = 255;	 // invalid value

		// 1. DiffuseColor:
		grcEffectVar idvarDifCol = pShader->LookupVar("DiffuseColor", FALSE);
		if(idvarDifCol)
		{
			Vector3					diffCol;
			pShader->GetVar(idvarDifCol, diffCol);

			Assert((int)idvarDifCol < 256);	// must fit into u8
			Assert(i < 256);			// must fit into u8

			CCustomShaderEffectVehicleType::structDiffColEffect dcEffect;
			dcEffect.idvarDiffColor = (u8)idvarDifCol;
#if VEHICLE_SUPPORT_PAINT_RAMP
			dcEffect.idvarDiffuseRampTexture = (u8)pShader->LookupVar("DiffuseRampTexture", FALSE);
			dcEffect.idvarSpecularRampTexture = (u8)pShader->LookupVar("SpecularRampTexture", FALSE);
			dcEffect.idvarDiffuseSpecularRampEnabled = (u8)pShader->LookupVar("matDiffuseSpecularRampEnabled", FALSE);
#endif
			dcEffect.shaderIdx = (u8)i;

			// find color mapping
			if(diffCol == BODYCOLOR1)
			{
				dcEffect.colorIdx		= colorIdx = 0;
				pType->m_bHasBodyColor1 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			else if(diffCol == BODYCOLOR2)
			{
				dcEffect.colorIdx		= colorIdx = 1;
				pType->m_bHasBodyColor2 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			else if(diffCol == BODYCOLOR3)
			{
				dcEffect.colorIdx		= colorIdx = 2;
				pType->m_bHasBodyColor3 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			else if(diffCol == BODYCOLOR4)
			{
				dcEffect.colorIdx		= colorIdx = 3;
				pType->m_bHasBodyColor4 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			else if(diffCol == BODYCOLOR5)
			{
				dcEffect.colorIdx		= colorIdx = 4;
				pType->m_bHasBodyColor5 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			else if(diffCol == BODYCOLOR6)
			{
				dcEffect.colorIdx		= colorIdx = 5;
				pType->m_bHasBodyColor6 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			else if(diffCol == BODYCOLOR7)
			{
				dcEffect.colorIdx		= colorIdx = 6;
				pType->m_bHasBodyColor7 = true;
				tmpTabDiffCol.Append() = dcEffect;
			}
			
		}//if(idvarDifCol)...
		
		// 2. Specular values: Intensity, Falloff and Fresnel:
		grcEffectVar idvarSpecInt		= pShader->LookupVar("SpecularColor", FALSE);
		grcEffectVar idvarSpecFalloff	= pShader->LookupVar("Specular", FALSE);
		grcEffectVar idvarSpecFresnel	= pShader->LookupVar("Fresnel", FALSE);
		
		if(idvarSpecInt || idvarSpecFalloff || idvarSpecFresnel)
		{
			CCustomShaderEffectVehicleType::structSpecColEffect	&dcEffect = tmpTabSpecularCol.Append();

			dcEffect.idvarSpecInt		=
			dcEffect.idvarSpecFalloff	= 
			dcEffect.idvarSpecFresnel	= grcevNONE;

			if(idvarSpecInt)
			{
				Assert((int)idvarSpecInt < 256);	// must fit into u8
				dcEffect.idvarSpecInt		= (u8)idvarSpecInt;

				float originalSpecInt=1.0f;
				pShader->GetVar(idvarSpecInt, originalSpecInt);
				dcEffect.origSpecInt		= originalSpecInt;
			}

			if(idvarSpecFalloff)
			{
				Assert((int)idvarSpecFalloff < 256);	// must fit into u8
				dcEffect.idvarSpecFalloff	= (u8)idvarSpecFalloff;

				float originalSpecFalloff=1.0f;
				pShader->GetVar(idvarSpecFalloff, originalSpecFalloff);
				dcEffect.origSpecFalloff	= originalSpecFalloff;
			}

			if(idvarSpecFresnel)
			{
				Assert((int)idvarSpecFresnel < 256);	// must fit into u8
				dcEffect.idvarSpecFresnel	= (u8)idvarSpecFresnel;

				float originalSpecFresnel=1.0f;
				pShader->GetVar(idvarSpecFresnel, originalSpecFresnel);
				dcEffect.origSpecFresnel	= originalSpecFresnel;
			}

			Assert(i < 256);			// must fit into u8
			dcEffect.shaderIdx			= (u8)i;
			Assert((int)colorIdx < 256);		// must fit into u8
			dcEffect.colorIdx			= (u8)colorIdx;
		}

		// 3. Dirt texture:
		bool bDirtIsInterior = false;
		grcEffectVar idvarDirtTex = pShader->LookupVar("DirtTex", FALSE);
		if(!idvarDirtTex)
		{	// replace main diffuse tex when dirt texture not present (interiors, wheels, etc.):
			idvarDirtTex	= pShader->LookupVar("DiffuseTex", FALSE);
			bDirtIsInterior = true;
		}

		// don't setup burnout texture for badges & cutout:
		if(idvarDirtTex)
		{
			const char *pShaderName = pShader->GetName();
			if(pShaderName)
			{
				if( (!strcmp("vehicle_badges", pShaderName))	||
					(!strcmp("vehicle_cutout", pShaderName))	)
				{
					idvarDirtTex = grcevNONE;
				}
			}
		}

		// tentative "patch" for B*2275234, B*2137345 and B*2272964:
		Assertf((int(idvarDirtTex) <= 255), "Vehicle: %s: idvarDirtTex is far too big!", pVehicleMI->GetModelName());
		if(int(idvarDirtTex) > 255)
		{
			idvarDirtTex = grcevNONE;
		}

		if(idvarDirtTex)
		{
			CCustomShaderEffectVehicleType::structDirtTexEffect		&dcEffect = tmpTabDirtTex.Append();
			grcTexture *pOrigDirtTex=NULL;
			pShader->GetVar(idvarDirtTex, pOrigDirtTex);
			#if __ASSERT
				if(pOrigDirtTex)
				{	// make sure it's not texture reference:
					Assert(pOrigDirtTex->GetResourceType()!=grcTexture::REFERENCE);
				}
			#endif //__ASSERT...

			Assert((int)idvarDirtTex < 256);	// must fit into u8
			Assert(i < 256);			// must fit into u8

			strStreamingEngine::AddRefByPtr(pOrigDirtTex, REF_OTHER);

			dcEffect.pOrigDirtTex		= pOrigDirtTex;
			dcEffect.idvarDirtTex		= (u8)idvarDirtTex;
			dcEffect.shaderIdx			= (u8)i;
			dcEffect.bIsInterior		= bDirtIsInterior;
		}

		grcEffectVar idvarDirtCol = pShader->LookupVar("DirtColor", FALSE);
		if(idvarDirtCol)
		{
			Vector3 origDirtCol;
			pShader->GetVar(idvarDirtCol, origDirtCol);
			pType->m_DefDirtColor.Setf(origDirtCol.x, origDirtCol.y, origDirtCol.z, 1.0f);
		}

		// 4. overlay texture:
		grcEffectVar idvarTex2 = pShader->LookupVar("DiffuseTex2", FALSE);
		if(idvarTex2)
		{
			CCustomShaderEffectVehicleType::structTex2Effect		&dcEffect = tmpTabTex2.Append();
			grcTexture *pOrigTex2=NULL;
			pShader->GetVar(idvarTex2, pOrigTex2);
			#if __ASSERT
				if(pOrigTex2)
				{	// make sure it's not texture reference:
					Assert(pOrigTex2->GetResourceType()!=grcTexture::REFERENCE);
				}
			#endif //__ASSERT...

			Assert((int)idvarTex2 < 256);	// must fit into u8
			Assert(i < 256);				// must fit into u8

			strStreamingEngine::AddRefByPtr(pOrigTex2, REF_OTHER);

			dcEffect.pOrigTex2			= pOrigTex2;
			dcEffect.idvarTex2			= (u8)idvarTex2;
			dcEffect.shaderIdx			= (u8)i;
		}


		if(pType->m_idVarEmissiveMult)
		{
			grcEffectVar idvarEmissiveMult = pShader->LookupVar("EmissiveMultiplier", FALSE);
			if(idvarEmissiveMult)
			{
				float fEmissiveMult;
				pShader->GetVar(idvarEmissiveMult, fEmissiveMult);

				if(!bFoundEmissiveMult)
				{
					bFoundEmissiveMult = true;
					pType->m_DefEmissiveMult = fEmissiveMult;
				}
				else
				{
					Assertf(pType->m_DefEmissiveMult == fEmissiveMult, "%s: EmissiveMultiplier (=%.2f) is not the same for all parts of the vehicle: found %.2f.",pVehicleMI->GetModelName(), pType->m_DefEmissiveMult, fEmissiveMult);
				}
			}
		}

	}// for(s32 i=0; i<shaderCount; i++)...

	if(pVehicleMI && (!pVehicleMI->GetAllowBodyColorMapping()))
	{
		// block color mapping for scripts if requested
		pType->m_bHasBodyColor1 =
		pType->m_bHasBodyColor2 =
		pType->m_bHasBodyColor3 =
		pType->m_bHasBodyColor4 =
		pType->m_bHasBodyColor5 =
		pType->m_bHasBodyColor6 =
		pType->m_bHasBodyColor7 = false;
	}

	pType->m_DiffColEffect = tmpTabDiffCol;
	#if __ASSERT
		extern char* CCustomShaderEffectBase_EntityName;
		Assertf(pType->m_DiffColEffect.GetCount() > 0, "BS#124925: %s (drawable=%p, shaderGroup=%p): DiffColEffect array is empty! This vehicle's materials do not have a valid color variation.  Andrzej would love to see this assert.", CCustomShaderEffectBase_EntityName, pDrawable, shaderGroup);
	#endif
	pType->m_SpecColEffect	= tmpTabSpecularCol;
	pType->m_DirtTexEffect	= tmpTabDirtTex;
	pType->m_Tex2Effect		= tmpTabTex2;

	// burnout truck texture setup:
	// 1. vehshare_truck is dynamically streamed in and is usually parent to vehicle's main txd
	// 2. normal vehicle txd dependency:	vehicle_txd <- vehshare
	// 3. truck txd structure dependency:	vehicle_txd <- vehshare_truck <- vehshare
	Assert(CSystem::IsThisThreadId(SYS_THREAD_UPDATE));	// truck burnout tex referencing allowed only on update thread

	pType->m_bHasTruckTex = false;
	if(false && pVehicleMI) // separate burnout tex for trucks has been blocked - they share burnout tex with everybody else now
	{
		const strLocalIndex txdIdx = strLocalIndex(pVehicleMI->GetAssetParentTxdIndex());
		if(txdIdx != -1)
		{
			const strLocalIndex vehshareTxdIdx = strLocalIndex(pVehicleMI->GetCommonTxd());	// vehshare is always resident at index 0
			Assert(vehshareTxdIdx != -1);
			const strLocalIndex parentTxdIdx = g_TxdStore.GetParentTxdSlot(txdIdx);

			// assume first level parent to be vehshare_truck:
			if( (parentTxdIdx!=-1) && (parentTxdIdx!=vehshareTxdIdx) )
			{
				const strLocalIndex vehshareTruckTxdIdx = parentTxdIdx;
				grcTexture *burnoutTruckTex = g_TxdStore.Get(vehshareTruckTxdIdx)->Lookup(VEHICLE_GENERIC_BURNOUT_TRUCK_TEXNAME);
				Assert(burnoutTruckTex);
			
				if(ms_nBurnoutTruckTextureRef)
				{	// same ptr as previously fetched?
					Assert(ms_pBurnoutTruckTexture == burnoutTruckTex);
				}
				else
				{	
					// update static shared pointer with burnouttrucktex ptr:
					ms_pBurnoutTruckTexture = burnoutTruckTex;
				}
				ms_nBurnoutTruckTextureRef++;
			
				pType->m_bHasTruckTex = true;
			}
		}
	}

	return pType;
}// end of CCustomShaderEffectVehicle::Create()...


//
//
// Recreates Type structures using texture ptr:
// - m_DirtTexEffect;
//
bool CCustomShaderEffectVehicleType::Recreate(rmcDrawable *pDrawable, CVehicleModelInfo* /*pVehicleMI*/)
{
	Assert(pDrawable);

	grmShaderGroup* shaderGroup	= &pDrawable->GetShaderGroup();
	const s32 shaderCount		= shaderGroup->GetCount();
	atArray<CCustomShaderEffectVehicleType::structDirtTexEffect>	tmpTabDirtTex(0, shaderCount);

	for(s32 i=0; i<shaderCount; i++)
	{
		grmShader *pShader = shaderGroup->GetShaderPtr(i);
		Assert(pShader);

		// 3. Dirt texture:
		bool bDirtIsInterior = false;
		grcEffectVar idvarDirtTex = pShader->LookupVar("DirtTex", FALSE);
		if(!idvarDirtTex)
		{	// replace main diffuse tex when dirt texture not present (interiors, wheels, etc.):
			idvarDirtTex	= pShader->LookupVar("DiffuseTex", FALSE);
			bDirtIsInterior = true;
		}

		// don't setup burnout texture for badges:
		if(idvarDirtTex)
		{
			const char *pShaderName = pShader->GetName();
			if(pShaderName && !strcmp("vehicle_badges", pShaderName))
			{
				idvarDirtTex = grcevNONE;
			}
		}

		if(idvarDirtTex)
		{
			CCustomShaderEffectVehicleType::structDirtTexEffect		&dcEffect = tmpTabDirtTex.Append();
			grcTexture *pOrigDirtTex=NULL;
			pShader->GetVar(idvarDirtTex, pOrigDirtTex);
			#if __ASSERT
				if(pOrigDirtTex)
				{	// make sure it's not texture reference:
					Assert(pOrigDirtTex->GetResourceType()!=grcTexture::REFERENCE);
				}
			#endif //__ASSERT...

			Assert((int)idvarDirtTex < 256);	// must fit into u8
			Assert(i < 256);			// must fit into u8

			strStreamingEngine::AddRefByPtr(pOrigDirtTex, REF_OTHER);

			dcEffect.pOrigDirtTex		= pOrigDirtTex;
			dcEffect.idvarDirtTex		= (u8)idvarDirtTex;
			dcEffect.shaderIdx			= (u8)i;
			dcEffect.bIsInterior		= bDirtIsInterior;
		}

	}// for(s32 i=0; i<shaderCount; i++)...


bool bRecreate=true;
	// check if new dirtTexEffect tab contains burnout textures
	// (if yes, then drawable was NOT re-streamed (burnout textures are only set by CSE code)
	// and CSEType doesn't need to be recreated):
	Assert(this->m_DirtTexEffect.GetCount()==tmpTabDirtTex.GetCount());
	const u32 count = tmpTabDirtTex.GetCount();
	for(u32 i=0; i<count; i++)
	{
		CCustomShaderEffectVehicleType::structDirtTexEffect *newPtr = &tmpTabDirtTex[i];
	#if __ASSERT
		CCustomShaderEffectVehicleType::structDirtTexEffect *oldPtr = &this->m_DirtTexEffect[i];
		Assert(oldPtr->idvarDirtTex	== newPtr->idvarDirtTex);
		Assert(oldPtr->shaderIdx	== newPtr->shaderIdx);
		Assert(oldPtr->bIsInterior	== newPtr->bIsInterior);
	#endif

		grcTexture *burnoutTex = m_bHasTruckTex? CCustomShaderEffectVehicleType::ms_pBurnoutTruckTexture : CCustomShaderEffectVehicleType::ms_pBurnoutTexture;
		burnoutTex = newPtr->bIsInterior? CCustomShaderEffectVehicleType::ms_pBurnoutIntTexture : burnoutTex;
		if(newPtr->pOrigDirtTex == burnoutTex)
		{
			bRecreate = false;	// burnout tex detected: drawable was NOT re-streamed
		}
	}

	atArray<CCustomShaderEffectVehicleType::structDirtTexEffect> *const removeRefs = bRecreate? &this->m_DirtTexEffect : &tmpTabDirtTex;
	for(u32 i=0; i<count; i++)
	{
		grcTexture *const pTex = (*removeRefs)[i].pOrigDirtTex;
		(*removeRefs)[i].pOrigDirtTex = NULL;
		strStreamingEngine::RemoveRefByPtr(pTex, REF_OTHER);
	}

	if(bRecreate)
	{
		this->m_DirtTexEffect = tmpTabDirtTex;
	}

	return(TRUE);
}// end of CCustomShaderEffectVehicleType::Recreate()...

//
// restores drawable's shaderVars values to their original (initial) state:
// - to be executed right before MasterCSE for modelInfo is destroyed;
// - note: uses RecordSetVar() API (directly modifies InstanceData memory without drawablespu, etc.);
// - that way if drawable is NOT reloaded from disk by streaming and directly reused for MasterCSE creation
//   it makes it possible to correctly initialise/create given MasterCSE
//   (which may rely on shaderVar values - e.g. CSEVehicle);
//
bool CCustomShaderEffectVehicleType::RestoreModelInfoDrawable(rmcDrawable *pDrawable)
{
	Assert(pDrawable);
	Assert(CSystem::IsThisThreadId(SYS_THREAD_UPDATE));	// allowed on Update Thread only

	if(!pDrawable)
		return(false);

	grmShaderGroup* pShaderGroup	= &pDrawable->GetShaderGroup();
	Assert(pShaderGroup);
	const u32 shaderCount			= pShaderGroup->GetCount();

	// restore "DiffuseColor":
	const u32 count = m_DiffColEffect.GetCount();
	if(count)
	{
		Vector3 defaultDiffuseCol[7] =
		{
			BODYCOLOR1,	// 0
			BODYCOLOR2,	// 1
			BODYCOLOR3,	// 2
			BODYCOLOR4,	// 3
			BODYCOLOR5,	// 4
			BODYCOLOR6,	// 5
			BODYCOLOR7	// 6
		};

		for(u32 i=0; i<count; i++)
		{
			CCustomShaderEffectVehicleType::structDiffColEffect *ptr = &m_DiffColEffect[i];
			pShaderGroup->GetShader(ptr->shaderIdx).RecordSetVar((grcEffectVar)ptr->idvarDiffColor, defaultDiffuseCol[ptr->colorIdx]);

#if VEHICLE_SUPPORT_PAINT_RAMP
			if(ptr->idvarDiffuseRampTexture)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffuseRampTexture, const_cast<grcTexture*>(grcTexture::NoneBlack));
			}

			if(ptr->idvarSpecularRampTexture)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecularRampTexture, const_cast<grcTexture*>(grcTexture::NoneBlack));
			}

			if(ptr->idvarDiffuseSpecularRampEnabled)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffuseSpecularRampEnabled, VEHICLE_PAINT_RAMP_DISABLED_VALUE);
			}
#endif
		}
	}

	// restore original "SpecularColor":
	const s32 specCount = m_SpecColEffect.GetCount();
	for(u32 i=0; i<specCount; i++)
	{
		CCustomShaderEffectVehicleType::structSpecColEffect *ptr = &m_SpecColEffect[i];
		if(ptr->idvarSpecInt)
			pShaderGroup->GetShader(ptr->shaderIdx).RecordSetVar((grcEffectVar)ptr->idvarSpecInt, float(ptr->origSpecInt));

		if(ptr->idvarSpecFalloff)
			pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFalloff, float(ptr->origSpecFalloff));

		if(ptr->idvarSpecFresnel)
			pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFresnel, float(ptr->origSpecFresnel));
	}

	// restore original DirtTexture:
	const u32 dirtTexCount = m_DirtTexEffect.GetCount();
	for(u32 i=0; i<dirtTexCount; i++)
	{
		CCustomShaderEffectVehicleType::structDirtTexEffect *ptr = &m_DirtTexEffect[i];
	#if __PPU
		// Hack: manually clear FLAG_SET_FROM_SPU to shut up assert in RecordSetVar():
		grcInstanceData& data = pShaderGroup->GetShader(ptr->shaderIdx).GetInstanceData();
		data.Flags &= ~grcInstanceData::FLAG_SET_FROM_SPU;
	#endif
		pShaderGroup->GetShader(ptr->shaderIdx).RecordSetVar((grcEffectVar)ptr->idvarDirtTex, (grcTexture*)ptr->pOrigDirtTex);
	}

	for(u32 i=0; i<shaderCount; i++)
	{
		grmShader *pShader = pShaderGroup->GetShaderPtr(i);
		Assert(pShader);

		// restore DirtColor:
		grcEffectVar idvarDirtCol = pShader->LookupVar("DirtColor", FALSE);
		if(idvarDirtCol)
		{
			Vector3 origDirtCol(VEC3V_TO_VECTOR3(m_DefDirtColor.GetRGB()));
			pShader->RecordSetVar(idvarDirtCol, origDirtCol);
		}

		// restore Emissive Multiplier:
		if(m_idVarEmissiveMult)
		{
			grcEffectVar idvarEmissiveMult = pShader->LookupVar("EmissiveMultiplier", FALSE);
			if(idvarEmissiveMult)
			{
				pShader->RecordSetVar(idvarEmissiveMult, m_DefEmissiveMult);
			}
		}
	}

	// restore overlay texture:
	const u32 tex2Count = m_Tex2Effect.GetCount();
	for(u32 i=0; i<tex2Count; i++)
	{
		CCustomShaderEffectVehicleType::structTex2Effect *ptr = &m_Tex2Effect[i];
	#if __PPU
		// Hack: manually clear FLAG_SET_FROM_SPU to shut up assert in RecordSetVar():
		grcInstanceData& data = pShaderGroup->GetShader(ptr->shaderIdx).GetInstanceData();
		data.Flags &= ~grcInstanceData::FLAG_SET_FROM_SPU;
	#endif
		pShaderGroup->GetShader(ptr->shaderIdx).RecordSetVar((grcEffectVar)ptr->idvarTex2, (grcTexture*)ptr->pOrigTex2);
	}

	return(true);
}// end of CCustomShaderEffectVehicle::RestoreDrawable()...


//
//
//
//
CCustomShaderEffectVehicleType::~CCustomShaderEffectVehicleType()
{
	Assert(CSystem::IsThisThreadId(SYS_THREAD_UPDATE));	// truck burnout tex referencing allowed only on update thread

	if(this->m_bHasTruckTex)
	{
		Assert(ms_pBurnoutTruckTexture);	// must be valid
		ms_nBurnoutTruckTextureRef--;
		Assert(ms_nBurnoutTruckTextureRef>=0);
		if(ms_nBurnoutTruckTextureRef==0)
		{
			ms_pBurnoutTruckTexture = NULL;
		}
	}

	const u32 dirtTexCount = m_DirtTexEffect.GetCount();
	for(u32 i=0; i<dirtTexCount; i++)
	{
		grcTexture *const pTex = this->m_DirtTexEffect[i].pOrigDirtTex;
		this->m_DirtTexEffect[i].pOrigDirtTex = NULL;
		strStreamingEngine::RemoveRefByPtr(pTex, REF_OTHER);
	}

	const u32 tex2Count = m_Tex2Effect.GetCount();
	for(u32 i=0; i<tex2Count; i++)
	{
		grcTexture *const pTex2 = this->m_Tex2Effect[i].pOrigTex2;
		this->m_Tex2Effect[i].pOrigTex2 = NULL;
		strStreamingEngine::RemoveRefByPtr(pTex2, REF_OTHER);
	}
}


//
//
//
//
inline u8 VehShaderGroupLookupVar(grmShaderGroup *pShaderGroup, const char *name, bool mustExist)
{
	grmShaderGroupVar varID = pShaderGroup->LookupVar(name, mustExist);
	Assert((int)varID < 256);	// must fit into u8
	return (u8)varID;
}

inline u8 VehEffectLookupGlobalVar(const char *name, bool mustExist)
{
	grcEffectGlobalVar  varID = grcEffect::LookupGlobalVar(name, mustExist);
	Assert((int)varID < 256);	// must fit into u8
	return (u8)varID;
}


//
//
// initializes all instances of the effect class;
// to be called once, when "master" class is created;
//
bool CCustomShaderEffectVehicleType::Initialise(rmcDrawable *pDrawable)
{
	return Initialise(pDrawable, NULL);
}

bool CCustomShaderEffectVehicleType::Initialise(rmcDrawable *pDrawable, grmShaderGroup *pClonedShaderGroup)
{
	Assert(pDrawable);

	// BS#2551385: vehicle mods: use cloned shaderGroup (if exists) rather than drawable's original shaderGroup:
	grmShaderGroup* pShaderGroup= pClonedShaderGroup? pClonedShaderGroup : &pDrawable->GetShaderGroup();
	Assert(pShaderGroup);

	m_idVarDirtLevelMod			= VehShaderGroupLookupVar(pShaderGroup, "DirtLevelMod",	FALSE);
	m_idVarDirtColor			= VehShaderGroupLookupVar(pShaderGroup, "DirtColor",	FALSE);

	m_idVarSpec2Color			= VehShaderGroupLookupVar(pShaderGroup, "Specular2Color",	FALSE);
	m_idVarDiffuse2Color		= VehShaderGroupLookupVar(pShaderGroup, "DiffuseColor2",	FALSE);
	m_idVarDiffuseColorTint		= VehShaderGroupLookupVar(pShaderGroup, "DiffuseColorTint",	FALSE);
#if USE_DISKBRAKEGLOW
	m_idVarDiskBrakeGlow		= VehShaderGroupLookupVar(pShaderGroup, "DiskBrakeGlow",FALSE);
#endif

	// headlights
	m_idVarDimmer				= VehShaderGroupLookupVar(pShaderGroup, "dimmerSetPacked", FALSE);


	// tyre deformation on/off control:
	m_idVarTyreDeformSwitchOn	= VehEffectLookupGlobalVar("tyreDeformSwitchOn", TRUE);

	// vehicle deformation
#if USE_GPU_VEHICLEDEFORMATION
	m_idVarDamageSwitchOn	= VehEffectLookupGlobalVar("switchOn",	TRUE);
	m_idVarDamageTex		= VehShaderGroupLookupVar(pShaderGroup, "damagetexture",	false);
	m_idVarBoundRadius		= VehShaderGroupLookupVar(pShaderGroup, "BoundRadius",		false);
	m_idVarDamageMult		= VehShaderGroupLookupVar(pShaderGroup, "DamageMultiplier",	false);
	m_idVarOffset			= VehShaderGroupLookupVar(pShaderGroup, "DamageTextureOffset", false);
	m_idVarDamagedFrontWheelOffsets = VehShaderGroupLookupVar(pShaderGroup, "DamagedWheelOffsets", false);
#if __BANK
	m_idVarDebugDamageMap	= VehShaderGroupLookupVar(pShaderGroup, "bDebugDisplayDamageMap",	false);
	m_idVarDebugDamageMult	= VehShaderGroupLookupVar(pShaderGroup, "bDebugDisplayDamageScale",	false);
#endif
#endif

	m_idVarDiffuseTex2		= VehShaderGroupLookupVar(pShaderGroup, "DiffuseTex2", false);
	m_idVarDiffuseTex3		= VehShaderGroupLookupVar(pShaderGroup, "DiffuseTex3", false);
	m_idVarTrackAnimUV		= VehShaderGroupLookupVar(pShaderGroup, "TrackAnimUV0", FALSE);
	m_idVarTrack2AnimUV		= VehShaderGroupLookupVar(pShaderGroup, "Track2AnimUV0", FALSE);
	m_idVarTrackAmmoAnimUV	= VehShaderGroupLookupVar(pShaderGroup, "TrackAmmoAnimUV0", FALSE);
 	m_idVarEnvEffScale		= VehShaderGroupLookupVar(pShaderGroup, "envEffScale0", FALSE);
	m_idVarEmissiveMult		= VehShaderGroupLookupVar(pShaderGroup, "EmissiveMultiplier", false);

	// Just spew how much space it *would* take...
	// pShaderGroup->Clone(NULL);
	// Displayf("...and the rest of the object is %u bytes",Size());

	m_idLicensePlateBgTex		= VehShaderGroupLookupVar(pShaderGroup, "PlateBgTex", false);
	m_idLicensePlateBgNormTex	= VehShaderGroupLookupVar(pShaderGroup, "PlateBgBumpTex", false);
	m_idLicensePlateFontColor	= VehShaderGroupLookupVar(pShaderGroup, "LicensePlateFontTint", false);
	m_idLicensePlateText1		= VehShaderGroupLookupVar(pShaderGroup, "LetterIndex1", false);
	m_idLicensePlateText2		= VehShaderGroupLookupVar(pShaderGroup, "LetterIndex2", false);

	m_idLicensePlateFontOutlineColor				= VehShaderGroupLookupVar(pShaderGroup, "FontOutlineColor", false);
	m_idLicensePlateFontExtents						= VehShaderGroupLookupVar(pShaderGroup, "LicensePlateFontExtents", false);
	m_idLicensePlateFontOutlineMinMaxDepth_Enabled	= VehShaderGroupLookupVar(pShaderGroup, "FontOutlineMinMaxDepthEnabled", false);
	m_idLicensePlateMaxLettersOnPlate				= VehShaderGroupLookupVar(pShaderGroup, "LicensePlateMaxLetters", false);

#if USE_DISKBRAKEGLOW
	m_varDiskBrakeGlow			= 0.0f;
#endif // USE_DISKBRAKEGLOW

	m_bIsHighDetail				= false;

	return(TRUE);
}// end of Initialise()...


//
//
//
//
CCustomShaderEffectBase*	CCustomShaderEffectVehicleType::CreateInstance(CEntity* pEntity)
{
	CCustomShaderEffectVehicle *pNewShaderEffect = rage_new CCustomShaderEffectVehicle();

	CVehicleModelInfo *pVMI = (CVehicleModelInfo*)(pEntity->GetBaseModelInfo());
	Assert(pVMI);

	for (int i=0; i<NUMBER_OF_RENDER_THREADS; i++)
	{
		pNewShaderEffect->m_pType[i] = this;
	}

	pNewShaderEffect->m_vDamagedFrontWheelOffsets[0] = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
	pNewShaderEffect->m_vDamagedFrontWheelOffsets[1] = Vector4(0.0f, 0.0f, 0.0f, 0.0f);

	pNewShaderEffect->SetDirtLevel(0.0f);
	pNewShaderEffect->SetDirtColor(this->GetDefaultDirtColor());
	pNewShaderEffect->SetBurnoutLevel(0.0f);

	for(s32 i=0; i<7; i++)
	{
		pNewShaderEffect->m_varDifCol[i]		= Color32(0,0,0);
		pNewShaderEffect->m_varMetallicID[i]	= (u8)CVehicleModelColor::EVehicleModelColorMetallic_none;
	}
	pNewShaderEffect->SetSpec2Color(0,0,0);
	pNewShaderEffect->SetSpec2DirLerp(0.0f);
	pNewShaderEffect->SetDiffuseTint(pVMI->GetDiffuseTint());
	pNewShaderEffect->m_bRenderScorched			= FALSE;
	pNewShaderEffect->m_pLiveryTexture			= NULL;

	pNewShaderEffect->m_liveryFragSlotIdx		= strLocalIndex::INVALID_INDEX;

	pNewShaderEffect->UpdateVehicleColors(pEntity);

	pNewShaderEffect->m_bTyreDeformSwitchOn		= false;
	pNewShaderEffect->m_bBurstWheel				= false;
	pNewShaderEffect->m_bDamageSwitchOn			= false;
	pNewShaderEffect->m_pDamageTexture			= NULL;

#if VEHICLE_SUPPORT_PAINT_RAMP
	for(u32 i = 0; i < NELEM(pNewShaderEffect->m_pRampTextures); ++i)
	{
		pNewShaderEffect->m_pRampTextures[i] = 0;
	}
#endif

	pNewShaderEffect->m_bCustomPrimaryColor		= false;
	pNewShaderEffect->m_bCustomSecondaryColor	= false;
	pNewShaderEffect->m_bIsBrokenOffPart		= false;
	pNewShaderEffect->m_bHasLiveryMod			= false;

	pNewShaderEffect->m_uvTrackAnim				= Vector2(0.0f,0.0f);
	pNewShaderEffect->m_uvTrack2Anim			= Vector2(0.0f,0.0f);
	pNewShaderEffect->m_uvTrackAmmoAnim			= Vector2(0.0f,0.0f);

	pNewShaderEffect->m_fUserEmissiveMultiplier	= 1.0f;

	for(u32 i=0; i<(4*CVehicleLightSwitch::LW_LIGHTVECTORS+1); i++)
	{
		pNewShaderEffect->m_fLightDimmer[i]		= 1.0f;
	}

float envEff1=0.0f;
	const float envEffScaleMin = pVMI->GetEnvEffScaleMin();
	const float envEffScaleMax = pVMI->GetEnvEffScaleMax();
	if(envEffScaleMin < envEffScaleMax)
		envEff1 = g_DrawRand.GetRanged(envEffScaleMin, envEffScaleMax);
	else
		envEff1 = envEffScaleMin;	// do not rand() if min==max

float envEff2=0.0f;
	const float envEffScaleMin2 = pVMI->GetEnvEffScaleMin2();
	const float envEffScaleMax2 = pVMI->GetEnvEffScaleMax2();
	if(envEffScaleMin2 < envEffScaleMax2)
		envEff2 = g_DrawRand.GetRanged(envEffScaleMin2, envEffScaleMax2);
	else
		envEff2 = envEffScaleMin2;	// do not rand() if min==max

	pNewShaderEffect->SetEnvEffScale(g_DrawRand.GetBool()? envEff1 : envEff2);	// equally select from 1st or 2nd range


	pNewShaderEffect->m_pLicensePlateDiffuseTex	= NULL;
	pNewShaderEffect->m_pLicensePlateNormalTex	= NULL;

	int seed = 1;
	if(pEntity->GetIsTypeVehicle())
		seed = static_cast<CVehicle*>(pEntity)->GetRandomSeed();

	pNewShaderEffect->GenerateLicensePlateText(seed);

	pNewShaderEffect->AddKnownRefs();

	//The license plate textures to use should be driven later by script. (Same as the livery stuff) However, since this functionality is
	//new, this is not currently set up. So I have added the code block below to set the license plate textures to the default textures. (If
	//a default is defined.) This way, the license plates will draw correctly in the mean time, and as a proof of concept, any instance of a
	//vehicle can be spawned with a different license plate texture just by changing the default texture index in Rag and spawning a new instance.
	//
	//Once this is hooked up through code, it may make sense to remove this functionality completely. However, if a we do that and script misses a
	//call to set the plate background texture, the resulting visual may or may not look very strange and completely incorrect depending on what is
	//drawn before it. So perhaps to identify this easily, in all __BANK or !__FINAL builds we could have some default error texture to make any
	//problems very obvious. If we go with this method, this code block should probably be moved to the Initialise() function.
	//
	//IMPORTANT Note: This code *must* come after the AddKnownRefs() call, or the game may assert and become unstable. -AJG
	pNewShaderEffect->SelectLicensePlateByProbability(pEntity);
	InitialiseClothDrawable(pEntity);

	pNewShaderEffect->SetDamageTex(const_cast<grcTexture*>(grcTexture::NoneBlack));
	return(pNewShaderEffect);
}

//
//
// initializes vehicle cloth drawable:
//
rmcDrawable* CCustomShaderEffectVehicleType::InitialiseClothDrawable(CEntity *pEntity) const
{
	// initialize vehicle cloth drawable instance (only for SD vehicle):
	fragInst* pFragInst = pEntity->GetFragInst();
	if(pFragInst && pEntity->m_nFlags.bIsFrag && (!this->GetIsHighDetail()))
	{
		// Search for a cloth drawable
		rmcDrawable *pClothDrawable = NULL;
		fragCacheEntry *cacheEntry = pFragInst->GetCacheEntry();
		if(cacheEntry)
		{
			fragHierarchyInst* hierInst = cacheEntry->GetHierInst();
			Assertf( hierInst,"No HierInst on a cached frag" );
			environmentCloth* pEnvCloth = hierInst->envCloth;
			if( pEnvCloth )
			{
				pClothDrawable = pEnvCloth->GetDrawable();
			}
		}

		if(pClothDrawable)
		{
			grmShaderGroup *pClothShaderGroup = &pClothDrawable->GetShaderGroup();
			if(pClothShaderGroup->GetShaderGroupVarCount()==0)
			{
				CCustomShaderEffectVehicleType *pClothCseType = CCustomShaderEffectVehicleType::Create(pClothDrawable, NULL, NULL);
				if(!pClothCseType->Initialise(pClothDrawable))
				{
					Assertf(FALSE, "Error initialising CustomShaderEffect!");
				}

				// check if clothCSE matches SD vehicleCSE:
				#if __ASSERT
				#define ASSERT_COMPARE_VAR0(VAR) Assertf(this->VAR == pClothCseType->VAR, "Value of "#VAR" doesn't match for vehicle SD CSE and vehicle cloth !");
				#define ASSERT_COMPARE_VAR(VAR)  Assertf(this->VAR == pClothCseType->VAR, "Value of "#VAR" doesn't match for vehicle's SD CSE (=%d) and vehicle's cloth CSE (=%d)!",this->VAR,pClothCseType->VAR);
					ASSERT_COMPARE_VAR0(m_DefDirtColor);
					ASSERT_COMPARE_VAR(m_idVarDiffuse2Color);
					ASSERT_COMPARE_VAR(m_idVarDirtLevelMod);
					ASSERT_COMPARE_VAR(m_idVarDirtColor);
					ASSERT_COMPARE_VAR(m_idVarDiffuseColorTint);

					ASSERT_COMPARE_VAR(m_idVarDiffuseTex2);
					ASSERT_COMPARE_VAR(m_idVarDiffuseTex3);
					ASSERT_COMPARE_VAR(m_idVarTyreDeformSwitchOn);
					ASSERT_COMPARE_VAR(m_idVarTrackAnimUV);

					ASSERT_COMPARE_VAR(m_idVarTrack2AnimUV);
					ASSERT_COMPARE_VAR(m_idVarTrackAmmoAnimUV);
					ASSERT_COMPARE_VAR(m_idVarEnvEffScale);
					ASSERT_COMPARE_VAR(m_idLicensePlateBgTex);

					ASSERT_COMPARE_VAR(m_idLicensePlateBgNormTex);
					ASSERT_COMPARE_VAR(m_idLicensePlateFontColor);
					ASSERT_COMPARE_VAR(m_idLicensePlateText1);
					ASSERT_COMPARE_VAR(m_idLicensePlateText2);

					ASSERT_COMPARE_VAR(m_idLicensePlateFontOutlineColor);
					ASSERT_COMPARE_VAR(m_idLicensePlateFontExtents);
					ASSERT_COMPARE_VAR(m_idLicensePlateFontOutlineMinMaxDepth_Enabled);
					ASSERT_COMPARE_VAR(m_idLicensePlateMaxLettersOnPlate);

					ASSERT_COMPARE_VAR(m_idVarDimmer);
				#if USE_GPU_VEHICLEDEFORMATION
					ASSERT_COMPARE_VAR(m_idVarDamageSwitchOn);
					ASSERT_COMPARE_VAR(m_idVarBoundRadius);
					ASSERT_COMPARE_VAR(m_idVarDamageMult);
					ASSERT_COMPARE_VAR(m_idVarDamageTex);
				#endif
				#if USE_DISKBRAKEGLOW
					ASSERT_COMPARE_VAR(m_idVarDiskBrakeGlow);
				#endif
					ASSERT_COMPARE_VAR(m_bHasTruckTex);
					ASSERT_COMPARE_VAR(m_bIsHighDetail);
					ASSERT_COMPARE_VAR(m_bHasBodyColor1);
					ASSERT_COMPARE_VAR(m_bHasBodyColor2);
					ASSERT_COMPARE_VAR(m_bHasBodyColor3);
					ASSERT_COMPARE_VAR(m_bHasBodyColor4);
					ASSERT_COMPARE_VAR(m_bHasBodyColor5);
					ASSERT_COMPARE_VAR(m_bHasBodyColor6);
					ASSERT_COMPARE_VAR(m_bHasBodyColor7);

					ASSERT_COMPARE_VAR(m_DiffColEffect.GetCount());
					ASSERT_COMPARE_VAR(m_SpecColEffect.GetCount());
					ASSERT_COMPARE_VAR(m_DirtTexEffect.GetCount());
					ASSERT_COMPARE_VAR(m_Tex2Effect.GetCount());
				#undef ASSERT_COMPARE_VAR0
				#undef ASSERT_COMPARE_VAR
				#endif //__ASSERT...

				delete pClothCseType;
				pClothCseType = NULL;
				return(pClothDrawable);
			}
		}
	}// vehicle cloth drawable instance...

	return(NULL);
}

//
//
//
//
grcTexture* CCustomShaderEffectVehicleType::GetDirtTexture(u32 shaderIdx) const
{
	const u32 dirtTexCount = m_DirtTexEffect.GetCount();
	for(u32 i=0; i<dirtTexCount; i++)
	{
		const CCustomShaderEffectVehicleType::structDirtTexEffect *ptr = &m_DirtTexEffect[i];
		if(ptr->shaderIdx == shaderIdx)
		{
			return (grcTexture*)ptr->pOrigDirtTex;
		}
	}
	return(NULL);
}

//
//
//
//
CCustomShaderEffectVehicle::CCustomShaderEffectVehicle() : CCustomShaderEffectBase(sizeof(*this), CSE_VEHICLE)
{
	m_nLicensePlateTexIdx		=
	m_nLiveryIdx				=
	m_nLivery2Idx				= -1;

	m_pLicensePlateDiffuseTex	= NULL;
	m_pLicensePlateNormalTex	= NULL;

	m_bCustomPrimaryColor		= false;
	m_bCustomSecondaryColor		= false; //ensure this is properly initialized

	memset(m_LicensePlateText,0,sizeof(m_LicensePlateText));
}

//
//
//
//
CCustomShaderEffectVehicle::~CCustomShaderEffectVehicle()
{
	RemoveKnownRefs();
	// m_pType is cleaned up in ShutdownMaster
}

//
//
//
//
void CCustomShaderEffectVehicle::CopySettings(CCustomShaderEffectVehicle *src, CEntity* /*pEntity*/)
{
	sysMemCpy(m_fLightDimmer, src->m_fLightDimmer, sizeof(m_fLightDimmer));
	this->m_fBoundRadius			= src->m_fBoundRadius;
	this->m_fDamageMultiplier		= src->m_fDamageMultiplier;
	sysMemCpy(this->m_vDamagedFrontWheelOffsets, src->m_vDamagedFrontWheelOffsets, sizeof(src->m_vDamagedFrontWheelOffsets));

	sysMemCpy(this->m_varDifCol, src->m_varDifCol, sizeof(src->m_varDifCol));
	this->m_varSpec2Color_DirLerp	= src->m_varSpec2Color_DirLerp;
	this->m_varDiffColorTint		= src->m_varDiffColorTint;
	this->m_varDirtColor_DirtLevel	= src->m_varDirtColor_DirtLevel;
	sysMemCpy(this->m_varMetallicID, src->m_varMetallicID, sizeof(src->m_varMetallicID));

	this->m_pDamageTexture			= src->m_pDamageTexture;
#if VEHICLE_SUPPORT_PAINT_RAMP
	for(u32 i = 0; i < NELEM(this->m_pRampTextures); ++i)
	{
		this->m_pRampTextures[i] = src->m_pRampTextures[i];
	}
#endif
//	grcTextureIndex					m_pLiveryTexture;
	this->m_liveryFragSlotIdx		= src->m_liveryFragSlotIdx;
	this->m_nLiveryIdx				= src->m_nLiveryIdx;
	this->m_nLivery2Idx				= src->m_nLivery2Idx;
	this->m_bCustomPrimaryColor		= src->m_bCustomPrimaryColor;
	this->m_bCustomSecondaryColor	= src->m_bCustomSecondaryColor;
	this->m_bIsBrokenOffPart		= src->m_bIsBrokenOffPart;
	this->m_bHasLiveryMod			= src->m_bHasLiveryMod;
	this->m_uvTrackAnim				= src->m_uvTrackAnim;
	this->m_uvTrack2Anim			= src->m_uvTrack2Anim;
	this->m_uvTrackAmmoAnim			= src->m_uvTrackAmmoAnim;

	this->m_fUserEmissiveMultiplier	= src->m_fUserEmissiveMultiplier;

	SetLicensePlateTexIndex(src->m_nLicensePlateTexIdx);
//	grcTextureIndex					m_pLicensePlateDiffuseTex;
//	grcTextureIndex					m_pLicensePlateNormalTex;
	sysMemCpy(this->m_LicensePlateText, src->m_LicensePlateText, sizeof(src->m_LicensePlateText));

	sysMemCpy(this->m_wheelBurstSideRatios, src->m_wheelBurstSideRatios, sizeof(src->m_wheelBurstSideRatios));

#if USE_DISKBRAKEGLOW
	m_varDiskBrakeGlow				= src->m_varDiskBrakeGlow;
#endif
	this->m_varEnvEffScale			= src->m_varEnvEffScale;
	this->m_varBurnoutLevel			= src->m_varBurnoutLevel;

	this->m_bRenderScorched			= src->m_bRenderScorched;
	this->m_bTyreDeformSwitchOn		= src->m_bTyreDeformSwitchOn;
	this->m_bBurstWheel				= src->m_bBurstWheel;
	this->m_bDamageSwitchOn			= src->m_bDamageSwitchOn;
}


//
//
//
//
void CCustomShaderEffectVehicle::Update(fwEntity* pEntityBase)
{
	CEntity* pEntity = static_cast<CEntity*>(pEntityBase);
	Assert(pEntity);
	if(pEntity->GetIsTypeVehicle())
	{
		CVehicle *pVehicle = static_cast<CVehicle*>(pEntity);

		// dirt test:
//		const float time = float(fwTimer::GetTimeInMilliseconds()) * 0.001f;
//		this->SetDirtLevel(rage::Sinf(time)*0.5f + 0.5f);
		this->SetDirtLevel(pVehicle->GetBodyDirtLevel() / 15.0f);
		this->SetDirtColor(pVehicle->GetBodyDirtColor());

		this->m_bHasLiveryMod = pVehicle->GetVariationInstance().GetNumModsForType(VMT_LIVERY_MOD, pVehicle) > 0;

#if !__FINAL
		if(gbDontDisplayDirtOnVehicles || PARAM_novehicledirt.Get())
			this->SetDirtLevel(0.0f);
#endif //__DEV...


		if(pVehicle->m_nPhysicalFlags.bRenderScorched)	// vehicle burntout/exploded?
		{
			this->m_bRenderScorched = TRUE;
			float fBurnoutLevelInc =
										#if CSE_VEHICLE_EDITABLEVALUES
											ms_fEVBurnoutSpeed;
										#else
											 0.01f;
										#endif
#if GTA_REPLAY
			if(CReplayMgr::IsReplayInControlOfWorld())
			{
				ReplayVehicleExtension* pExt = ReplayVehicleExtension::GetExtension(pVehicle);
				if(pExt && pExt->GetIncScorch() == false)
				{
					fBurnoutLevelInc = 0.0f;	// Don't increment scorch...replay is in control
				}
			}
#endif // GTA_REPLAY

			this->SetBurnoutLevel(GetBurnoutLevel()+fBurnoutLevelInc);
			this->SetDirtLevel(1.0f);
			this->UpdateVehicleColors(pVehicle);
		}
		else
		{
			this->m_bRenderScorched = FALSE;
			this->SetBurnoutLevel(0.0f);
		}

		Color32 newWindowTint = GetDiffuseTint();
		if (pVehicle->GetVariationInstance().GetKitIndex() != INVALID_VEHICLE_KIT_INDEX && pVehicle->GetVariationInstance().GetWindowTint() != 0xff)
		{
			newWindowTint = CVehicleModelInfo::GetVehicleColours()->GetVehicleWindowColor(pVehicle->GetVariationInstance().GetWindowTint());
		}
		SetDiffuseTint(newWindowTint);

		const tcKeyframeUncompressed& currKeyframe = g_timeCycle.GetCurrUpdateKeyframe();
		this->SetSpec2DirLerp(currKeyframe.GetVar(TCVAR_LIGHT_VEHICLE_SECOND_SPEC_OVERRIDE));

#if USE_DISKBRAKEGLOW
		if( GetCseType()->m_idVarDiskBrakeGlow )
		{
			// That's our current temperature
			float wheelTemperature = m_varDiskBrakeGlow;

			// Update glow level if needed
			if( pVehicle->GetHasGlowingBrakes() )
			{
				const float engineOn = (float)(fwTimer::GetTimeInMilliseconds() - pVehicle->m_EngineSwitchedOnTime);
				
				// Gather linear speed and brake force from the wheels
				const int numWheels = pVehicle->GetNumWheels();

#if DISKBRAKEGLOW_DEBUG_TEXT_FULLWHEELDETAIL
				float wheelBrakes[20];
				float wheelSpeed[20];
				float wheelAngleVel[20];
				float wheelSlipRatio[20];
#endif // DISKBRAKEGLOW_DEBUG_TEXT
				float accumWheelSpeed = 0.0f;
				float accumBrakeForce = 0.0f;

				for(int i=0;i<numWheels;i++)
				{
					const CWheel *wheel = pVehicle->GetWheel(i);
					if( wheel )
					{
						accumWheelSpeed += wheel->GetGroundSpeed();
						accumBrakeForce += wheel->GetBrakeForce();
#if DISKBRAKEGLOW_DEBUG_TEXT_FULLWHEELDETAIL
						wheelBrakes[i] = wheel->GetBrakeForce();
						wheelSpeed[i] = wheel->GetGroundSpeed();
						wheelAngleVel[i] = wheel->GetRotSpeed();
						wheelSlipRatio[i] = wheel->GetRotSlipRatio();
#endif // DISKBRAKEGLOW_DEBUG_TEXT_FULLWHEELDETAIL
					}
				}

				const float fnumWheels = (float)numWheels;
				accumBrakeForce /= fnumWheels;
				accumWheelSpeed /= fnumWheels;
#if DISKBRAKEGLOW_DEBUG_TEXT
				{
					char msg[1024];
					static int StartX = 100;
					static int StartY = 10;

					int y = StartY;

					sprintf(msg,"breakped %f",pVehicle->GetBrake());
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"HandBreak %d",pVehicle->GetHandBrake());
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"BrakeForce %f",accumBrakeForce);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"WheelSpeed %f",accumWheelSpeed);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"SpeedCap %f",g_fDiskBrake_SpeedCap);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"MagicNumber %f",g_fDiskBrake_TempMagicNumber);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"EngineOn %f",engineOn);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					const float EngineAge = rage::Clamp((engineOn - g_fDiskBrake_EngineAge) * (1.0f / g_fDiskBrake_EngineAge),0.0f,1.0f);
					sprintf(msg,"EngineAge %f",EngineAge);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
#if DISKBRAKEGLOW_V2
					const float nWheelSpeed = rage::Max(0.0f,(accumWheelSpeed - g_fDiskBrake_SpeedCap) * (1.0f / g_fDiskBrake_SpeedCap));
					const float sWheelSpeed = rage::square(nWheelSpeed);
					const float nHeatingRate = g_fDiskBrake_MaxHeatingRate * nWheelSpeed;
					const float sHeatingRate = g_fDiskBrake_MaxHeatingRate * sWheelSpeed;
					const float heatingRate = rage::Lerp(accumBrakeForce,nHeatingRate,sHeatingRate);
#else // DISKBRAKEGLOW_V2
					const float heatingRate = (accumWheelSpeed / g_fDiskBrake_TempMagicNumber) * accumBrakeForce;
#endif // DISKBRAKEGLOW_V2
					sprintf(msg,"heatingRate %f",heatingRate);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"WheelTemp %f",wheelTemperature);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					static float maxwheelTemperature = 0.0f;
					static float minwheelTemperature = FLT_MAX;
					if( wheelTemperature > maxwheelTemperature )
					{
						maxwheelTemperature = wheelTemperature;
					}
					
					if( wheelTemperature < minwheelTemperature )
					{
						minwheelTemperature = wheelTemperature;
					}
					sprintf(msg,"minwheelTemperature %f",minwheelTemperature);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					sprintf(msg,"maxwheelTemperature %f",maxwheelTemperature);
					grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
					y++;
					
#if DISKBRAKEGLOW_DEBUG_TEXT_FULLWHEELDETAIL
					for(int i=0;i<numWheels;i++)
					{
						const CWheel *wheel = pVehicle->GetWheel(i);
						if( wheel )
						{
							sprintf(msg,"Wheel Speed %d:%f",i,wheelSpeed[i]);
							grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
							y++;
							sprintf(msg,"Wheel Break %d:%f",i,wheelBrakes[i]);
							grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
							y++;
							sprintf(msg,"wheelAngleVel %d:%f",i,wheelAngleVel[i]);
							grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
							y++;
							sprintf(msg,"wheelSlipRatio %d:%f",i,wheelSlipRatio[i]);
							grcDebugDraw::PrintToScreenCoors(msg,StartX,y);
							y++;
						}
					}
#endif // DISKBRAKEGLOW_DEBUG_TEXT_FULLWHEELDETAIL
				}
#endif // DISKBRAKEGLOW_DEBUG_TEXT

				// Scale the disk "temperature" (actually 0 to 1) based on the vehicle's behaviour
				const float timestep = fwTimer::GetTimeStep();
				if( (pVehicle->GetBrake() > 0.05f) &&
					(false == pVehicle->GetHandBrake()) &&
					(accumBrakeForce > 0.0f) &&
					(accumWheelSpeed > g_fDiskBrake_SpeedCap) )
				{
#if DISKBRAKEGLOW_V2
					const float nWheelSpeed = rage::Max(0.0f,(accumWheelSpeed - g_fDiskBrake_SpeedCap) * (1.0f / g_fDiskBrake_SpeedCap));
					const float sWheelSpeed = rage::square(nWheelSpeed);
					const float nHeatingRate = g_fDiskBrake_MaxHeatingRate * nWheelSpeed;
					const float sHeatingRate = g_fDiskBrake_MaxHeatingRate * sWheelSpeed;
					const float heatingRate = rage::Lerp(accumBrakeForce,nHeatingRate,sHeatingRate);
#else // DISKBRAKEGLOW_V2
					const float heatingRate = (accumWheelSpeed / g_fDiskBrake_TempMagicNumber) * accumBrakeForce;
#endif // DISKBRAKEGLOW_V2
					const float EngineAge = rage::Clamp((engineOn - g_fDiskBrake_EngineAge) * (1.0f / g_fDiskBrake_EngineAge),0.0f,1.0f);
					wheelTemperature = rage::Min(0.5f,wheelTemperature + (timestep * heatingRate * EngineAge));
				}
				else
				{
					wheelTemperature = rage::Max(0.0f,wheelTemperature - (timestep * g_fDiskBrake_CoolingRate));
				}

			}
			else
			{
				wheelTemperature = 0.0f;
			}

#if DISKBRAKEGLOW_DEBUG_SHADER
			static float frequency = 1500.0f;
			static float maxLum = 1.0f;

			wheelTemperature = rage::Abs((rage::Sinf(((float)fwTimer::GetTimeInMilliseconds()/frequency)*PI) * maxLum));
#endif // DISKBRAKEGLOW_DEBUG_SHADER
		
			m_varDiskBrakeGlow = wheelTemperature;
		}
#endif // USE_DISKBRAKEGLOW


// debug test tank track anim:
#if 0
static dev_bool	gbDbgTrackAnim			= TRUE;
static dev_float	gbDbgTrackAnimAddRight	= -0.01f;
static dev_float	gbDbgTrackAnimAddLeft	= 0.01f;
	if(gbDbgTrackAnim)
	{
		if(m_idVarTrackAnimUV)
		{
			Vector2 a;
			a.x = gbDbgTrackAnimAddRight;
			a.y = gbDbgTrackAnimAddLeft;
			this->TrackUVAnimAdd( a );
		}
	}
#endif //#if 0...


		// calculate sun glare factor:
#if CSE_VEHICLE_EDITABLEVALUES
		if(ms_bEVSunGlareEnabled)
#else
		if(0)
#endif
		{
			float glare_s = 1.0f;
			const Vector3& cameraPos	= camInterface::GetPos();
			const Vector3& cameraFront	= camInterface::GetFront();
			const Vector3 vehiclePos	= VEC3V_TO_VECTOR3(pEntity->GetTransform().GetPosition());

			// distance factor:
			#if CSE_VEHICLE_EDITABLEVALUES
				const float glareMinDist  = ms_fEVSunGlareDistMin;
				const float glareMaxDist  =	ms_fEVSunGlareDistMax;
			#else
				const float glareMinDist  =	65.0f;
				const float glareMaxDist  =	75.0f;
			#endif
			
			const Vector3 distV(cameraPos - vehiclePos);
			const float dist2 = distV.Mag2();
			glare_s *= 1.0f - rage::Clamp((glareMaxDist*glareMaxDist-dist2)/(glareMaxDist*glareMaxDist-glareMinDist*glareMinDist), 0.0f, 1.0f);

			const CLightSource &dirLight = Lights::GetRenderDirectionalLight();

			// "only during day" factor:
			glare_s *= rage::Clamp(dirLight.GetIntensity()-2.0f, 0.0f, 1.0f);

			// view/sun angle factor:
			Vector3 surface_worldNormal(cameraPos - vehiclePos);	// fake "normal"
			surface_worldNormal.Normalize();

			Vector3 surfaceToEyeDirection(-cameraFront);
			surfaceToEyeDirection.Normalize();

			Vector3 halfVector = surfaceToEyeDirection - dirLight.GetDirection();
			halfVector.Normalize();

			float glareSpec = rage::Clamp(surface_worldNormal.Dot(halfVector), 0.0f, 1.0f);

			#if CSE_VEHICLE_EDITABLEVALUES
				const u32 powCount = ms_nEVSunGlarePow;
			#else
				const u32 powCount = 32;
			#endif
			float glareSpecFactor = 1.0f;
			for(u32 i=0; i<powCount; i++)
			{
				glareSpecFactor *= glareSpec;
			}
			glare_s *= glareSpecFactor;

			glare_s = rage::Clamp(glare_s, 0.0f, 1.0f);
		
			// SunGlareFx v2:
			if(glare_s > 0.0f)
			{
				Vector3 boundCentre;
				const float boundRadius = pVehicle->GetBoundCentreAndRadius(boundCentre);

				Vector3 coronaPos = boundCentre;

				#if CSE_VEHICLE_EDITABLEVALUES
					const float spriteZShiftScale = ms_fEVSunGlareSpriteZShiftScale;
				#else
					const float spriteZShiftScale = 0.2f;
				#endif
				coronaPos.z += boundRadius*spriteZShiftScale;	// shift glare sprite a little upwards to cover windscreen, etc.

				#if CSE_VEHICLE_EDITABLEVALUES
					const float coronaSizeMult = ms_fEVSunGlareSpriteSize;
				#else
					const float coronaSizeMult = 0.55f;
				#endif
				const float coronaSize = boundRadius * coronaSizeMult * glare_s;
				
				u32 colorInt = u32(255.0f*glare_s);
				Color32 coronaColor(colorInt,colorInt,colorInt,colorInt); 

				#if CSE_VEHICLE_EDITABLEVALUES
					const float coronaHdrIntensityMult = ms_fEVSunGlareHdrMult;
				#else
					const float coronaHdrIntensityMult = 8.0f;
				#endif
				const float coronaHdrIntensity = coronaHdrIntensityMult * glare_s * glare_s;
				const float zBias = boundRadius*1.5f;

				g_coronas.Register(RCC_VEC3V(coronaPos),
								   coronaSize, 
								   coronaColor,
								   coronaHdrIntensity, 
								   zBias, 
								   Vec3V(V_ZERO),
								   1.0f,
								   CORONAS_DEF_DIR_LIGHT_CONE_ANGLE_INNER,
								   CORONAS_DEF_DIR_LIGHT_CONE_ANGLE_OUTER,
								   CORONA_DONT_REFLECT);
			}
		}

		// update tyre burst/side ratios:
		this->m_bBurstWheel = false;
		const u32 numWheels = pVehicle->GetNumWheels();
		if(numWheels)
		{
			float aBurstRatios[NUM_VEH_CWHEELS_MAX];
			float aSideRatios[NUM_VEH_CWHEELS_MAX];
			sysMemSet(aBurstRatios, 0x00, sizeof(aBurstRatios));
			sysMemSet(aSideRatios,  0x00, sizeof(aSideRatios));

			for(int i=0; i<numWheels; i++)
			{
				CWheel* pWheel = pVehicle->GetWheel(i);
				if(pWheel->GetTyreHealth() < TYRE_HEALTH_DEFAULT)
				{
					aBurstRatios[pWheel->GetHierarchyId() - VEH_WHEEL_LF] = pWheel->GetTyreBurstRatio();
					aSideRatios[pWheel->GetHierarchyId() - VEH_WHEEL_LF] = pWheel->GetTyreBurstSideRatio();
					this->m_bBurstWheel = true;
				}
			}

			// if any tyres are burst remap burst/side ratios to <0;255> (format directly used by DLC):
			if(this->m_bBurstWheel)
			{
				for(int i=0; i<NUM_VEH_CWHEELS_MAX; i++)
				{
					m_wheelBurstSideRatios[i][0] = (u8)(rage::Clamp(aBurstRatios[i], 0.0f, 1.0f) * 255.0f);
					m_wheelBurstSideRatios[i][1] = (u8)(rage::Clamp(0.5f * (aSideRatios[i] + 1.0f), 0.0f, 1.0f) * 255.0f);
				}
			}
		}// if(pVehicle->GetNumWheels())...

	}//if(pEntity->GetIsTypeVehicle())...
	else
	{
		// Assuming this is a wheel that's broken off
		this->m_bBurstWheel = GetEnableTyreDeform();
		if(this->m_bBurstWheel)
		{
			for(int i = 0; i < NUM_VEH_CWHEELS_MAX; i++)
			{
				m_wheelBurstSideRatios[i][0] = 255;
				m_wheelBurstSideRatios[i][1] = 127;
			}
		}
	}
}// end of Update()...

#if VEHICLE_SUPPORT_PAINT_RAMP
static grcTexture* GetVehicleColourRampTexture(CVehicleModelInfoVarGlobal* pVehColours, s32 col)
{
	grcTexture* result = 0;
	fwTxd *rampTxd = CCustomShaderEffectVehicle::GetRampTxd();
	const char *rampTextureName = pVehColours->GetVehicleColourRampTextureName(col);
	if (rampTextureName && rampTextureName[0] && Verifyf(rampTxd, "Missing ramp Txd"))
	{
		u32 rampHash = fwTxd::ComputeHash(rampTextureName);
		result = rampTxd->Lookup(rampHash);
		Assert(result);
	}
	return result;
}
#endif

//
//
//
//
bool CCustomShaderEffectVehicle::UpdateVehicleColors(CEntity *pEntity)
{
	// needs to be at a multiple of 16
	AlignedCompileTimeAssert(OffsetOf(CCustomShaderEffectVehicle,m_fLightDimmer), 16);

	Assert(pEntity);

	// might not be a vehicle (fragments break off vehicles as CObjects but still point to the vehicle model info)
	// need to work out how to pass the parent vehicle through to these objects
	CRGBA cols[7];
	float fBodyColorScale = 1.0f;
	u8	  metallicId[7];
#if VEHICLE_SUPPORT_PAINT_RAMP
	grcTexture* ramps[NELEM(m_pRampTextures)] = {};
#endif

	cols[4] = CRGBA(255,255,255,255);	// default interior color
	metallicId[4] = (u8)CVehicleModelColor::EVehicleModelColorMetallic_none;

	CCustomShaderEffectVehicleType *pType = GetCseTypeInternal();

	bool bColorChanged = false;

	if(pEntity->GetIsTypeVehicle())
	{
		CVehicle *pVehicle = static_cast<CVehicle*>(pEntity);
		CVehicleModelInfoVarGlobal* pVehColours = CVehicleModelInfo::GetVehicleColours();
		Assert(pVehColours);

		cols[0] = pVehColours->GetVehicleColour(pVehicle->GetBodyColour1());
		cols[1] = pVehColours->GetVehicleColour(pVehicle->GetBodyColour2());
		cols[2] = pVehColours->GetVehicleColour(pVehicle->GetBodyColour3());
		cols[3] = pVehColours->GetVehicleColour(pVehicle->GetBodyColour4());
		cols[5] = pVehColours->GetVehicleColour(pVehicle->GetBodyColour5());					// color5 mapped to bodycolor6
		cols[6] = pVehColours->GetVehicleColour(pVehicle->GetBodyColour6());					// color6 mapped to bodycolor7

		metallicId[0] = pVehColours->GetVehicleColourMetallicID(pVehicle->GetBodyColour1());
		metallicId[1] = pVehColours->GetVehicleColourMetallicID(pVehicle->GetBodyColour2());
		metallicId[2] = pVehColours->GetVehicleColourMetallicID(pVehicle->GetBodyColour3());
		metallicId[3] = pVehColours->GetVehicleColourMetallicID(pVehicle->GetBodyColour4());
		metallicId[5] = pVehColours->GetVehicleColourMetallicID(pVehicle->GetBodyColour5());	// color5 mapped to bodycolor6
		metallicId[6] = pVehColours->GetVehicleColourMetallicID(pVehicle->GetBodyColour6());	// color6 mapped to bodycolor7

#if VEHICLE_SUPPORT_PAINT_RAMP
		ramps[0] = GetVehicleColourRampTexture(pVehColours, pVehicle->GetBodyColour1());
		ramps[1] = GetVehicleColourRampTexture(pVehColours, pVehicle->GetBodyColour2());
		ramps[2] = GetVehicleColourRampTexture(pVehColours, pVehicle->GetBodyColour3());
		ramps[3] = GetVehicleColourRampTexture(pVehColours, pVehicle->GetBodyColour4());
#endif

		if(pVehicle->m_nPhysicalFlags.bRenderScorched)
		{
			// vehicle burntout/exploded:
			this->m_bRenderScorched = TRUE;

			// fBodyColorScale = 0.1f;

			// default interior (bodycolor5) color:
			cols[4] = CRGBA(128,128,128);
		}

		
		if( pType->m_idVarDiffuseTex2 )
		{
			CVehicleModelInfo *modelInfo = pVehicle->GetVehicleModelInfo();
			Assert(modelInfo);

			if( modelInfo->GetVehicleFlag(CVehicleModelInfoFlags::FLAG_HAS_LIVERY) )
			{
				Assertf(modelInfo->GetLiveriesCount() >0, "%s:Livery flag but no liveries ?", modelInfo->GetModelName());

				if(m_nLiveryIdx != -1) // livery ID to use has already by decided
				{
					u32 liveryHash = modelInfo->GetLiveryHash(m_nLiveryIdx);
					Assertf(liveryHash != 0xFFFFFFFF, "Invalid livery texture on vehicle '%s'", modelInfo->GetModelName());

					grcTexture* liveryTex = NULL;
					//if (m_pType->GetIsHighDetail())
					//{
					//      s32 hdTxdIdx = modelInfo->GetHDTxdIndex(); 
					//      fwTxd* hdTxd = g_TxdStore.Get(hdTxdIdx); 
					//      Assert(hdTxd);
					//
					//      if (hdTxd)
					//          liveryTex = hdTxd->Lookup(liveryHash);
					//}

					if (!liveryTex)
					{
						strLocalIndex txdIdx = strLocalIndex(modelInfo->GetAssetParentTxdIndex());
						fwTxd* txd = g_TxdStore.Get(txdIdx);

						if (AssertVerify(txd))
							liveryTex = txd->Lookup(liveryHash);
					}

					m_pLiveryTexture = liveryTex;
					Assert(m_pLiveryTexture);
				}
				else
				{
					if( modelInfo->GetVehicleFlag(CVehicleModelInfoFlags::FLAG_LIVERY_MATCH_EXTRA) ) // Match extras to livery
					{
						m_nLiveryIdx = -1;
						int extraIdx = -1;

						if( pVehicle->m_nDisableExtras ) // anything turned on ?
						{
							for(int i=0; i<(VEH_LAST_EXTRA - VEH_EXTRA_1); i++)
							{
								if( !(pVehicle->m_nDisableExtras &BIT(i)) )
								{
									// Enabled
									extraIdx = i;
									break;
								}
							}
							m_nLiveryIdx = extraIdx;
						}

						if( m_nLiveryIdx == -1 )
						{
							if( extraIdx == -1 )
							{ // extra with no matching textures, hence just use the last texture (supposedly blank)
								m_nLiveryIdx = modelInfo->GetLiveriesCount()-1;
							}
							else
							{ // No extras, just pick a random one
								m_nLiveryIdx = fwRandom::GetRandomNumberInRange(0, modelInfo->GetLiveriesCount());
							}
						}
						else
						{ // One extra : are we using the matching or the last texture (blank)
							bool noLivery = (0 != (fwRandom::GetRandomNumberInRange(0, 3) & 1));
							if( noLivery )
							{
								m_nLiveryIdx = modelInfo->GetLiveriesCount()-1;
							}
						}

						u32 liveryHash = modelInfo->GetLiveryHash(m_nLiveryIdx);
						Assertf(liveryHash != 0xFFFFFFFF, "Invalid livery texture on vehicle '%s'", modelInfo->GetModelName());

						strLocalIndex txdIdx = strLocalIndex(modelInfo->GetAssetParentTxdIndex());
						fwTxd *txd = g_TxdStore.Get(txdIdx);

						if (AssertVerify(txd))
						{
							grcTexture *liveryTex = txd->Lookup(liveryHash);
							m_pLiveryTexture = liveryTex;
							Assert(m_pLiveryTexture);
						}
					}
					else
					{
						m_nLiveryIdx = fwRandom::GetRandomNumberInRange(0, modelInfo->GetLiveriesCount());

						u32 liveryHash = modelInfo->GetLiveryHash(m_nLiveryIdx);
						Assertf(liveryHash != 0xFFFFFFFF, "Invalid livery texture on vehicle '%s'", modelInfo->GetModelName());

						strLocalIndex txdIdx = strLocalIndex(modelInfo->GetAssetParentTxdIndex());
						fwTxd *txd = g_TxdStore.Get(txdIdx);

						if (AssertVerify(txd))
						{
							grcTexture *liveryTex = txd->Lookup(liveryHash);
							m_pLiveryTexture = liveryTex;
							Assert(m_pLiveryTexture);
						}
					}
				}
			}
			else
			{
				m_pLiveryTexture = NULL;
			}
		}// if(pType->m_idVarDiffuseTex2)...

		if( pType->m_idVarDiffuseTex3 )
		{
			CVehicleModelInfo *modelInfo = pVehicle->GetVehicleModelInfo();
			Assert(modelInfo);

			if( modelInfo->GetVehicleFlag(CVehicleModelInfoFlags::FLAG_HAS_LIVERY) )
			{
				Assertf(modelInfo->GetLiveries2Count() >0, "%s:Livery flag but no liveries2 ?", modelInfo->GetModelName());

				if(m_nLivery2Idx != -1) // livery ID to use has already by decided
				{
					u32 livery2Hash = modelInfo->GetLivery2Hash(m_nLivery2Idx);
					Assertf(livery2Hash != 0xFFFFFFFF, "Invalid livery2 texture on vehicle '%s'", modelInfo->GetModelName());

					grcTexture* livery2Tex = NULL;
					if (!livery2Tex)
					{
						strLocalIndex txdIdx = strLocalIndex(modelInfo->GetAssetParentTxdIndex());
						fwTxd* txd = g_TxdStore.Get(txdIdx);

						if (AssertVerify(txd))
							livery2Tex = txd->Lookup(livery2Hash);
					}

					m_pLivery2Texture = livery2Tex;
					Assert(m_pLivery2Texture);
				}
				else
				{
					if( modelInfo->GetVehicleFlag(CVehicleModelInfoFlags::FLAG_LIVERY_MATCH_EXTRA) ) // Match extras to livery
					{
						m_nLivery2Idx = -1;
						int extraIdx = -1;

						if( pVehicle->m_nDisableExtras ) // anything turned on ?
						{
							for(int i=0; i<(VEH_LAST_EXTRA - VEH_EXTRA_1); i++)
							{
								if( !(pVehicle->m_nDisableExtras &BIT(i)) )
								{
									// Enabled
									extraIdx = i;
									break;
								}
							}
							m_nLivery2Idx = extraIdx;
						}

						if( m_nLivery2Idx == -1 )
						{
							if( extraIdx == -1 )
							{ // extra with no matching textures, hence just use the last texture (supposedly blank)
								m_nLivery2Idx = modelInfo->GetLiveries2Count()-1;
							}
							else
							{ // No extras, just pick a random one
								m_nLivery2Idx = fwRandom::GetRandomNumberInRange(0, modelInfo->GetLiveries2Count());
							}
						}
						else
						{ // One extra : are we using the matching or the last texture (blank)
							bool noLivery = (0 != (fwRandom::GetRandomNumberInRange(0, 3) & 1));
							if( noLivery )
							{
								m_nLivery2Idx = modelInfo->GetLiveries2Count()-1;
							}
						}

						u32 livery2Hash = modelInfo->GetLivery2Hash(m_nLivery2Idx);
						Assertf(livery2Hash != 0xFFFFFFFF, "Invalid livery2 texture on vehicle '%s'", modelInfo->GetModelName());

						strLocalIndex txdIdx = strLocalIndex(modelInfo->GetAssetParentTxdIndex());
						fwTxd *txd = g_TxdStore.Get(txdIdx);

						if (AssertVerify(txd))
						{
							grcTexture *livery2Tex = txd->Lookup(livery2Hash);
							m_pLivery2Texture = livery2Tex;
							Assert(m_pLivery2Texture);
						}
					}
					else
					{
						m_nLivery2Idx = fwRandom::GetRandomNumberInRange(0, modelInfo->GetLiveries2Count());

						u32 livery2Hash = modelInfo->GetLivery2Hash(m_nLivery2Idx);
						Assertf(livery2Hash != 0xFFFFFFFF, "Invalid livery2 texture on vehicle '%s'", modelInfo->GetModelName());

						strLocalIndex txdIdx = strLocalIndex(modelInfo->GetAssetParentTxdIndex());
						fwTxd *txd = g_TxdStore.Get(txdIdx);

						if (AssertVerify(txd))
						{
							grcTexture *livery2Tex = txd->Lookup(livery2Hash);
							m_pLivery2Texture = livery2Tex;
							Assert(m_pLivery2Texture);
						}
					}
				}
			}
			else
			{
				m_pLivery2Texture = NULL;
			}
		}// if(pType->m_idVarDiffuseTex3)...

	}
	else
	{
		cols[0] = cols[1] = cols[2] = cols[3] = cols[5] = cols[6] = CRGBA(150, 150,150, 255);
		metallicId[0] = metallicId[1] = metallicId[2] = metallicId[3] = metallicId[5] = metallicId[6] = (u8)CVehicleModelColor::EVehicleModelColorMetallic_none;
	}

	Color32 primaryColor = m_varDifCol[0];
	Color32 secondaryColor = m_varDifCol[1];
	
	for(s32 i=0; i<7; i++)
	{
		if(i==4)		// skip bodycolor5 as it's interior hardcoded color
			continue;	

		Color32 newColor = Color32(cols[i].GetRedf()*fBodyColorScale, cols[i].GetGreenf()*fBodyColorScale, cols[i].GetBluef()*fBodyColorScale); 

		if(newColor != this->m_varDifCol[i])
		{
			bColorChanged = true;
		}

		this->m_varDifCol[i] = newColor;
		this->m_varMetallicID[i] = metallicId[i];
	}

#if VEHICLE_SUPPORT_PAINT_RAMP
	for(u32 i = 0; i < NELEM(ramps); ++i)
	{
		if(ramps[i] != m_pRampTextures[i])
		{
			bColorChanged = true;
		}

		this->m_pRampTextures[i] = ramps[i];
	}
#endif
	
	// Restore custom colors
	if( m_bCustomPrimaryColor )
		m_varDifCol[0] = primaryColor;
	if( m_bCustomSecondaryColor )
		m_varDifCol[1] = secondaryColor;
		
	// and interior color with no body color scale:
	this->m_varDifCol[4]		= cols[4];
	this->m_varMetallicID[4]	= metallicId[4];

	// this is specular color:
	this->SetSpec2Color(cols[2].GetRed(), cols[2].GetGreen(), cols[2].GetBlue());

	return bColorChanged;
}// end of UpdateVehicleColors()...

void CCustomShaderEffectVehicle::SetCustomPrimaryColor(Color32 col)
{
	m_varDifCol[0] = col;
	m_bCustomPrimaryColor = true;
}

Color32 CCustomShaderEffectVehicle::GetCustomPrimaryColor()
{
	return m_varDifCol[0];
}

void CCustomShaderEffectVehicle::SetCustomSecondaryColor(Color32 col)
{
	m_varDifCol[1] = col;
	m_bCustomSecondaryColor = true;
}

Color32 CCustomShaderEffectVehicle::GetCustomSecondaryColor()
{
	return m_varDifCol[1];
}

void CCustomShaderEffectVehicle::SetRed()
{
	m_varDifCol[0] =
	m_varDifCol[1] =
	m_varDifCol[2] =
	m_varDifCol[3] =
	m_varDifCol[4] =
	m_varDifCol[5] = 
	m_varDifCol[6] = Color32(255,0,0);

	m_varMetallicID[0] =
	m_varMetallicID[1] =
	m_varMetallicID[2] =
	m_varMetallicID[3] =
	m_varMetallicID[4] =
	m_varMetallicID[5] =
	m_varMetallicID[6] = (u8)CVehicleModelColor::EVehicleModelColorMetallic_none;
}

void CCustomShaderEffectVehicle::SetGreen()
{
	m_varDifCol[0] =
	m_varDifCol[1] =
	m_varDifCol[2] =
	m_varDifCol[3] =
	m_varDifCol[4] =
	m_varDifCol[5] =
	m_varDifCol[6] = Color32(0,255,0);

	m_varMetallicID[0] =
	m_varMetallicID[1] =
	m_varMetallicID[2] =
	m_varMetallicID[3] =
	m_varMetallicID[4] =
	m_varMetallicID[5] =
	m_varMetallicID[6] = (u8)CVehicleModelColor::EVehicleModelColorMetallic_none;
}

void CCustomShaderEffectVehicle::SetBlue()
{
	m_varDifCol[0] =
	m_varDifCol[1] =
	m_varDifCol[2] =
	m_varDifCol[3] =
	m_varDifCol[4] =
	m_varDifCol[5] =
	m_varDifCol[6] = Color32(0,0,255);

	m_varMetallicID[0] =
	m_varMetallicID[1] =
	m_varMetallicID[2] =
	m_varMetallicID[3] =
	m_varMetallicID[4] =
	m_varMetallicID[5] =
	m_varMetallicID[6] = (u8)CVehicleModelColor::EVehicleModelColorMetallic_none;
}

//
//
//
//
void CCustomShaderEffectVehicle::AddToDrawList(u32 modelIndex, bool bExecute)
{
	DLC(CCustomShaderEffectDC, (*this, modelIndex, bExecute, GetCseTypeInternal()));
}

//
//
//
// special version of SetShaderVariables() method for JohnW's multicore renderer
// as we don't have entities there, but only drawables;
//
void CCustomShaderEffectVehicle::SetShaderVariables(rmcDrawable* pDrawable)
{
	SetShaderVariables(pDrawable, Vector3(0.0, 0.0, 0.0));
}

void CCustomShaderEffectVehicle::SetShaderVariables(rmcDrawable* pDrawable, Vector3 boneOffset, bool isBrokenOffPart)
{

// 	rmcDrawable* pDrawable = NULL;
// 	if (GetIsHighDetail()){
// 		CVehicleModelInfo* pVMI = static_cast<CVehicleModelInfo*>(m_pBaseModelInfo);
// 		if (pVMI->GetHDFragType()){
// 			pDrawable = pVMI->GetHDFragType()->GetCommonDrawable();
// 		} else {
// 			return;
// 		}
// 	} else {
// 		Assert(m_pBaseModelInfo);
// 		pDrawable = m_pBaseModelInfo->GetDrawable();
// 		Assert(pDrawable);
// 	}

	if(!pDrawable)
		return;

#if __BANK
	if(DRAWLISTMGR->IsExecutingDebugOverlayDrawList())
		return;
#endif

	CCustomShaderEffectVehicleType *pType = GetCseTypeInternal();

	grmShaderGroup* pShaderGroup = &pDrawable->GetShaderGroup();

	// setup shaders for vehicle deformation
	// Do this before the early out for the shadow pass so its setup correctly for shadows.
#if USE_GPU_VEHICLEDEFORMATION
	if(pType->m_idVarDamageSwitchOn)
	{
		grcEffect::SetGlobalVar((grcEffectGlobalVar)pType->m_idVarDamageSwitchOn, GTASHADERVARBOOL(m_bDamageSwitchOn));

		// no need to set other vars if damage isn't switched on
		if(m_bDamageSwitchOn)
		{
			if(m_pDamageTexture && pType->m_idVarDamageTex && pType->m_idVarBoundRadius && pType->m_idVarDamageMult && pType->m_idVarDamagedFrontWheelOffsets && pType->m_idVarOffset BANK_ONLY( && pType->m_idVarDebugDamageMap && pType->m_idVarDebugDamageMult))
			{
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDamageTex,	m_pDamageTexture);
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarBoundRadius,	m_fBoundRadius);
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDamageMult,	m_fDamageMultiplier);
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDamagedFrontWheelOffsets, m_vDamagedFrontWheelOffsets, 2);
#if __BANK
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDebugDamageMap, CVehicleDeformation::ms_bDisplayDamageMap);
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDebugDamageMult, CVehicleDeformation::ms_bDisplayDamageMult);
#endif

			#if __BANK
 				boneOffset += Vector3(CVehicleDeformation::m_DamageTextureOffset_X, CVehicleDeformation::m_DamageTextureOffset_Y, CVehicleDeformation::m_DamageTextureOffset_Z);
			#endif
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarOffset,		boneOffset);
			}
			else
			{	// disable damage if invalid settings
				grcEffect::SetGlobalVar((grcEffectGlobalVar)pType->m_idVarDamageSwitchOn, false);

				if(pType->m_idVarDamageTex)
				{
					pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDamageTex,	const_cast<grcTexture*>(grcTexture::NoneBlack));
				}
			}
		}
		else
		{
			if(pType->m_idVarDamageTex)
			{
				pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDamageTex, m_pDamageTexture ? m_pDamageTexture : const_cast<grcTexture*>(grcTexture::NoneBlack));
			}
		}
	}
	else
	{
		if(pType->m_idVarDamageTex)
		{
			pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDamageTex, m_pDamageTexture ? m_pDamageTexture : const_cast<grcTexture*>(grcTexture::NoneBlack));
		}
	}
#endif //USE_GPU_VEHICLEDEFORMATION...

	// tyre deform on/off control:
	if(pType->m_idVarTyreDeformSwitchOn)
	{
		grcEffect::SetGlobalVar((grcEffectGlobalVar)pType->m_idVarTyreDeformSwitchOn, GTASHADERVARBOOL(m_bTyreDeformSwitchOn));
		
		#if CSE_VEHICLE_EDITABLEVALUES
			// editable inner wheel radius stuff:
			grcEffect::SetGlobalVar((grcEffectGlobalVar)pType->m_idVarTyreDeformSwitchOn, GTASHADERVARBOOL(m_bTyreDeformSwitchOn || GetEWREnabled()));
		#endif
	}

	if(grmModel::GetForceShader())
		return;

	const u32 dirtTexCount = pType->m_DirtTexEffect.GetCount();
	if(m_bRenderScorched)
	{
		// Dirt texture (replaced with burnout when vehicle scorched):
		for(u32 i=0; i<dirtTexCount; i++)
		{
			CCustomShaderEffectVehicleType::structDirtTexEffect *ptr = &pType->m_DirtTexEffect[i];

			Assert(!GetCseType()->m_bHasTruckTex || CCustomShaderEffectVehicleType::ms_pBurnoutTruckTexture);	// truck expects a valid burnout texture

			grcTexture *burnoutTex = GetCseType()->m_bHasTruckTex? CCustomShaderEffectVehicleType::ms_pBurnoutTruckTexture : CCustomShaderEffectVehicleType::ms_pBurnoutTexture;
			burnoutTex = ptr->bIsInterior? CCustomShaderEffectVehicleType::ms_pBurnoutIntTexture : burnoutTex;
			pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDirtTex, (grcTexture*)burnoutTex);
		}
		
		// burnout vehicle: full dirt level + darker dirt + dirtOrBurnout=0 (nonDirtSpecIntScale (for non dirt shaders) to 0)
		if(pType->m_idVarDirtLevelMod)
			pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDirtLevelMod, Vector4(GetBurnoutLevel(), 0.25f, /*dirtOrBurnout*/0.0f, 0.10f));
	}
	else
	{	// restore original dirt texture:
		for(u32 i=0; i<dirtTexCount; i++)
		{
			CCustomShaderEffectVehicleType::structDirtTexEffect *ptr = &pType->m_DirtTexEffect[i];
			pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDirtTex, (grcTexture*)ptr->pOrigDirtTex);
		}

		const float dirtModulator = rage::Lerp(rage::Clamp(g_weather.GetWetness(),0.0f,1.0f), 1.0f, DEFAULT_DIRTMODWET);
		if(pType->m_idVarDirtLevelMod)
			pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDirtLevelMod, Vector4(this->GetDirtLevel(), dirtModulator, /*dirtOrBurnout*/1.0f, 1.0f));
	}

	if(DRAWLISTMGR->IsExecutingShadowDrawList())
		return;

	if(pType->m_idVarDirtColor)
	{
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDirtColor, this->GetDirtColor());
	}

	if(pType->m_idVarSpec2Color)
	{
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarSpec2Color, this->GetSpec2Color());	// rgb=spec2Color, a=spec2DirLerp
	}

#if USE_DISKBRAKEGLOW
	if( pType->m_idVarDiskBrakeGlow )
	{
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDiskBrakeGlow,m_varDiskBrakeGlow);
	}
#endif

	// setup shader for headlights
	if(pType->m_idVarDimmer)
	{
		float lightValues[4*CVehicleLightSwitch::LW_LIGHTVECTORS] = {0.0f};

		const float dayNightFade = CVehicle::GetDayNightFade();

		for (u32 i=0; i < CVehicleLightSwitch::LW_LIGHTCOUNT; ++i)
		{
			lightValues[i] = isBrokenOffPart ? CVehicle::GetLightOffValue(i, dayNightFade) : m_fLightDimmer[i];
		}
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDimmer, (Vector4*)lightValues, CVehicleLightSwitch::LW_LIGHTVECTORS);
	}

	// SpecularColor:
	const s32 specCount = pType->m_SpecColEffect.GetCount();

	if(false && m_bRenderScorched)
	{
		static dev_bool bEnableSpecularBurnout=true;
		for(s32 i=0; i<specCount; i++)
		{
			CCustomShaderEffectVehicleType::structSpecColEffect *ptr = &pType->m_SpecColEffect[i];
			if(bEnableSpecularBurnout)
			{
				if(ptr->idvarSpecInt)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecInt, float(ptr->origSpecInt));

				if(ptr->idvarSpecFalloff)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFalloff, float(ptr->origSpecFalloff));

				if(ptr->idvarSpecFresnel)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFresnel, float(ptr->origSpecFresnel));
			}
			else
			{
				if(ptr->idvarSpecInt)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecInt, 0.0f);
			}
		}
	}
	else
	{
		for(s32 i=0; i<specCount; i++)
		{
			CCustomShaderEffectVehicleType::structSpecColEffect *ptr = &pType->m_SpecColEffect[i];
			
			if((ptr->colorIdx != 255) && (m_varMetallicID[ptr->colorIdx] != (u8)CVehicleModelColor::EVehicleModelColorMetallic_none))
			{	// setup metallic settings:
				CVehicleMetallicSetting *metallicSet = CVehicleModelInfo::GetVehicleColours()->GetMetallicSetting( m_varMetallicID[ptr->colorIdx] );		
				Assert(metallicSet);

				if(ptr->idvarSpecInt)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecInt, metallicSet->m_specInt);

				if(ptr->idvarSpecFalloff)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFalloff, metallicSet->m_specFalloff);

				if(ptr->idvarSpecFresnel)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFresnel, metallicSet->m_specFresnel);
			}
			else
			{	// restore original specular colors:
				if(ptr->idvarSpecInt)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecInt, float(ptr->origSpecInt));

				if(ptr->idvarSpecFalloff)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFalloff, float(ptr->origSpecFalloff));

				if(ptr->idvarSpecFresnel)
					pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecFresnel, float(ptr->origSpecFresnel));
			}
			
		}
	}

	// overlay color:
	if(pType->m_idVarDiffuse2Color)
	{
		if(m_bRenderScorched)
			pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDiffuse2Color, Vector4(0.75f, 0.75f, 0.75f, 1.0f));
		else
			pShaderGroup->SetVarByRef((grmShaderGroupVar)pType->m_idVarDiffuse2Color, VECTOR4_IDENTITY);
	}

	// diffuse tint color (used mainly for vehicle glass):
	if(pType->m_idVarDiffuseColorTint)
	{
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDiffuseColorTint, m_varDiffColorTint);
	}

	if(pType->m_idVarDiffuseTex2)
	{
		if (m_bHasLiveryMod) 
		{
			grcTexture *pLiveryModTex = (grcTexture*)grcTexture::NoneBlackTransparent;

			if (m_liveryFragSlotIdx != strLocalIndex::INVALID_INDEX)
			{
				if (g_FragmentStore.GetSlot(m_liveryFragSlotIdx)->m_pObject != NULL)
				{
					grmShaderGroup *pFragShaderGroup = g_FragmentStore.Get(m_liveryFragSlotIdx)->GetCommonDrawable()->GetShaderGroupPtr();
					fwTxd const* pTxd = pFragShaderGroup ? pFragShaderGroup->GetTexDict() : NULL; // frag's internal txd

					Assertf(pTxd,"livery mod %s, does not have a .txd embedded in the mod frag", g_FragmentStore.GetName(m_liveryFragSlotIdx)); 
					if (pTxd && pTxd->GetCount() > 0)
					{
						pLiveryModTex = pTxd->GetEntry(0);
					}
				}
			}
			pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDiffuseTex2, pLiveryModTex);
		}
		else if(m_pLiveryTexture)
		{
			pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDiffuseTex2, m_pLiveryTexture);
		}
		else
		{
			// restore original overlay texture(s):
			const u32 tex2Count = pType->m_Tex2Effect.GetCount();
			for(u32 i=0; i<tex2Count; i++)
			{
				CCustomShaderEffectVehicleType::structTex2Effect *ptr = &pType->m_Tex2Effect[i];
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarTex2, (grcTexture*)ptr->pOrigTex2);
			}
		}
	}

	if(pType->m_idVarDiffuseTex3 && m_pLivery2Texture)
	{
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarDiffuseTex3, m_pLivery2Texture);
	}

	const u32 count = pType->m_DiffColEffect.GetCount();
	#if __ASSERT
		Assertf(count > 0, "BS#124925: DiffColEffect array is empty! Andrzej would love to see this assert.");
	#endif
	if(count)
	{
		for(u32 i=0; i<count; i++)
		{
			CCustomShaderEffectVehicleType::structDiffColEffect *ptr = &pType->m_DiffColEffect[i];
#if __DEV
			if(ms_nForceColorCars==0)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVarByRef((grcEffectVar)ptr->idvarDiffColor, ORIGIN);
			}
			else if(ms_nForceColorCars==1)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVarByRef((grcEffectVar)ptr->idvarDiffColor, VEC3_IDENTITY);
			}
			else
#endif // __DEV
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffColor, m_varDifCol[ptr->colorIdx]);
			}

#if VEHICLE_SUPPORT_PAINT_RAMP
			grcTexture* diffuseRampTex = 0;
			grcTexture* specularRampTex = 0;
			if(ptr->colorIdx < NELEM(m_pRampTextures))
			{
				diffuseRampTex = m_pRampTextures[ptr->colorIdx];
				specularRampTex = m_pRampTextures[2]; // Albert: 2=BodyColor3=Specular
#if __BANK
				if(s_DebugRampTextureEnabled)
				{
					diffuseRampTex = s_DebugRampTexture;
					specularRampTex = s_DebugRampTexture;
				}

				if(!s_RampDiffuseEnabled)
				{
					diffuseRampTex = 0;
				}
				if(!s_RampSpecularEnabled)
				{
					specularRampTex = 0;
				}
#endif
			}
#if __DEV
			if(ms_nForceColorCars==0 || ms_nForceColorCars==1)
			{
				diffuseRampTex = 0;
				specularRampTex = 0;
			}
#endif

			if (ptr->idvarDiffuseRampTexture)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffuseRampTexture, diffuseRampTex ? diffuseRampTex : const_cast<grcTexture*>(grcTexture::NoneBlack));
			}

			if (ptr->idvarSpecularRampTexture)
			{
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarSpecularRampTexture, specularRampTex ? specularRampTex : const_cast<grcTexture*>(grcTexture::NoneBlack));
			}

			if (ptr->idvarDiffuseSpecularRampEnabled)
			{
				float rampEnabled = specularRampTex ? 2.0f : 1.0f;
				rampEnabled = diffuseRampTex ? rampEnabled : -rampEnabled;
				pShaderGroup->GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffuseSpecularRampEnabled, rampEnabled);
			}
#endif
		}
	}

	// track UV anim for tank:
	if(pType->m_idVarTrackAnimUV)
	{
		Vector4 uv4(m_uvTrackAnim.x, m_uvTrackAnim.y, 0.0f, 0.0f);
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarTrackAnimUV, uv4);
	}

	// track UV anim for tank:
	if(pType->m_idVarTrack2AnimUV)
	{
		Vector4 uv4(m_uvTrack2Anim.x, m_uvTrack2Anim.y, 0.0f, 0.0f);
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarTrack2AnimUV, uv4);
	}

	// track UV anim for ammo:
	if(pType->m_idVarTrackAmmoAnimUV)
	{
		Vector4 uv4(m_uvTrackAmmoAnim.x, m_uvTrackAmmoAnim.y, 0.0f, 0.0f);
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarTrackAmmoAnimUV, uv4);
	}

	// emissive control:
	if(pType->m_idVarEmissiveMult)
	{
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarEmissiveMult, m_fUserEmissiveMultiplier * pType->m_DefEmissiveMult);
	}

	// enveff scale:
	if(pType->m_idVarEnvEffScale)
	{
		float envEffScale = GetEnvEffScale();
		Vector2 envEffScaleV2(envEffScale, envEffScale/1000.0f);
		pShaderGroup->SetVar((grmShaderGroupVar)pType->m_idVarEnvEffScale, envEffScaleV2);
	}

	//Set the license plate shader vars
	const CVehicleModelInfoPlates *plates = &CVehicleModelInfo::GetVehicleColours()->GetLicensePlateData();
	if(plates && m_nLicensePlateTexIdx >= 0)
	{
		//Find the right textures to set to license plate.
		const CVehicleModelInfoPlates::TextureArray &textures = plates->GetTextureArray();

		if(m_pLicensePlateDiffuseTex && pType->m_idLicensePlateBgTex != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateBgTex), m_pLicensePlateDiffuseTex);

		if(m_pLicensePlateNormalTex && pType->m_idLicensePlateBgNormTex != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateBgNormTex), m_pLicensePlateNormalTex);

		if(pType->m_idLicensePlateFontColor != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateFontColor), textures[m_nLicensePlateTexIdx].GetFontColor());

		if(pType->m_idLicensePlateText1 != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateText1), Vector4(m_LicensePlateText[0],m_LicensePlateText[1],m_LicensePlateText[2],m_LicensePlateText[3]));

		if(pType->m_idLicensePlateText2 != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateText2), Vector4(m_LicensePlateText[4],m_LicensePlateText[5],m_LicensePlateText[6],m_LicensePlateText[7]));

		if(pType->m_idLicensePlateFontOutlineColor != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateFontOutlineColor), textures[m_nLicensePlateTexIdx].GetFontOutlineColor());

		if(pType->m_idLicensePlateFontExtents != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateFontExtents), textures[m_nLicensePlateTexIdx].GetFontExtents());

		if(pType->m_idLicensePlateFontOutlineMinMaxDepth_Enabled != grmsgvNONE)
		{
			const Vector2 &outlineMinMaxDepth = textures[m_nLicensePlateTexIdx].GetFontOutlineMinMaxDepth();
			Vector4 enabled(outlineMinMaxDepth.x, outlineMinMaxDepth.y, (textures[m_nLicensePlateTexIdx].IsFontOutlineEnabled() ? 1.0f : 0.0f), 0.0f);
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateFontOutlineMinMaxDepth_Enabled), enabled);
		}

		if(pType->m_idLicensePlateMaxLettersOnPlate != grmsgvNONE)
			pShaderGroup->SetVar(static_cast<grmShaderGroupVar>(pType->m_idLicensePlateMaxLettersOnPlate), textures[m_nLicensePlateTexIdx].GetMaxLettersOnPlate());
	}

	#if CSE_VEHICLE_EDITABLEVALUES
		this->SetEditableShaderValues(pShaderGroup, pDrawable);
	#endif

}// end of SetShaderVariables()...

//
//
// this is called from CVehicleModelInfo::SetupCommonData():
//

void CCustomShaderEffectVehicle::SetupBurnoutTexture(s32 txdSlot)
{
	if (txdSlot == -1)
	{
		CCustomShaderEffectVehicleType::ms_pBurnoutTexture = NULL;
		CCustomShaderEffectVehicleType::ms_pBurnoutIntTexture = NULL;
	}
	else
	{
		const fwTxd *burnoutTxd = g_TxdStore.Get(strLocalIndex(txdSlot));

		if (Verifyf(burnoutTxd, "vehicle burnout txd slot %d (%s) was NULL", txdSlot, g_TxdStore.GetName(strLocalIndex(txdSlot))))
		{
			grcTexture *burnout = burnoutTxd->Lookup(VEHICLE_GENERIC_BURNOUT_TEXNAME);
			CCustomShaderEffectVehicleType::ms_pBurnoutTexture = burnout;
			Assert(CCustomShaderEffectVehicleType::ms_pBurnoutTexture);

			grcTexture *burnoutInt = burnoutTxd->Lookup(VEHICLE_GENERIC_BURNOUT_INT_TEXNAME);
			CCustomShaderEffectVehicleType::ms_pBurnoutIntTexture = burnoutInt;
			Assert(CCustomShaderEffectVehicleType::ms_pBurnoutIntTexture);
		}
	}
}// end of SetupBurnoutTexture()...




//
//
//
//
void CCustomShaderEffectVehicle::SelectLicensePlateByProbability(CEntity *pEntity)
{
	if(Verifyf(pEntity, "Null entity passed in to SelectLicensePlateByProbability()!"))
	{
		int defaultTexIdx = CVehicleModelInfo::GetVehicleColours()->GetLicensePlateData().GetDefaultTextureIndex();

		CVehicle* pVehicle = static_cast<CVehicle*>(pEntity);
		CVehicleModelInfo *modelInfo = pVehicle->GetVehicleModelInfo();
		if(Verifyf(modelInfo, "Got invalid model info! (pEntity = 0x%p | modelIndex = %d)", pEntity, pEntity->GetModelIndex()) && modelInfo->GetModelType() == MI_TYPE_VEHICLE)
		{
			defaultTexIdx = modelInfo->SelectLicensePlateTextureIndex();
		}

		SetLicensePlateTexIndex(defaultTexIdx);
	}
}

void CCustomShaderEffectVehicle::SetLicensePlateText(const char *str)
{
	//Convert text to char array indices. 
	const CVehicleModelInfoPlates *plates = &CVehicleModelInfo::GetVehicleColours()->GetLicensePlateData();
	u8 *strIndices = m_LicensePlateText;
	bool endOfStr = false;

	// B*1325679 - Can you add the required number of spaces when the name is shorter than the 8 characters it is. 
	// 8 chars max, not zero terminated if max?
	int length;
	for(length=0; length<LICENCE_PLATE_LETTERS_MAX; length++)
	{
		if( str[length] == 0 )
			break;
	}
	int lead = (LICENCE_PLATE_LETTERS_MAX - length)>>1;

	for(u32 i=0; i<LICENCE_PLATE_LETTERS_MAX; i++)
	{
		endOfStr = endOfStr || i>=(length + lead);
		if(endOfStr || i<lead)
		{
			strIndices[i] = plates->GetFontSpaceOffset();
		}
		else
		{
			char c = str[i - lead];

			if(c >= '0' && c <= '9')
			{
				strIndices[i] = plates->GetFontNumericOffset() + (c - '0');
			}
			else if(c >= 'A' && c <= 'Z')
			{
				strIndices[i] = plates->GetFontAlphabeticOffset() + (c - 'A');
			}
			else if(c >= 'a' && c <= 'z')
			{
				strIndices[i] = plates->GetFontAlphabeticOffset() + (c - 'a');
			}
			else if(c == ' ')
			{
				strIndices[i] = plates->GetFontSpaceOffset();
			}
			else
			{
				//All the rest go here...
				strIndices[i] = plates->GetFontRandomCharOffset() + (c % plates->GetFontNumRandomChar());
			}
		}

		//Make sure the index is with-in the proper range
		#if __ASSERT
			static u8 sMaxGlyphs = 64;
			Assertf(strIndices[i] < sMaxGlyphs, "Invalid font glyph index value: %i", static_cast<int>(strIndices[i]));
		#endif
	}
}

static char sDecodedLicenseText[ CCustomShaderEffectVehicle::LICENCE_PLATE_LETTERS_MAX+1 ];
CompileTimeAssert(sizeof(sDecodedLicenseText) > CCustomShaderEffectVehicle::LICENCE_PLATE_LETTERS_MAX);

const char* CCustomShaderEffectVehicle::GetLicensePlateText() const
{
	const CVehicleModelInfoPlates *plates = &CVehicleModelInfo::GetVehicleColours()->GetLicensePlateData();

	int	inIDX = 0;
	int	outIDX = 0;
	while(inIDX < LICENCE_PLATE_LETTERS_MAX)
	{
		if (m_LicensePlateText[inIDX] >= plates->GetFontRandomCharOffset())
		{
			// we can't convert back the random characters unfortunately
			sDecodedLicenseText[outIDX++] = ' ';
		}
		else if (m_LicensePlateText[inIDX] >= plates->GetFontAlphabeticOffset())
		{
			sDecodedLicenseText[outIDX++] = 'A' + (m_LicensePlateText[inIDX] - plates->GetFontAlphabeticOffset());
		}
		else if (m_LicensePlateText[inIDX] >= plates->GetFontNumericOffset())
		{
			sDecodedLicenseText[outIDX++] = '0' + (m_LicensePlateText[inIDX] - plates->GetFontNumericOffset());
		}
		else if (m_LicensePlateText[inIDX] == 0)
		{
			sDecodedLicenseText[outIDX++] = 0;
			break;
		}
		inIDX++;
	}
	for(int i = outIDX; i<=LICENCE_PLATE_LETTERS_MAX; i++)
	{
		sDecodedLicenseText[i] = 0;
	}

	return sDecodedLicenseText;
}

void CCustomShaderEffectVehicle::GenerateLicensePlateText(u32 seed)
{
	// California legal is 1ABC234 since early 80s
	// We'll use 12ABC345
	mthRandom rnd(seed);
	
	char tag[9];

	tag[0] = static_cast<char>(rnd.GetRanged('0','9'));
	tag[1] = static_cast<char>(rnd.GetRanged('0','9'));
	tag[2]	= static_cast<char>(rnd.GetRanged('A','Z'));
	tag[3]	= static_cast<char>(rnd.GetRanged('A','Z'));
	tag[4]	= static_cast<char>(rnd.GetRanged('A','Z'));
	tag[5] = static_cast<char>(rnd.GetRanged('0','9'));
	tag[6] = static_cast<char>(rnd.GetRanged('0','9'));
	tag[7] = static_cast<char>(rnd.GetRanged('0','9'));
	tag[8] = '\0';

	SetLicensePlateText(tag);
}

void CCustomShaderEffectVehicle::SetLicensePlateTexIndex(s32 index)
{
	const CVehicleModelInfoPlates *plates = &CVehicleModelInfo::GetVehicleColours()->GetLicensePlateData();
	if(Verifyf(index >= -1 && index < plates->GetTextureArray().size(),
		"Invalid index license plate texture index requested: %d. Max number of known plate textures = %d",
		index, plates->GetTextureArray().size() ))
	{
		if(m_nLicensePlateTexIdx != index)
		{
			//Update the license plate index
			m_nLicensePlateTexIdx = index;

			if(m_nLicensePlateTexIdx >= 0)
			{
				//Find the right textures to set to license plate.
				const CVehicleModelInfoPlates::TextureArray &textures = plates->GetTextureArray();
				u32 diffuseHash = textures[m_nLicensePlateTexIdx].GetDiffuseMapStrHash().GetHash();
				u32 normalHash = textures[m_nLicensePlateTexIdx].GetNormalMapStrHash().GetHash();

				grcTexture *diffuseMap = NULL;
				grcTexture *normalMap = NULL;
				strLocalIndex txdIdx = strLocalIndex(CVehicleModelInfo::GetCommonTxd());
				fwTxd *txd = g_TxdStore.Get(txdIdx);

				if(Verifyf(txd, "Encountered a NULL texture dictionary while trying to iterate the loaded global vehicle texture dictionaries!"))
				{
					if(!diffuseMap)
						diffuseMap = txd->Lookup(diffuseHash);

					if(!normalMap)
						normalMap = txd->Lookup(normalHash);
				}

				//Update our texture pointers to point to new license plate background textures.
				Assertf(diffuseMap, "SetLicensePlateTexIndex was unable to find the requested diffuse texture (%s <hash=0x%x>) for license plate background texture set index %d.",
					(textures[m_nLicensePlateTexIdx].GetDiffuseMapStrHash().GetCStr() ? textures[m_nLicensePlateTexIdx].GetDiffuseMapStrHash().GetCStr() : "<Unknown Hash>"),
					textures[m_nLicensePlateTexIdx].GetDiffuseMapStrHash().GetHash(), m_nLicensePlateTexIdx);
				Assertf(normalMap, "SetLicensePlateTexIndex was unable to find the requested normal texture (%s <hash=0x%x>) for license plate background texture set index %d.",
					(textures[m_nLicensePlateTexIdx].GetNormalMapStrHash().GetCStr() ? textures[m_nLicensePlateTexIdx].GetNormalMapStrHash().GetCStr() : "<Unknown Hash>"),
					textures[m_nLicensePlateTexIdx].GetNormalMapStrHash().GetHash(), m_nLicensePlateTexIdx);

				m_pLicensePlateDiffuseTex = diffuseMap;
				m_pLicensePlateNormalTex = normalMap;
			}
		}
	}
}


inline float wrapOverOne(float a)
{
	if(a > 1.0f)
	{
		float ipart;
		a = rage::Modf(a, &ipart);
	}
	return(a);
}

inline float wrapBelowZero(float a)
{
	if(a < 0.0f)
	{
		float ipart;
		a = rage::Modf(a, &ipart);
		a += 1.0f;
	}
	return(a);
}

//
// tanks tracks:
// adds given amount of U shift to overall UV anim:
//
void CCustomShaderEffectVehicle::TrackUVAnimAdd(const Vector2& a)
{
	this->m_uvTrackAnim.x += a.x;	// right shift
	this->m_uvTrackAnim.y += a.y;	// left shift

	// wrap to <0; 1.0f>
	m_uvTrackAnim.x = wrapOverOne(m_uvTrackAnim.x);
	m_uvTrackAnim.y = wrapOverOne(m_uvTrackAnim.y);
	m_uvTrackAnim.x = wrapBelowZero(m_uvTrackAnim.x);
	m_uvTrackAnim.y = wrapBelowZero(m_uvTrackAnim.y);
}

void CCustomShaderEffectVehicle::Track2UVAnimAdd(const Vector2& a)
{
	this->m_uvTrack2Anim.x += a.x;	// right shift
	this->m_uvTrack2Anim.y += a.y;	// left shift

	// wrap to <0; 1.0f>
	m_uvTrack2Anim.x = wrapOverOne(m_uvTrack2Anim.x);
	m_uvTrack2Anim.y = wrapOverOne(m_uvTrack2Anim.y);
	m_uvTrack2Anim.x = wrapBelowZero(m_uvTrack2Anim.x);
	m_uvTrack2Anim.y = wrapBelowZero(m_uvTrack2Anim.y);
}

void CCustomShaderEffectVehicle::TrackAmmoUVAnimAdd(const Vector2& a)
{
	this->m_uvTrackAmmoAnim.x += a.x;	// right shift
	this->m_uvTrackAmmoAnim.y += a.y;	// left shift

	// wrap to <0; 1.0f>
	m_uvTrackAmmoAnim.x = wrapOverOne(m_uvTrackAmmoAnim.x);
	m_uvTrackAmmoAnim.y = wrapOverOne(m_uvTrackAmmoAnim.y);
	m_uvTrackAmmoAnim.x = wrapBelowZero(m_uvTrackAmmoAnim.x);
	m_uvTrackAmmoAnim.y = wrapBelowZero(m_uvTrackAmmoAnim.y);
}

const u32 g_vehicleGlassVarHashDiffuseTex               = ATSTRINGHASH("DiffuseTex", 0xC8E8C282);
const u32 g_vehicleGlassVarHashDirtTex                  = ATSTRINGHASH("DirtTex", 0xA6F4CF58);
const u32 g_vehicleGlassVarHashSpecularTex              = ATSTRINGHASH("SpecularTex", 0xC6F46E79);
const u32 g_vehicleGlassVarHashSpecularMapIntensityMask = ATSTRINGHASH("SpecularMapIntensityMask", 0x92DB11FB);
const u32 g_vehicleGlassVarHashEnvEffTexTileUV          = ATSTRINGHASH("envEffTexTileUV", 0xDAC8F5E7);
const u32 g_vehicleGlassVarHashEnvEffThickness          = ATSTRINGHASH("envEffThickness", 0xA114F369);

const u32 g_vehicleGlassVarHashDirtLevelMod             = ATSTRINGHASH("DirtLevelMod", 0xEC247F19);
const u32 g_vehicleGlassVarHashDirtColor                = ATSTRINGHASH("DirtColor", 0x44546346);
const u32 g_vehicleGlassVarHashDiffuseColorTint         = ATSTRINGHASH("DiffuseColorTint", 0xE297F9DA);
const u32 g_vehicleGlassVarHashEnvEffScale0             = ATSTRINGHASH("envEffScale0", 0xC788FA2A);

void CVehicleGlassShaderData::GetStandardShaderVariables(const grmShader* pShader)
{
	Assertf(strcmp(pShader->GetName(), "vehicle_vehglass") == 0, "CVehicleGlassShaderData::GetStandardShaderVariables called on shader \"%s\"", pShader->GetName());

	const grcEffectVar idVarDiffuseTex               = pShader->LookupVarByHash(g_vehicleGlassVarHashDiffuseTex);
	const grcEffectVar idVarDirtTex                  = pShader->LookupVarByHash(g_vehicleGlassVarHashDirtTex);
	const grcEffectVar idVarSpecularTex              = pShader->LookupVarByHash(g_vehicleGlassVarHashSpecularTex);
	const grcEffectVar idVarSpecularMapIntensityMask = pShader->LookupVarByHash(g_vehicleGlassVarHashSpecularMapIntensityMask);
	const grcEffectVar idVarEnvEffTexTileUV          = pShader->LookupVarByHash(g_vehicleGlassVarHashEnvEffTexTileUV);
	const grcEffectVar idVarEnvEffThickness          = pShader->LookupVarByHash(g_vehicleGlassVarHashEnvEffThickness);

	const grcEffectVar idVarDirtLevelMod             = pShader->LookupVarByHash(g_vehicleGlassVarHashDirtLevelMod);
	const grcEffectVar idVarDirtColor                = pShader->LookupVarByHash(g_vehicleGlassVarHashDirtColor);
	const grcEffectVar idVarDiffuseColorTint         = pShader->LookupVarByHash(g_vehicleGlassVarHashDiffuseColorTint);
	const grcEffectVar idVarEnvEffScale0             = pShader->LookupVarByHash(g_vehicleGlassVarHashEnvEffScale0);

	grcTexture* pDiffuseTex  = NULL;
	grcTexture* pDirtTex     = NULL;
	grcTexture* pSpecularTex = NULL;

	pShader->GetVar(idVarDiffuseTex , pDiffuseTex);
	pShader->GetVar(idVarDirtTex    , pDirtTex);
	pShader->GetVar(idVarSpecularTex, pSpecularTex);

	m_DiffuseTex  = pDiffuseTex;
	m_DirtTex     = pDirtTex;
	m_SpecularTex = pSpecularTex;

	pShader->GetVar(idVarSpecularMapIntensityMask, m_SpecularMapIntensityMask);
	pShader->GetVar(idVarEnvEffTexTileUV         , m_EnvEffTexTileUV);
	pShader->GetVar(idVarEnvEffThickness         , m_EnvEffThickness);

	pShader->GetVar(idVarDirtLevelMod            , m_DirtLevelMod);
	pShader->GetVar(idVarDirtColor               , m_DirtColor);
	pShader->GetVar(idVarDiffuseColorTint        , m_DiffuseColorTint);
	pShader->GetVar(idVarEnvEffScale0            , m_EnvEffScale0);

#if USE_GPU_VEHICLEDEFORMATION
	m_bDamageOn = false;
	m_pDamageTex = NULL; // Set this to NULL in case we can't get the damage texture from the custom shader
#endif // USE_GPU_VEHICLEDEFORMATION
}

void CVehicleGlassShaderData::GetCustomShaderVariables(const CCustomShaderEffectVehicle* pCSE)
{
	m_DirtLevelMod		= pCSE->m_bRenderScorched ? Vector4(1.0f, 0.25f, 0.0f, 0.0f) : Vector4(pCSE->GetDirtLevel(), 1.0f, 1.0f, 1.0f);
	m_DirtColor			= VEC4V_TO_VECTOR4(pCSE->GetDirtColor().GetRGBA());
	m_DiffuseColorTint	= VEC4V_TO_VECTOR4(pCSE->GetDiffuseTint().GetRGBA());
	m_EnvEffScale0		= Vector2(pCSE->GetEnvEffScale(), pCSE->GetEnvEffScale()/1000.0f);

#if CSE_VEHICLE_EDITABLEVALUES
	// Overwrite the shader value with the override value
	if (CCustomShaderEffectVehicle::GetEVOverrideDiffuseColorTint())
	{
		CCustomShaderEffectVehicle::GetEVDiffuseColorTint(m_DiffuseColorTint);
	}
#endif // CSE_VEHICLE_EDITABLEVALUES
}

void CVehicleGlassShaderData::GetDirtTexture(const CCustomShaderEffectVehicle* pCSE, int shaderIndex ASSERT_ONLY(, const char* vehicleModelName))
{
	const CCustomShaderEffectVehicleType* pType = pCSE->GetCseType();

	m_DirtTex = pType->GetDirtTexture(shaderIndex);

	Assertf(m_DirtTex, "%s: m_DirtTex is NULL", vehicleModelName);
}

#if USE_GPU_VEHICLEDEFORMATION
void CVehicleGlassShaderData::GetDamageShaderVariables(const CCustomShaderEffectVehicle* pCSE)
{
	m_bDamageOn = pCSE->GetEnableDamage();
	if(m_bDamageOn)
	{
		m_pDamageTex = pCSE->GetDamageTex();
		m_fBoundRadius = pCSE->GetBoundRadius();
		m_fDamageMultiplier	= pCSE->GetDamageMultiplier();
	}
	else
	{
		m_pDamageTex = NULL;
	}
}
#endif // USE_GPU_VEHICLEDEFORMATION

void CVehicleGlassShader::Create(grmShader* pShader)
{
	Assertf(strcmp(pShader->GetName(), "vehicle_vehglass_crack") == 0, "CVehicleGlassShader::Create called on shader \"%s\"", pShader->GetName());

	m_shader = pShader;

	m_idVarDiffuseTex               = pShader->LookupVarByHash(g_vehicleGlassVarHashDiffuseTex);
	m_idVarDirtTex                  = pShader->LookupVarByHash(g_vehicleGlassVarHashDirtTex);
	m_idVarSpecularTex              = pShader->LookupVarByHash(g_vehicleGlassVarHashSpecularTex);
	m_idVarSpecularMapIntensityMask = pShader->LookupVarByHash(g_vehicleGlassVarHashSpecularMapIntensityMask);
	m_idVarEnvEffTexTileUV          = pShader->LookupVarByHash(g_vehicleGlassVarHashEnvEffTexTileUV);
	m_idVarEnvEffThickness          = pShader->LookupVarByHash(g_vehicleGlassVarHashEnvEffThickness);

	m_idVarDirtLevelMod             = pShader->LookupVarByHash(g_vehicleGlassVarHashDirtLevelMod);
	m_idVarDirtColor                = pShader->LookupVarByHash(g_vehicleGlassVarHashDirtColor);
	m_idVarDiffuseColorTint         = pShader->LookupVarByHash(g_vehicleGlassVarHashDiffuseColorTint);
	m_idVarEnvEffScale0             = pShader->LookupVarByHash(g_vehicleGlassVarHashEnvEffScale0);

	m_idVarCrackTexture             = pShader->LookupVar("vehglassCrackTexture");
	m_idVarCrackTextureParams       = pShader->LookupVar("vehglassCrackTextureParams");

#if USE_GPU_VEHICLEDEFORMATION
	m_idVarDamageSwitchOn = grcEffect::LookupGlobalVar("switchOn");
	m_idVarDamageTex = m_shader->LookupVar("damagetexture");
	m_idVarBoundRadius = m_shader->LookupVar("BoundRadius");
	m_idVarDamageMult = m_shader->LookupVar("DamageMultiplier");
	m_idVarOffset = m_shader->LookupVar("DamageTextureOffset");
#endif // USE_GPU_VEHICLEDEFORMATION
}

void CVehicleGlassShader::Shutdown()
{
	Assertf(m_shader, "Create not called, or Shutdown called twice");
	delete m_shader;
	ASSERT_ONLY(m_shader = NULL;)
}

void CVehicleGlassShader::SetShaderVariables(const CVehicleGlassShaderData& data) const
{
	m_shader->SetVar(m_idVarDiffuseTex              , data.m_DiffuseTex);
	m_shader->SetVar(m_idVarDirtTex                 , data.m_DirtTex);
	m_shader->SetVar(m_idVarSpecularTex             , data.m_SpecularTex);
	m_shader->SetVar(m_idVarSpecularMapIntensityMask, data.m_SpecularMapIntensityMask);
	m_shader->SetVar(m_idVarEnvEffTexTileUV         , data.m_EnvEffTexTileUV);
	m_shader->SetVar(m_idVarEnvEffThickness         , data.m_EnvEffThickness);

	m_shader->SetVar(m_idVarDirtLevelMod            , data.m_DirtLevelMod);
	m_shader->SetVar(m_idVarDirtColor               , data.m_DirtColor);
	m_shader->SetVar(m_idVarDiffuseColorTint        , data.m_DiffuseColorTint);
	m_shader->SetVar(m_idVarEnvEffScale0            , data.m_EnvEffScale0);

#if USE_GPU_VEHICLEDEFORMATION
	if (data.m_bDamageOn && data.m_pDamageTex != NULL)
	{
		grcEffect::SetGlobalVar((grcEffectGlobalVar)m_idVarDamageSwitchOn, true);

		m_shader->SetVar(m_idVarBoundRadius, data.m_fBoundRadius);
		m_shader->SetVar(m_idVarDamageMult, data.m_fDamageMultiplier);
		m_shader->SetVar(m_idVarDamageTex, data.m_pDamageTex);
		m_shader->SetVar(m_idVarOffset, Vector3(0.0, 0.0, 0.0));
	}
	else
	{
		grcEffect::SetGlobalVar((grcEffectGlobalVar)m_idVarDamageSwitchOn, false);
		m_shader->SetVar(m_idVarDamageTex, const_cast<grcTexture*>(grcTexture::NoneBlack));
	}
#endif // USE_GPU_VEHICLEDEFORMATION
}

void CVehicleGlassShader::SetTintVariable(const Vector4& diffuseColorTint) const
{
	m_shader->SetVar(m_idVarDiffuseColorTint, diffuseColorTint);
}

void CVehicleGlassShader::ClearShaderVariables() const
{
	m_shader->SetVar(m_idVarDiffuseTex      , (grcTexture*)NULL);
	m_shader->SetVar(m_idVarDirtTex         , (grcTexture*)NULL);
	m_shader->SetVar(m_idVarSpecularTex     , (grcTexture*)NULL);

#if USE_GPU_VEHICLEDEFORMATION
	grcEffect::SetGlobalVar((grcEffectGlobalVar)m_idVarDamageSwitchOn, false);
	m_shader->SetVar(m_idVarDamageTex       , (grcTexture*)NULL);
#endif // USE_GPU_VEHICLEDEFORMATION
}

void CVehicleGlassShader::SetCrackTextureParams(grcTexture* crackTexture, float amount, float scale, float bumpAmount, float bumpiness, Vec4V_In tint) const
{
	if (m_idVarCrackTexture != grcevNONE)
	{
		m_shader->SetVar(m_idVarCrackTexture, (amount > 0.0f) ? crackTexture : grcTexture::None);
	}

	if (m_idVarCrackTextureParams != grcevNONE)
	{
		const Vec4V params[] =
		{
			Vec4V(amount, scale, bumpAmount, bumpiness),
			tint
		};
		m_shader->SetVar(m_idVarCrackTextureParams, params, NELEM(params));
	}
}

#if CSE_VEHICLE_EDITABLEVALUES
//
//
//
//
void CCustomShaderEffectVehicle::SetEditableShaderValues(grmShaderGroup *pShaderGroup, rmcDrawable* pDrawable)
{
	Assert(pShaderGroup);

	if(ms_bEVSpec2DirLerpOverride)
	{
		Color32 spec2Color = this->GetSpec2Color();
		Vector4 spec2ColorV4(spec2Color.GetRedf(), spec2Color.GetGreenf(), spec2Color.GetBluef(), ms_fEVSpec2DirLerp);
		SetVector4ShaderGroupVar(pShaderGroup,	"Specular2Color",			spec2ColorV4);
	}

	if(!ms_bEVEnabled)
		return;

#if 0
	// old way of doing things:
	if(m_idVarEVSpecFalloff)
		pShaderGroup->SetVar(m_idVarEVSpecFalloff,		ms_fEVSpecFalloff);

	if(m_idVarEVSpecIntensity)
		pShaderGroup->SetVar(m_idVarEVSpecIntensity,	ms_fEVSpecIntensity);

	if(m_idVarEVSpec2Falloff)
		pShaderGroup->SetVar(m_idVarEVSpec2Falloff,		ms_fEVSpec2Falloff);
	// etc., etc.
#endif //#if 0...

	// ... and the new way of setting editable shader variables:
	SetFloatShaderGroupVar(pShaderGroup,	"Fresnel",					ms_fEVSpecFresnel);
	SetFloatShaderGroupVar(pShaderGroup,	"Specular",					ms_fEVSpecFalloff);
	SetFloatShaderGroupVar(pShaderGroup,	"SpecularColor",			ms_fEVSpecIntensity);
	SetFloatShaderGroupVar(pShaderGroup,	"SpecTexTileUV",			ms_fEVSpecTexTileUV);
	SetFloatShaderGroupVar(pShaderGroup,	"Specular2Factor",			ms_fEVSpec2Falloff);
	SetFloatShaderGroupVar(pShaderGroup,	"specular2ColorIntensity",	ms_fEVSpec2Intensity);

	Color32 spec2Color = this->GetSpec2Color();
	Vector4 spec2ColorV4(spec2Color.GetRedf(), spec2Color.GetGreenf(), spec2Color.GetBluef(), ms_fEVSpec2DirLerp);
	SetVector4ShaderGroupVar(pShaderGroup,	"Specular2Color",			spec2ColorV4);

	SetFloatShaderGroupVar(pShaderGroup,	"Reflectivity",				ms_fEVReflectivity);
	SetFloatShaderGroupVar(pShaderGroup,	"Bumpiness",				ms_fEVBumpiness);
	SetFloatShaderGroupVar(pShaderGroup,	"DiffuseTexTileUV",			ms_fEVDiffuseTexTileUV);

	const float dirtModulator = rage::Lerp(rage::Clamp(g_weather.GetWetness(),0.0f,1.0f), ms_fEVDirtModDry, ms_fEVDirtModWet);
	SetVector4ShaderGroupVar(pShaderGroup,	"DirtLevelMod",				Vector4(ms_fEVDirtLevel,dirtModulator,(float)ms_fEVDirtOrBurnout,1.0f));
	SetVector3ShaderGroupVar(pShaderGroup,	"DirtColor",				ms_fEVDirtColor);
	SetFloatShaderGroupVar(pShaderGroup,	"envEffThickness0",			ms_fEVEnvEffThickness);
	SetVector2ShaderGroupVar(pShaderGroup,	"envEffScale0",				Vector2(ms_fEVEnvEffScale, ms_fEVEnvEffScale / 1000.0f));
	SetFloatShaderGroupVar(pShaderGroup,	"envEffTexTileUV",			ms_fEVEnvEffTexTileUV);

	SetVector4ShaderGroupVar(pShaderGroup,	"LetterIndex1",						ms_fEVLetterIndex1);
	SetVector4ShaderGroupVar(pShaderGroup,	"LetterIndex2",						ms_fEVLetterIndex2);
	SetVector2ShaderGroupVar(pShaderGroup,	"LetterSize",						ms_fEVLetterSize);
	SetVector2ShaderGroupVar(pShaderGroup,	"NumLetters",						ms_fEVNumLetters);
	SetVector4ShaderGroupVar(pShaderGroup,	"LicensePlateFontExtents",			ms_fEVLicensePlateFontExtents);
	SetVector4ShaderGroupVar(pShaderGroup,	"LicensePlateFontTint",				ms_fEVLicensePlateFontTint);
	SetFloatShaderGroupVar(pShaderGroup,	"FontNormalScale",					ms_fEVFontNormalScale);
	SetFloatShaderGroupVar(pShaderGroup,	"DistMapCenterVal",					ms_fEVDistMapCenterVal);
	SetVector4ShaderGroupVar(pShaderGroup,	"DistEpsilonScaleMin",				ms_fEVDistEpsilonScaleMin);
	SetVector3ShaderGroupVar(pShaderGroup,	"FontOutlineMinMaxDepthEnabled",	ms_fEVFontOutlineMinMaxDepthEnabled);
	SetVector3ShaderGroupVar(pShaderGroup,	"FontOutlineColor",					ms_fEVFontOutlineColor);

	if(ms_fEVOverrideDiffuseColorTint)
	{
		SetVector4ShaderGroupVar(pShaderGroup, "DiffuseColorTint", Vector4(ms_fEVDiffuseColorTint.x, ms_fEVDiffuseColorTint.y, ms_fEVDiffuseColorTint.z, ms_fEVDiffuseColorTintAlpha) );
	}

	// set body color 0:
	CCustomShaderEffectVehicleType::structDiffColEffect *ptr = &GetCseTypeInternal()->m_DiffColEffect[0];
	if(ms_fEVOverrideBodyColor)
	{
		pDrawable->GetShaderGroup().GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffColor, ms_fEVBodyColor);
	}
	else
	{
		pDrawable->GetShaderGroup().GetShader(ptr->shaderIdx).SetVar((grcEffectVar)ptr->idvarDiffColor, m_varDifCol[ptr->colorIdx]);
	}

}// end of SetEditableShaderValues()...


//
//
//
//
bool CCustomShaderEffectVehicle::InitWidgets(bkBank& bank)
{
	// debug widgets:
	bank.PushGroup("Vehicle Editable Inner Tyre Radius", false);
		bank.AddToggle("Enable",				&ms_bEWREnabled);
		bank.AddToggle("Tyre rendering enable",	&ms_bEWRTyreEnabled);
		bank.AddSlider("Inner radius (divide it by 10 for real value)",	&ms_fEWRInnerRadius,	0.0f, 50.0f, 0.001f);
	bank.PopGroup();

	bank.PushGroup("Vehicle Editable Shaders Values", false);
		bank.AddToggle("Enable",									&ms_bEVEnabled);
		bank.AddSlider("Specular falloff",							&ms_fEVSpecFalloff,		0.0f, 512.0f, 0.1f);
		bank.AddSlider("Specular Fresnel",							&ms_fEVSpecFresnel,		0.0f, 1.0f, 0.01f);
		bank.AddSlider("Specular intensity",						&ms_fEVSpecIntensity,	0.0f, 1.0f, 0.01f);
		bank.AddSlider("Spec Texture TileUV",						&ms_fEVSpecTexTileUV,	1.0f, 32.0f, 0.1f);
		bank.AddSlider("Specular 2 falloff",						&ms_fEVSpec2Falloff,	0.0f, 512.0f, 0.1f);
		bank.AddSlider("Specular 2 intensity",						&ms_fEVSpec2Intensity,	0.0f, 3.0f, 0.1f);
		bank.AddSlider("Specular 2 dir (0=GlobalDirLight, 1=Up)",	&ms_fEVSpec2DirLerp,	0.0f, 1.0f, 0.01f);
		bank.AddSlider("Reflectivity",								&ms_fEVReflectivity,	0, 100.0f, 0.1f);
		bank.AddSlider("Bumpiness",									&ms_fEVBumpiness,		0, 10.0f, 0.01f);

		bank.AddToggle("Override Body Color",			&ms_fEVOverrideBodyColor);
		bank.AddColor("Body Color 0",					&ms_fEVBodyColor);

		bank.AddToggle("Override Diffuse Color Tint",	&ms_fEVOverrideDiffuseColorTint);
		bank.AddColor("Diffuse Tint RGB",				&ms_fEVDiffuseColorTint);
		bank.AddSlider("Diffuse Tint Alpha",			&ms_fEVDiffuseColorTintAlpha,	0.0f, 1.0f, 0.01f);

		bank.AddSlider("Diffuse Texture TileUV",		&ms_fEVDiffuseTexTileUV,	1.0f, 32.0f, 0.1f);
		bank.AddSlider("Dirt Level",					&ms_fEVDirtLevel,			0.0f, 1.0f, 0.1f);
		bank.AddSlider("Dirt Color Intensity (Dry)",	&ms_fEVDirtModDry,			0.0f, 1.0f, 0.1f);
		bank.AddSlider("Dirt Color Intensity (Wet)",	&ms_fEVDirtModWet,			0.0f, 1.0f, 0.1f);
		bank.AddSlider("Mode: Dirt (1) / Burnout (0)",	&ms_fEVDirtOrBurnout,		0, 1, 1);
		bank.AddColor("Dirt Color",						&ms_fEVDirtColor);

		bank.AddSlider("EnvEff: Scale",					&ms_fEVEnvEffScale,		0.0f, 1.0f, 0.1f);
		bank.AddSlider("EnvEff: Thickness",				&ms_fEVEnvEffThickness,	0.0f, 100.0f, 0.1f);
		bank.AddSlider("EnvEff: Texture TileUV",		&ms_fEVEnvEffTexTileUV,	1.0f, 32.0f, 0.1f);

		bank.PushGroup("2nd Spec Direction");
			bank.AddToggle("Override",									&ms_bEVSpec2DirLerpOverride);
			bank.AddSlider("Spec 2 direction (0=GlobalDirLight, 1=Up)",	&ms_fEVSpec2DirLerp,	0.0f, 1.0f, 0.01f);
		bank.PopGroup();

		bank.PushGroup("Plate:", false);
			bank.AddSlider("LetterIndex1",					&ms_fEVLetterIndex1,					0.0f, 255.0f, 1.0f);
			bank.AddSlider("LetterIndex2",					&ms_fEVLetterIndex2,					0.0f, 255.0f, 1.0f);
			bank.AddSlider("LetterSize",					&ms_fEVLetterSize,						0.0f, 1.0f, 0.1f);
			bank.AddSlider("NumLetters",					&ms_fEVNumLetters,						0.0f, 255.0f, 1.0f);
			bank.AddSlider("LicensePlateFontExtents",		&ms_fEVLicensePlateFontExtents,			0.0f, 1.0f,0.1f);
			bank.AddColor( "LicensePlateFontTint",			&ms_fEVLicensePlateFontTint);
			bank.AddSlider("FontNormalScale",				&ms_fEVFontNormalScale,					0.0f, 100.0f, 0.1f);
			bank.AddSlider("DistMapCenterVal",				&ms_fEVDistMapCenterVal,				0.0f, 1.0f, 0.1f);
			bank.AddSlider("DistEpsilonScaleMin",			&ms_fEVDistEpsilonScaleMin,				0.0f, 50.0f, 1.0f);
			bank.AddSlider("FontOutlineMinMaxDepthEnabled",	&ms_fEVFontOutlineMinMaxDepthEnabled,	0.0f, 1.0f, 0.1f);
			bank.AddColor( "FontOutlineColor",				&ms_fEVFontOutlineColor);
		bank.PopGroup();
	bank.PopGroup();

	bank.PushGroup("Vehicle Burnout VFX", false);
		bank.AddSlider("Burnout VFX speed",					&ms_fEVBurnoutSpeed,				1.0f/255.0f, 1.0f, 1.0f/255.0f);
	bank.PopGroup();

	bank.PushGroup("Vehicle Sun Glare Fx", false);
		bank.AddToggle("Enable",				&ms_bEVSunGlareEnabled);
		bank.AddSlider("Fade min distance",		&ms_fEVSunGlareDistMin,				0.0f, 100.0f, 0.1f);
		bank.AddSlider("Fade max distance",		&ms_fEVSunGlareDistMax,				0.0f, 100.0f, 0.1f);
		bank.AddSlider("Sun glare spec power",	&ms_nEVSunGlarePow,					1, 96, 1);
		bank.AddSlider("Sprite size",			&ms_fEVSunGlareSpriteSize,			0.0f, 2.0f, 0.01f);
		bank.AddSlider("Sprite Z shift scale",	&ms_fEVSunGlareSpriteZShiftScale,	0.0f, 1.0f, 0.05f);
		bank.AddSlider("Sprite intensity",		&ms_fEVSunGlareHdrMult,				0.0f, 16.0f, 0.1f);
	bank.PopGroup();

#if VEHICLE_SUPPORT_PAINT_RAMP
	bank.PushGroup("Vehicle Chameleon Paint");
		bank.AddToggle("Enable Debug Ramp", &s_DebugRampTextureEnabled, ReloadDebugRampTexture);
		bank.AddText("Debug Ramp Path", &s_DebugRampTexturePath[0], sizeof(s_DebugRampTexturePath) - 1, false, ReloadDebugRampTexture);
		bank.AddButton("Reload Debug Ramp", ReloadDebugRampTexture);
		bank.AddToggle("Diffuse Ramp Enabled", &s_RampDiffuseEnabled);
		bank.AddToggle("Specular Ramp Enabled", &s_RampSpecularEnabled);
	bank.PopGroup();
#endif

	return(TRUE);
}// end of InitWidgets()...
#endif //CSE_VEHICLE_EDITABLEVALUES...