Re3/src/render/Shadows.cpp

#include "common.h"

#include "main.h"
#include "TxdStore.h"
#include "Timer.h"
#include "Camera.h"
#include "Timecycle.h"
#include "CutsceneMgr.h"
#include "Automobile.h"
#include "Ped.h"
#include "PlayerPed.h"
#include "World.h"
#include "Weather.h"
#include "ModelIndices.h"
#include "RenderBuffer.h"
#ifdef FIX_BUGS
#include "Replay.h"
#endif
#include "PointLights.h"
#include "SpecialFX.h"
#include "Shadows.h"

SETTWEAKPATH("Shadows");
TWEAKBOOL(gbPrintShite);

RwImVertexIndex ShadowIndexList[24];

RwTexture *gpShadowCarTex;
RwTexture *gpShadowPedTex;
RwTexture *gpShadowHeliTex;
RwTexture *gpShadowExplosionTex;
RwTexture *gpShadowHeadLightsTex;
RwTexture *gpOutline1Tex;
RwTexture *gpOutline2Tex;
RwTexture *gpOutline3Tex;
RwTexture *gpBloodPoolTex;
RwTexture *gpReflectionTex;
RwTexture *gpGoalMarkerTex;
RwTexture *gpWalkDontTex;
RwTexture *gpCrackedGlassTex;
RwTexture *gpPostShadowTex;
RwTexture *gpGoalTex;

int16            CShadows::ShadowsStoredToBeRendered;
CStoredShadow    CShadows::asShadowsStored  [MAX_STOREDSHADOWS];
CPolyBunch       CShadows::aPolyBunches     [MAX_POLYBUNCHES];
CStaticShadow    CShadows::aStaticShadows   [MAX_STATICSHADOWS];
CPolyBunch      *CShadows::pEmptyBunchList;
CPermanentShadow CShadows::aPermanentShadows[MAX_PERMAMENTSHADOWS];


void
CShadows::Init(void)
{
	CTxdStore::PushCurrentTxd();

	int32 slut = CTxdStore::FindTxdSlot("particle");
	CTxdStore::SetCurrentTxd(slut);

	gpShadowCarTex        = RwTextureRead("shad_car",     NULL);
	gpShadowPedTex        = RwTextureRead("shad_ped",     NULL);
	gpShadowHeliTex       = RwTextureRead("shad_heli",    NULL);
	gpShadowExplosionTex  = RwTextureRead("shad_exp",     NULL);
	gpShadowHeadLightsTex = RwTextureRead("headlight",    NULL);
	gpOutline1Tex         = RwTextureRead("outline_64",   NULL);
	gpOutline2Tex         = RwTextureRead("outline2_64",  NULL);
	gpOutline3Tex         = RwTextureRead("outline3_64",  NULL);
	gpBloodPoolTex        = RwTextureRead("bloodpool_64", NULL);
	gpReflectionTex       = RwTextureRead("reflection01", NULL);
	gpGoalMarkerTex       = RwTextureRead("goal",         NULL);
	gpWalkDontTex         = RwTextureRead("walk_dont",    NULL);
	gpCrackedGlassTex     = RwTextureRead("wincrack_32",  NULL);
	gpPostShadowTex       = RwTextureRead("lamp_shad_64", NULL);

	CTxdStore::PopCurrentTxd();

	ASSERT(gpShadowCarTex != NULL);
	ASSERT(gpShadowPedTex != NULL);
	ASSERT(gpShadowHeliTex != NULL);
	ASSERT(gpShadowExplosionTex != NULL);
	ASSERT(gpShadowHeadLightsTex != NULL);
	ASSERT(gpOutline1Tex != NULL);
	ASSERT(gpOutline2Tex != NULL);
	ASSERT(gpOutline3Tex != NULL);
	ASSERT(gpBloodPoolTex != NULL);
	ASSERT(gpReflectionTex != NULL);
	ASSERT(gpGoalMarkerTex != NULL);
	ASSERT(gpWalkDontTex != NULL);
	ASSERT(gpCrackedGlassTex != NULL);
	ASSERT(gpPostShadowTex != NULL);


	ShadowIndexList[0] = 0;
	ShadowIndexList[1] = 2;
	ShadowIndexList[2] = 1;

	ShadowIndexList[3] = 0;
	ShadowIndexList[4] = 3;
	ShadowIndexList[5] = 2;

	ShadowIndexList[6] = 0;
	ShadowIndexList[7] = 4;
	ShadowIndexList[8] = 3;

	ShadowIndexList[9] = 0;
	ShadowIndexList[10] = 5;
	ShadowIndexList[11] = 4;

	ShadowIndexList[12] = 0;
	ShadowIndexList[13] = 6;
	ShadowIndexList[14] = 5;

	ShadowIndexList[15] = 0;
	ShadowIndexList[16] = 7;
	ShadowIndexList[17] = 6;

	ShadowIndexList[18] = 0;
	ShadowIndexList[19] = 8;
	ShadowIndexList[20] = 7;

	ShadowIndexList[21] = 0;
	ShadowIndexList[22] = 9;
	ShadowIndexList[23] = 8;


	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
	{
		aStaticShadows[i].m_nId = 0;
		aStaticShadows[i].m_pPolyBunch = NULL;
	}

	pEmptyBunchList = &aPolyBunches[0];

	for ( int32 i = 0; i < MAX_POLYBUNCHES; i++ )
	{
		if ( i == MAX_POLYBUNCHES - 1 )
			aPolyBunches[i].m_pNext = NULL;
		else
			aPolyBunches[i].m_pNext = &aPolyBunches[i + 1];
	}

	for ( int32 i = 0; i < MAX_PERMAMENTSHADOWS; i++ )
	{
		aPermanentShadows[i].m_nType = SHADOWTYPE_NONE;
	}
}

void
CShadows::Shutdown(void)
{
	ASSERT(gpShadowCarTex != NULL);
	ASSERT(gpShadowPedTex != NULL);
	ASSERT(gpShadowHeliTex != NULL);
	ASSERT(gpShadowExplosionTex != NULL);
	ASSERT(gpShadowHeadLightsTex != NULL);
	ASSERT(gpOutline1Tex != NULL);
	ASSERT(gpOutline2Tex != NULL);
	ASSERT(gpOutline3Tex != NULL);
	ASSERT(gpBloodPoolTex != NULL);
	ASSERT(gpReflectionTex != NULL);
	ASSERT(gpGoalMarkerTex != NULL);
	ASSERT(gpWalkDontTex != NULL);
	ASSERT(gpCrackedGlassTex != NULL);
	ASSERT(gpPostShadowTex != NULL);

	RwTextureDestroy(gpShadowCarTex);
	RwTextureDestroy(gpShadowPedTex);
	RwTextureDestroy(gpShadowHeliTex);
	RwTextureDestroy(gpShadowExplosionTex);
	RwTextureDestroy(gpShadowHeadLightsTex);
	RwTextureDestroy(gpOutline1Tex);
	RwTextureDestroy(gpOutline2Tex);
	RwTextureDestroy(gpOutline3Tex);
	RwTextureDestroy(gpBloodPoolTex);
	RwTextureDestroy(gpReflectionTex);
	RwTextureDestroy(gpGoalMarkerTex);
	RwTextureDestroy(gpWalkDontTex);
	RwTextureDestroy(gpCrackedGlassTex);
	RwTextureDestroy(gpPostShadowTex);
}

void
CShadows::AddPermanentShadow(uint8 ShadowType, RwTexture *pTexture, CVector *pPosn,
							float fFrontX, float fFrontY, float fSideX, float fSideY,
							int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
							float fZDistance, uint32 nTime, float fScale)
{
	ASSERT(pTexture != NULL);
	ASSERT(pPosn != NULL);


	// find free slot
	int32 nSlot = 0;
	while ( nSlot < MAX_PERMAMENTSHADOWS && aPermanentShadows[nSlot].m_nType != SHADOWTYPE_NONE )
		nSlot++;

	if ( nSlot < MAX_PERMAMENTSHADOWS )
	{
		aPermanentShadows[nSlot].m_nType        = ShadowType;
		aPermanentShadows[nSlot].m_pTexture     = pTexture;
		aPermanentShadows[nSlot].m_vecPos       = *pPosn;
		aPermanentShadows[nSlot].m_vecFront.x   = fFrontX;
		aPermanentShadows[nSlot].m_vecFront.y   = fFrontY;
		aPermanentShadows[nSlot].m_vecSide.x    = fSideX;
		aPermanentShadows[nSlot].m_vecSide.y    = fSideY;
		aPermanentShadows[nSlot].m_nIntensity   = nIntensity;
		aPermanentShadows[nSlot].m_nRed         = nRed;
		aPermanentShadows[nSlot].m_nGreen       = nGreen;
		aPermanentShadows[nSlot].m_nBlue        = nBlue;
		aPermanentShadows[nSlot].m_fZDistance   = fZDistance;
		aPermanentShadows[nSlot].m_nLifeTime    = nTime;
		aPermanentShadows[nSlot].m_nTimeCreated = CTimer::GetTimeInMilliseconds();
	}
}

void
CShadows::StoreStaticShadow(uint32 nID, uint8 ShadowType, RwTexture *pTexture, Const CVector *pPosn,
							float fFrontX, float fFrontY, float fSideX, float fSideY,
							int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
							float fZDistance, float fScale, float fDrawDistance, bool bTempShadow, float fUpDistance)
{
	ASSERT(pPosn != NULL);

	float fDistToCamSqr = (*pPosn - TheCamera.GetPosition()).MagnitudeSqr2D();

	if ( SQR(fDrawDistance) > fDistToCamSqr)
	{
		float fDistToCam = Sqrt(fDistToCamSqr);

		if ( fDistToCam >= (fDrawDistance*(1.0f-(1.0f/4.0f))) )
		{
			//fDistToCam == 0             -> 4
			//fDistToCam == fDrawDistance -> 0
			float fMult = 1.0f - (4.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f-(1.0f/4.0f))));

			nIntensity = (int32)(nIntensity * fMult);
			nRed       = (int32)(nRed       * fMult);
			nGreen     = (int32)(nGreen     * fMult);
			nBlue      = (int32)(nBlue      * fMult);
		}

		int32 nSlot;

		nSlot = 0;
		while ( nSlot < MAX_STATICSHADOWS && !(nID == aStaticShadows[nSlot].m_nId && aStaticShadows[nSlot].m_pPolyBunch != NULL) )
			nSlot++;

		if ( nSlot < MAX_STATICSHADOWS )
		{
			if (   Abs(pPosn->x - aStaticShadows[nSlot].m_vecPosn.x) < fUpDistance
				&& Abs(pPosn->y - aStaticShadows[nSlot].m_vecPosn.y) < fUpDistance )
			{
				aStaticShadows[nSlot].m_bJustCreated     = true;
				aStaticShadows[nSlot].m_nType            = ShadowType;
				aStaticShadows[nSlot].m_pTexture         = pTexture;
				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
				aStaticShadows[nSlot].m_nRed             = nRed;
				aStaticShadows[nSlot].m_nGreen           = nGreen;
				aStaticShadows[nSlot].m_nBlue            = nBlue;
				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
				aStaticShadows[nSlot].m_fScale           = fScale;
				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();
			}
            else if (  Abs(pPosn->x - aStaticShadows[nSlot].m_vecPosn.x) < 0.05f
					&& Abs(pPosn->y - aStaticShadows[nSlot].m_vecPosn.y) < 0.05f
					&& Abs(pPosn->z - aStaticShadows[nSlot].m_vecPosn.z) < 2.0f

					&& fFrontX == aStaticShadows[nSlot].m_vecFront.x
					&& fFrontY == aStaticShadows[nSlot].m_vecFront.y
					&& fSideX  == aStaticShadows[nSlot].m_vecSide.x
					&& fSideY  == aStaticShadows[nSlot].m_vecSide.y )
			{
				aStaticShadows[nSlot].m_bJustCreated     = true;
				aStaticShadows[nSlot].m_nType            = ShadowType;
				aStaticShadows[nSlot].m_pTexture         = pTexture;
				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
				aStaticShadows[nSlot].m_nRed             = nRed;
				aStaticShadows[nSlot].m_nGreen           = nGreen;
				aStaticShadows[nSlot].m_nBlue            = nBlue;
				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
				aStaticShadows[nSlot].m_fScale           = fScale;
				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();
			}
			else
			{
				aStaticShadows[nSlot].Free();

				aStaticShadows[nSlot].m_nId              = nID;
				aStaticShadows[nSlot].m_nType            = ShadowType;
				aStaticShadows[nSlot].m_pTexture         = pTexture;
				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
				aStaticShadows[nSlot].m_nRed             = nRed;
				aStaticShadows[nSlot].m_nGreen           = nGreen;
				aStaticShadows[nSlot].m_nBlue            = nBlue;
				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
				aStaticShadows[nSlot].m_fScale           = fScale;
				aStaticShadows[nSlot].m_vecPosn          = *pPosn;
				aStaticShadows[nSlot].m_vecFront.x       = fFrontX;
				aStaticShadows[nSlot].m_vecFront.y       = fFrontY;
				aStaticShadows[nSlot].m_vecSide.x        = fSideX;
				aStaticShadows[nSlot].m_vecSide.y        = fSideY;
				aStaticShadows[nSlot].m_bJustCreated     = true;
				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();

				GeneratePolysForStaticShadow(nSlot);
			}
		}
		else
		{
			nSlot = 0;
			while ( nSlot < MAX_STATICSHADOWS && aStaticShadows[nSlot].m_pPolyBunch != NULL )
				nSlot++;

			if ( nSlot != MAX_STATICSHADOWS )
			{
				aStaticShadows[nSlot].m_nId              = nID;
				aStaticShadows[nSlot].m_nType            = ShadowType;
				aStaticShadows[nSlot].m_pTexture         = pTexture;
				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
				aStaticShadows[nSlot].m_nRed             = nRed;
				aStaticShadows[nSlot].m_nGreen           = nGreen;
				aStaticShadows[nSlot].m_nBlue            = nBlue;
				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
				aStaticShadows[nSlot].m_fScale           = fScale;
				aStaticShadows[nSlot].m_vecPosn          = *pPosn;
				aStaticShadows[nSlot].m_vecFront.x       = fFrontX;
				aStaticShadows[nSlot].m_vecFront.y       = fFrontY;
				aStaticShadows[nSlot].m_vecSide.x        = fSideX;
				aStaticShadows[nSlot].m_vecSide.y        = fSideY;
				aStaticShadows[nSlot].m_bJustCreated     = true;
				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();

				GeneratePolysForStaticShadow(nSlot);
			}
		}
	}
}

void
CShadows::StoreShadowToBeRendered(uint8 ShadowTexture, CVector *pPosn,
								float fFrontX, float fFrontY, float fSideX, float fSideY,
								int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue)
{
	ASSERT(pPosn != NULL);

	switch ( ShadowTexture )
	{
		case SHADOWTEX_NONE:
		{
			break;
		}

		case SHADOWTEX_CAR:
		{
			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, pPosn,
					fFrontX, fFrontY, fSideX, fSideY,
					nIntensity, nRed, nGreen, nBlue,
					15.0f, false, 1.0f);

			break;
		}

		case SHADOWTEX_PED:
		{
			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowPedTex, pPosn,
					fFrontX, fFrontY, fSideX, fSideY,
					nIntensity, nRed, nGreen, nBlue,
					15.0f, false, 1.0f);

			break;
		}

		case SHADOWTEX_EXPLOSION:
		{
			StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowExplosionTex, pPosn,
					fFrontX, fFrontY, fSideX, fSideY,
					nIntensity, nRed, nGreen, nBlue,
					15.0f, false, 1.0f);

			break;
		}

		case SHADOWTEX_HELI:
		{
			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowHeliTex, pPosn,
					fFrontX, fFrontY, fSideX, fSideY,
					nIntensity, nRed, nGreen, nBlue,
					15.0f, false, 1.0f);

			break;
		}

		case SHADOWTEX_HEADLIGHTS:
		{
			StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowHeadLightsTex, pPosn,
					fFrontX, fFrontY, fSideX, fSideY,
					nIntensity, nRed, nGreen, nBlue,
					15.0f, false, 1.0f);

			break;
		}

		case SHADOWTEX_BLOOD:
		{
			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpBloodPoolTex, pPosn,
					fFrontX, fFrontY, fSideX, fSideY,
					nIntensity, nRed, nGreen, nBlue,
					15.0f, false, 1.0f);

			break;
		}
	}

	//ASSERT(false);
}

void
CShadows::StoreShadowToBeRendered(uint8 ShadowType, RwTexture *pTexture, CVector *pPosn,
								float fFrontX, float fFrontY, float fSideX, float fSideY,
								int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
								float fZDistance, bool bDrawOnWater, float fScale)
{
	ASSERT(pTexture != NULL);
	ASSERT(pPosn != NULL);

	if ( ShadowsStoredToBeRendered < MAX_STOREDSHADOWS )
	{
		asShadowsStored[ShadowsStoredToBeRendered].m_ShadowType          = ShadowType;
		asShadowsStored[ShadowsStoredToBeRendered].m_pTexture            = pTexture;
		asShadowsStored[ShadowsStoredToBeRendered].m_vecPos              = *pPosn;
		asShadowsStored[ShadowsStoredToBeRendered].m_vecFront.x          = fFrontX;
		asShadowsStored[ShadowsStoredToBeRendered].m_vecFront.y          = fFrontY;
		asShadowsStored[ShadowsStoredToBeRendered].m_vecSide.x           = fSideX;
		asShadowsStored[ShadowsStoredToBeRendered].m_vecSide.y           = fSideY;
		asShadowsStored[ShadowsStoredToBeRendered].m_nIntensity          = nIntensity;
		asShadowsStored[ShadowsStoredToBeRendered].m_nRed                = nRed;
		asShadowsStored[ShadowsStoredToBeRendered].m_nGreen              = nGreen;
		asShadowsStored[ShadowsStoredToBeRendered].m_nBlue               = nBlue;
		asShadowsStored[ShadowsStoredToBeRendered].m_fZDistance          = fZDistance;
		asShadowsStored[ShadowsStoredToBeRendered].m_nFlags.bDrawOnWater = bDrawOnWater;
		asShadowsStored[ShadowsStoredToBeRendered].m_fScale              = fScale;

		ShadowsStoredToBeRendered++;
	}
}

void
CShadows::StoreShadowForCar(CAutomobile *pCar)
{
	ASSERT(pCar != NULL);

	if ( CTimeCycle::GetShadowStrength() != 0 )
	{
		CVector CarPos = pCar->GetPosition();
		float fDistToCamSqr = (CarPos - TheCamera.GetPosition()).MagnitudeSqr();

		if ( CCutsceneMgr::IsRunning() )
			fDistToCamSqr /= SQR(TheCamera.LODDistMultiplier) * 4.0f;

		float fDrawDistance = 18.0f;

		if ( fDistToCamSqr < SQR(fDrawDistance) )
		{
			float fDistToCam = Sqrt(fDistToCamSqr);
			
			//fDistToCam == 0             -> 4
			//fDistToCam == fDrawDistance -> 0
			float fMult = 1.0f - (4.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f-(1.0f/4.0f))) );

			int32 nColorStrength;

			if ( fDistToCam >= (fDrawDistance*(1.0f-(1.0f/4.0f))) )
				nColorStrength = (int32)(CTimeCycle::GetShadowStrength() * fMult);
			else
				nColorStrength = CTimeCycle::GetShadowStrength();

			float fVehicleHeight  = pCar->GetColModel()->boundingBox.GetSize().y;
			float fVehicleWidth   = pCar->GetColModel()->boundingBox.GetSize().x;

			if ( pCar->GetModelIndex() == MI_DODO )
			{
				fVehicleHeight *= 0.9f;
				fVehicleWidth  *= 0.4f;
			}

			CarPos.x -= pCar->GetForward().x * ((fVehicleHeight / 2) - pCar->GetColModel()->boundingBox.max.y);
			CarPos.y -= pCar->GetForward().y * ((fVehicleHeight / 2) - pCar->GetColModel()->boundingBox.max.y);

			if ( pCar->GetUp().z > 0.0f )
			{
				StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &CarPos,
					pCar->GetForward().x * (fVehicleHeight / 2),
					pCar->GetForward().y * (fVehicleHeight / 2),
					pCar->GetRight().x   * (fVehicleWidth  / 2),
					pCar->GetRight().y   * (fVehicleWidth  / 2),
					nColorStrength, nColorStrength, nColorStrength, nColorStrength,
					4.5f, false, 1.0f);
			}
			else
			{
				StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &CarPos,
					pCar->GetForward().x * (fVehicleHeight / 2),
					pCar->GetForward().y * (fVehicleHeight / 2),
					-pCar->GetRight().x  * (fVehicleWidth  / 2),
					-pCar->GetRight().y  * (fVehicleWidth  / 2),
					nColorStrength, nColorStrength, nColorStrength, nColorStrength,
					4.5f, false, 1.0f);
			}
		}
	}
}

void
CShadows::StoreCarLightShadow(CAutomobile *pCar, int32 nID, RwTexture *pTexture, CVector *pPosn,
							float fFrontX, float fFrontY, float fSideX, float fSideY, uint8 nRed, uint8 nGreen, uint8 nBlue,
							float fMaxViewAngle)
{
	ASSERT(pCar != NULL);
	ASSERT(pPosn != NULL);

	float fDistToCamSqr = (*pPosn - TheCamera.GetPosition()).MagnitudeSqr2D();

	bool bSpecialCam =     TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN
						|| TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED
						|| CCutsceneMgr::IsRunning();

	float fDrawDistance = 27.0f;

	if ( fDistToCamSqr < SQR(fDrawDistance) || bSpecialCam )
	{
		if ( bSpecialCam || DotProduct2D(CVector2D(TheCamera.CamFrontXNorm, TheCamera.CamFrontYNorm),
											*pPosn - TheCamera.GetPosition() ) > -fMaxViewAngle )
		{
			float fDistToCam = Sqrt(fDistToCamSqr);

			if ( fDistToCam >= (fDrawDistance*(1.0f-(1.0f/4.0f))) && !bSpecialCam ) // BUG? must be 3.0?
			{
				//fDistToCam == 0             -> 3
				//fDistToCam == fDrawDistance -> 0
				float fMult = 1.0f - (3.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f-(1.0f/3.0f))) );

				nRed   = (int32)(nRed   * fMult);
				nGreen = (int32)(nGreen * fMult);
				nBlue  = (int32)(nBlue  * fMult);
			}

			StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, pTexture, pPosn,
					fFrontX, fFrontY,
					fSideX, fSideY,
					128, nRed, nGreen, nBlue,
					6.0f, false, 1.0f);

		}
	}
}

void
CShadows::StoreShadowForPed(CPed *pPed, float fDisplacementX, float fDisplacementY,
							float fFrontX, float fFrontY, float fSideX, float fSideY)
{
	ASSERT(pPed != NULL);

	if ( pPed->bIsVisible )
	{
		if ( !(pPed->bInVehicle && pPed->m_nPedState != PED_DRAG_FROM_CAR && pPed->m_nPedState != PED_EXIT_CAR) )
		{
			if ( CTimeCycle::GetShadowStrength() != 0 )
				StoreShadowForPedObject(pPed,
					fDisplacementX, fDisplacementY,
					fFrontX, fFrontY,
					fSideX, fSideY);
		}
	}
}

void
CShadows::StoreShadowForPedObject(CEntity *pPedObject, float fDisplacementX, float fDisplacementY,
								float fFrontX, float fFrontY, float fSideX, float fSideY)
{
	ASSERT(pPedObject != NULL);

	CVector PedPos = pPedObject->GetPosition();

	float fDistToCamSqr = (PedPos - TheCamera.GetPosition()).MagnitudeSqr2D();

	float fDrawDistance = 26.0f;

	if ( fDistToCamSqr < SQR(fDrawDistance*0.5f)/*?*/ )
	{
		if ( pPedObject == FindPlayerPed() || TheCamera.IsSphereVisible(PedPos, 2.0f) != false )
		{
			float fDistToCam = Sqrt(fDistToCamSqr);

			//fDistToCam == 0             ->  2
			//fDistToCam == fDrawDistance -> -2
			float fMult = 1.0f - (4.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f/4.0f))); // BUG ? negative
			int32 nColorStrength;

			if ( fDistToCam >= (fDrawDistance*(1.0f/4.0f)) ) // BUG ? negative
				nColorStrength = (int32)(CTimeCycle::GetShadowStrength() * fMult);
			else
				nColorStrength = CTimeCycle::GetShadowStrength();

			PedPos.x += fDisplacementX;
			PedPos.y += fDisplacementY;

			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowPedTex, &PedPos,
					fFrontX, fFrontY,
					fSideX, fSideY,
					nColorStrength, nColorStrength, nColorStrength, nColorStrength,
					4.0f, false, 1.0f);
		}
	}
}

void
CShadows::StoreShadowForTree(CEntity *pTree)
{
	ASSERT(pTree != NULL);
}

void
CShadows::StoreShadowForPole(CEntity *pPole, float fOffsetX, float fOffsetY, float fOffsetZ,
								float fPoleHeight, float fPoleWidth, uint32 nID)
{
	ASSERT(pPole != NULL);

	if ( CTimeCycle::GetShadowStrength() != 0 )
	{
		if ( pPole->GetUp().z < 0.5f )
			return;

		CVector PolePos = pPole->GetPosition();

		PolePos.x += fOffsetX * pPole->GetRight().x + fOffsetY * pPole->GetForward().x;
		PolePos.y += fOffsetX * pPole->GetRight().y + fOffsetY * pPole->GetForward().y;
		PolePos.z += fOffsetZ;

		PolePos.x += -CTimeCycle::GetSunPosition().x * (fPoleHeight / 2);
		PolePos.y += -CTimeCycle::GetSunPosition().y * (fPoleHeight / 2);

		StoreStaticShadow((uint32)pPole + nID + _TODOCONST(51), SHADOWTYPE_DARK, gpPostShadowTex, &PolePos,
				-CTimeCycle::GetSunPosition().x * (fPoleHeight / 2),
				-CTimeCycle::GetSunPosition().y * (fPoleHeight / 2),
				CTimeCycle::GetShadowSideX()    * fPoleWidth,
				CTimeCycle::GetShadowSideY()    * fPoleWidth,
				2 * (int32)((pPole->GetUp().z - 0.5f) * CTimeCycle::GetShadowStrength() * 2.0f) / 3,
				0, 0, 0,
				15.0f, 1.0f, 40.0f, false, 0.0f);
	}
}

void
CShadows::SetRenderModeForShadowType(uint8 ShadowType)
{
	switch ( ShadowType )
	{
		case SHADOWTYPE_DARK:
		{
			RwRenderStateSet(rwRENDERSTATESRCBLEND,  (void *)rwBLENDSRCALPHA);
			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
			break;
		}

		case SHADOWTYPE_ADDITIVE:
		{
			RwRenderStateSet(rwRENDERSTATESRCBLEND,  (void *)rwBLENDONE);
			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDONE);
			break;
		}

		case SHADOWTYPE_INVCOLOR:
		{
			RwRenderStateSet(rwRENDERSTATESRCBLEND,  (void *)rwBLENDZERO);
			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCCOLOR);
			break;
		}
	}
}

void
CShadows::RenderStoredShadows(void)
{
	RenderBuffer::ClearRenderBuffer();

	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)FALSE);
	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)TRUE);
	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);

	for ( int32 i = 0; i < ShadowsStoredToBeRendered; i++ )
		asShadowsStored[i].m_nFlags.bRendered = false;

	for ( int32 i = 0; i < ShadowsStoredToBeRendered; i++ )
	{
		if ( !asShadowsStored[i].m_nFlags.bRendered )
		{
			SetRenderModeForShadowType(asShadowsStored[i].m_ShadowType);

			ASSERT(asShadowsStored[i].m_pTexture != NULL);

			RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(asShadowsStored[i].m_pTexture));

			for ( int32 j = i; j < ShadowsStoredToBeRendered; j++ )
			{
				if ( asShadowsStored[i].m_ShadowType   == asShadowsStored[j].m_ShadowType
					&& asShadowsStored[i].m_pTexture == asShadowsStored[j].m_pTexture )
				{
					float fWidth  = Abs(asShadowsStored[j].m_vecFront.x) + Abs(asShadowsStored[j].m_vecSide.x);
					float fHeight = Abs(asShadowsStored[j].m_vecFront.y) + Abs(asShadowsStored[j].m_vecSide.y);

					CVector shadowPos = asShadowsStored[j].m_vecPos;

					float fStartX = shadowPos.x - fWidth;
					float fEndX   = shadowPos.x + fWidth;
					float fStartY = shadowPos.y - fHeight;
					float fEndY   = shadowPos.y + fHeight;

					int32 nStartX = Max(CWorld::GetSectorIndexX(fStartX), 0);
					int32 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
					int32 nEndX   = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X-1);
					int32 nEndY   = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y-1);

					CWorld::AdvanceCurrentScanCode();

					for ( int32 y = nStartY; y <= nEndY; y++ )
					{
						for ( int32 x = nStartX; x <= nEndX; x++ )
						{
							CSector *pCurSector = CWorld::GetSector(x, y);

							ASSERT(pCurSector != NULL);

							CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS],
									fStartX, fStartY,
									fEndX, fEndY,
									&shadowPos,
									asShadowsStored[j].m_vecFront.x,
									asShadowsStored[j].m_vecFront.y,
									asShadowsStored[j].m_vecSide.x,
									asShadowsStored[j].m_vecSide.y,
									asShadowsStored[j].m_nIntensity,
									asShadowsStored[j].m_nRed,
									asShadowsStored[j].m_nGreen,
									asShadowsStored[j].m_nBlue,
									asShadowsStored[j].m_fZDistance,
									asShadowsStored[j].m_fScale,
									NULL);

							CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP],
									fStartX, fStartY,
									fEndX, fEndY,
									&shadowPos,
									asShadowsStored[j].m_vecFront.x,
									asShadowsStored[j].m_vecFront.y,
									asShadowsStored[j].m_vecSide.x,
									asShadowsStored[j].m_vecSide.y,
									asShadowsStored[j].m_nIntensity,
									asShadowsStored[j].m_nRed,
									asShadowsStored[j].m_nGreen,
									asShadowsStored[j].m_nBlue,
									asShadowsStored[j].m_fZDistance,
									asShadowsStored[j].m_fScale,
									NULL);
						}
					}

					asShadowsStored[j].m_nFlags.bRendered = true;
				}
			}

			RenderBuffer::RenderStuffInBuffer();
		}

	}

	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)FALSE);
	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)TRUE);
	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)TRUE);

	ShadowsStoredToBeRendered = 0;
}

void
CShadows::RenderStaticShadows(void)
{
	RenderBuffer::ClearRenderBuffer();

	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)FALSE);
	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)TRUE);
	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
	RwRenderStateSet(rwRENDERSTATEFOGENABLE,         (void *)FALSE);

	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
		aStaticShadows[i].m_bRendered = false;

	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
	{
		if ( aStaticShadows[i].m_pPolyBunch && !aStaticShadows[i].m_bRendered )
		{
			SetRenderModeForShadowType(aStaticShadows[i].m_nType);
			RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(aStaticShadows[i].m_pTexture));

			// optimization trick, render all shadows with same renderstate and texture
			for ( int32 j = i; j < MAX_STATICSHADOWS; j++ )
			{
				if ( aStaticShadows[j].m_pPolyBunch != NULL
						&& aStaticShadows[i].m_nType    == aStaticShadows[j].m_nType
						&& aStaticShadows[i].m_pTexture == aStaticShadows[j].m_pTexture )
				{
					for ( CPolyBunch *bunch = aStaticShadows[j].m_pPolyBunch; bunch != NULL; bunch = bunch->m_pNext )
					{
						RwImVertexIndex *pIndexes;
						RwIm3DVertex *pVerts;

						RenderBuffer::StartStoring(3 * (bunch->m_nNumVerts - 2), bunch->m_nNumVerts, &pIndexes, &pVerts);

						ASSERT(pIndexes != NULL);
						ASSERT(pVerts != NULL);

						for ( int32 k = 0; k < bunch->m_nNumVerts; k++ )
						{
							RwIm3DVertexSetRGBA(&pVerts[k],
									aStaticShadows[j].m_nRed,
									aStaticShadows[j].m_nGreen,
									aStaticShadows[j].m_nBlue,
									(int32)(aStaticShadows[j].m_nIntensity * (1.0f - CWeather::Foggyness * 0.5f)));

							RwIm3DVertexSetU  (&pVerts[k], bunch->m_aU[k] / 200.0f);
							RwIm3DVertexSetV  (&pVerts[k], bunch->m_aV[k] / 200.0f);
							RwIm3DVertexSetPos(&pVerts[k], bunch->m_aVerts[k].x, bunch->m_aVerts[k].y,  bunch->m_aVerts[k].z + 0.03f);
						}

						for ( int32 k = 0; k < 3 * (bunch->m_nNumVerts - 2); k++ )
							pIndexes[k] = ShadowIndexList[k];

						RenderBuffer::StopStoring();
					}

					aStaticShadows[j].m_bRendered = true;
				}
			}

			RenderBuffer::RenderStuffInBuffer();
		}
	}

	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)FALSE);
	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)TRUE);
}

void
CShadows::GeneratePolysForStaticShadow(int16 nStaticShadowID)
{
	float fWidth  = Abs(aStaticShadows[nStaticShadowID].m_vecFront.x) + Abs(aStaticShadows[nStaticShadowID].m_vecSide.x);
	float fHeight = Abs(aStaticShadows[nStaticShadowID].m_vecFront.y) + Abs(aStaticShadows[nStaticShadowID].m_vecSide.y);

	CVector shadowPos = aStaticShadows[nStaticShadowID].m_vecPosn;

	float fStartX = shadowPos.x - fWidth;
	float fEndX   = shadowPos.x + fWidth;
	float fStartY = shadowPos.y - fHeight;
	float fEndY   = shadowPos.y + fHeight;

	int32 nStartX = Max(CWorld::GetSectorIndexX(fStartX), 0);
	int32 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
	int32 nEndX   = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X-1);
	int32 nEndY   = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y-1);

	CWorld::AdvanceCurrentScanCode();

	for ( int32 y = nStartY; y <= nEndY; y++ )
	{
		for ( int32 x = nStartX; x <= nEndX; x++ )
		{
			CSector *pCurSector = CWorld::GetSector(x, y);

			ASSERT(pCurSector != NULL);

			CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS],
					fStartX, fStartY,
					fEndX, fEndY,
					&shadowPos,
					aStaticShadows[nStaticShadowID].m_vecFront.x,
					aStaticShadows[nStaticShadowID].m_vecFront.y,
					aStaticShadows[nStaticShadowID].m_vecSide.x,
					aStaticShadows[nStaticShadowID].m_vecSide.y,
					0, 0, 0, 0,
					aStaticShadows[nStaticShadowID].m_fZDistance,
					aStaticShadows[nStaticShadowID].m_fScale,
					&aStaticShadows[nStaticShadowID].m_pPolyBunch);

			CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP],
					fStartX, fStartY,
					fEndX, fEndY,
					&shadowPos,
					aStaticShadows[nStaticShadowID].m_vecFront.x,
					aStaticShadows[nStaticShadowID].m_vecFront.y,
					aStaticShadows[nStaticShadowID].m_vecSide.x,
					aStaticShadows[nStaticShadowID].m_vecSide.y,
					0, 0, 0, 0,
					aStaticShadows[nStaticShadowID].m_fZDistance,
					aStaticShadows[nStaticShadowID].m_fScale,
					&aStaticShadows[nStaticShadowID].m_pPolyBunch);
		}
	}
}

void
CShadows::CastShadowSectorList(CPtrList &PtrList, float fStartX, float fStartY, float fEndX, float fEndY, CVector *pPosn,
								float fFrontX, float fFrontY, float fSideX, float fSideY,
								int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
								float fZDistance, float fScale, CPolyBunch **ppPolyBunch)
{
	ASSERT(pPosn != NULL);

	CPtrNode *pNode = PtrList.first;

	CRect Bound;

	while ( pNode != NULL )
	{
		CEntity *pEntity = (CEntity *)pNode->item;
		uint16 nScanCode = pEntity->m_scanCode;
		pNode = pNode->next;

		ASSERT( pEntity != NULL );

		if ( nScanCode != CWorld::GetCurrentScanCode() )
		{
			if ( pEntity->bUsesCollision && pEntity->IsBuilding() )
			{
				pEntity->m_scanCode = CWorld::GetCurrentScanCode();

				Bound = pEntity->GetBoundRect();

				if ( fStartX < Bound.right
					&& fEndX > Bound.left
					&& fStartY < Bound.bottom
					&& fEndY > Bound.top )
				{
					if ( pPosn->z - fZDistance < pEntity->GetPosition().z + pEntity->GetColModel()->boundingBox.max.z
						&& pEntity->GetPosition().z + pEntity->GetColModel()->boundingBox.min.z < pPosn->z )
					{
						CastShadowEntity(pEntity,
							fStartX, fStartY,
							fEndX, fEndY,
							pPosn,
							fFrontX, fFrontY,
							fSideX, fSideY,
							nIntensity, nRed, nGreen, nBlue,
							fZDistance, fScale, ppPolyBunch);
					}
				}
			}
		}
	}
}

void
CShadows::CastShadowEntity(CEntity *pEntity,  float fStartX, float fStartY, float fEndX, float fEndY, CVector *pPosn,
							float fFrontX, float fFrontY, float fSideX, float fSideY,
							int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
							float fZDistance, float fScale, CPolyBunch **ppPolyBunch)
{	
	ASSERT(pEntity != NULL);
	ASSERT(pPosn != NULL);

	static CVector List   [20];
	static CVector Texture[20];
	static CVector Points [4];

	CColModel *pCol = pEntity->GetColModel();
	ASSERT(pCol != NULL);

#ifndef MASTER
	if ( gbPrintShite )
		printf("MI:%d Triangles:%d Coors:%f %f BBoxXY:%f %f\n",
			pEntity->GetModelIndex(),
			pCol->numTriangles,
			pEntity->GetPosition().x,
			pEntity->GetPosition().y,
			pCol->boundingBox.GetSize().x,
			pCol->boundingBox.GetSize().y);
#endif
	
	CCollision::CalculateTrianglePlanes(pCol);

	float fFrontRight    = DotProduct2D(CVector2D(fFrontX, fFrontY),     pEntity->GetRight());
	float fFrontForward  = DotProduct2D(CVector2D(fFrontX, fFrontY),     pEntity->GetForward());
	float fSideRight     = DotProduct2D(CVector2D(fSideX, fSideY),       pEntity->GetRight());
	float fSideForward   = DotProduct2D(CVector2D(fSideX, fSideY),       pEntity->GetForward());
	float fLengthRight   = DotProduct2D(*pPosn - pEntity->GetPosition(), pEntity->GetRight());
	float fLengthForward = DotProduct2D(*pPosn - pEntity->GetPosition(), pEntity->GetForward());

	Points[0].x = (fLengthRight   + fFrontRight  )  - fSideRight;
	Points[0].y = (fLengthForward + fFrontForward)  - fSideForward;

	Points[1].x = fSideRight      + (fLengthRight   + fFrontRight);
	Points[1].y = fSideForward    + (fLengthForward + fFrontForward);
                                  
	Points[2].x = fSideRight      + (fLengthRight   - fFrontRight);
	Points[2].y = fSideForward    + (fLengthForward - fFrontForward);

	Points[3].x = (fLengthRight   - fFrontRight)    - fSideRight;
	Points[3].y = (fLengthForward - fFrontForward)  - fSideForward;

	float MinX = Min(Min(Points[0].x, Points[1].x), Min(Points[2].x, Points[3].x));
	float MaxX = Max(Max(Points[0].x, Points[1].x), Max(Points[2].x, Points[3].x));

	float MinY = Min(Min(Points[0].y, Points[1].y), Min(Points[2].y, Points[3].y));
	float MaxY = Max(Max(Points[0].y, Points[1].y), Max(Points[2].y, Points[3].y));

	float MaxZ = pPosn->z - pEntity->GetPosition().z;
	float MinZ = MaxZ - fZDistance;

	for ( int32 i = 0; i < pCol->numTriangles; i++ )
	{
		CColTrianglePlane *pColTriPlanes = pCol->trianglePlanes;
		ASSERT(pColTriPlanes != NULL);

		if ( Abs(pColTriPlanes[i].normal.z) > 0.1f )
		{
			CColTriangle *pColTri = pCol->triangles;
			ASSERT(pColTri != NULL);

			CVector PointA, PointB, PointC;

			pCol->GetTrianglePoint(PointA, pColTri[i].a);
			pCol->GetTrianglePoint(PointB, pColTri[i].b);
			pCol->GetTrianglePoint(PointC, pColTri[i].c);

			if (   (PointA.x > MinX || PointB.x > MinX || PointC.x > MinX)
				&& (PointA.x < MaxX || PointB.x < MaxX || PointC.x < MaxX)
				&& (PointA.y > MinY || PointB.y > MinY || PointC.y > MinY)
				&& (PointA.y < MaxY || PointB.y < MaxY || PointC.y < MaxY)
				&& (PointA.z < MaxZ || PointB.z < MaxZ || PointC.z < MaxZ)
				&& (PointA.z > MinZ || PointB.z > MinZ || PointC.z > MinZ) )

			{
				List[0].x = Points[0].x;
				List[0].y = Points[0].y;

				List[1].x = Points[1].x;
				List[1].y = Points[1].y;

				List[2].x = Points[2].x;
				List[2].y = Points[2].y;

				List[3].x = Points[3].x;
				List[3].y = Points[3].y;

				Texture[0].x = 0.0f;
				Texture[0].y = 0.0f;

				Texture[1].x = 1.0f;
				Texture[1].y = 0.0f;

				Texture[2].x = 1.0f;
				Texture[2].y = 1.0f;

				Texture[3].x = 0.0f;
				Texture[3].y = 1.0f;


				CVector2D start;
				CVector2D dist;

				int32 numVerts1 = 0;
				int16 vertType1 = 0;
				{						
					for ( int32 j = 0; j < 4; j++ )
					{
						start = PointA;
						dist  = PointB - PointA;
						
						int32 in = j;
						
						float cp = CrossProduct2D(CVector2D(List[in]) - start, dist);

						if ( cp > 0.0f )
						{
							switch ( vertType1 )
							{
								case 0:
								{
									int32 out = numVerts1++ + 10;

									Texture[out].x = Texture[in].x;
									Texture[out].y = Texture[in].y;
									List[out].x    = List[in].x;
									List[out].y    = List[in].y;

									break;
								}

								case 1:
								{
									int32 out = numVerts1++ + 10;

									Texture[out].x = Texture[in].x;
									Texture[out].y = Texture[in].y;
									List[out].x    = List[in].x;
									List[out].y    = List[in].y;

									break;
								}

								case 2:
								{
									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
									float Compl = 1.0f - Scale;

									int32 out1 = numVerts1++ + 10;
									int32 out2 = numVerts1++ + 10;

									Texture[out1].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
									Texture[out1].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
									List[out1].x    = Compl*List[in-1].x    + Scale*List[in].x;
									List[out1].y    = Compl*List[in-1].y    + Scale*List[in].y;

									Texture[out2].x = Texture[in].x;
									Texture[out2].y = Texture[in].y;
									List[out2].x    = List[in].x;
									List[out2].y    = List[in].y;

									break;
								}
							}

							vertType1 = 1;
						}
						else
						{
							switch ( vertType1 )
							{
								case 1:
								{
									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
									float Compl = 1.0f - Scale;

									int32 out = numVerts1++ + 10;

									Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
									Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
									List[out].x    = Compl*List[in-1].x    + Scale*List[in].x;
									List[out].y    = Compl*List[in-1].y    + Scale*List[in].y;
									
									break;
								}
							}

							vertType1 = 2;
						}
					}

					float cp1 = CrossProduct2D(CVector2D(List[0]) - start, dist);
					if ( cp1 > 0.0f && vertType1 == 2 || cp1 <= 0.0f && vertType1 == 1 )
					{
						float cp2 = CrossProduct2D(CVector2D(List[3]) - start, dist);

						float Scale = Abs(cp2) / (Abs(cp2) + Abs(cp1));
						float Compl = 1.0f - Scale;

						int32 out = numVerts1++ + 10;

						Texture[out].x = Compl*Texture[3].x + Scale*Texture[0].x;
						Texture[out].y = Compl*Texture[3].y + Scale*Texture[0].y;
						List[out].x    = Compl*List[3].x    + Scale*List[0].x;
						List[out].y    = Compl*List[3].y    + Scale*List[0].y;
					}
				}

				int32 numVerts2 = 0;
				int16 vertType2 = 0;
				{						
					for ( int32 j = 0; j < numVerts1; j++ )
					{
						start = PointB;
						dist  = PointC - PointB;
					
						int32 in = j + 10;
						float cp = CrossProduct2D(CVector2D(List[in]) - start, dist);

						if ( cp > 0.0f )
						{
							switch ( vertType2 )
							{
								case 0:
								{
									int32 out = numVerts2++;

									Texture[out].x = Texture[in].x;
									Texture[out].y = Texture[in].y;
									List[out].x    = List[in].x;
									List[out].y    = List[in].y;
									
									break;
								}

								case 1:
								{
									int32 out = numVerts2++;

									Texture[out].x = Texture[in].x;
									Texture[out].y = Texture[in].y;
									List[out].x    = List[in].x;
									List[out].y    = List[in].y;
									
									break;
								}

								case 2:
								{
									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
									float Compl = 1.0f - Scale;

									int32 out1 = numVerts2++;
									int32 out2 = numVerts2++;

									Texture[out1].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
									Texture[out1].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
									List[out1].x    = Compl*List[in-1].x    + Scale*List[in].x;
									List[out1].y    = Compl*List[in-1].y    + Scale*List[in].y;

									Texture[out2].x = Texture[in].x;
									Texture[out2].y = Texture[in].y;
									List[out2].x    = List[in].x;
									List[out2].y    = List[in].y;
									
									break;
								}
							}

							vertType2 = 1;
						}
						else
						{
							switch ( vertType2 )
							{
								case 1:
								{
									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
									float Compl = 1.0f - Scale;

									int32 out = numVerts2++;

									Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
									Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
									List[out].x    = Compl*List[in-1].x    + Scale*List[in].x;
									List[out].y    = Compl*List[in-1].y    + Scale*List[in].y;
									
									break;
								}
							}

							vertType2 = 2;
						}
					}

					float cp1 = CrossProduct2D(CVector2D(List[10]) - start, dist);
					if ( cp1 > 0.0f && vertType2 == 2 || cp1 <= 0.0f && vertType2 == 1 )
					{
						int32 in = numVerts1 + 10;

						float cp2 = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

						float Scale = Abs(cp2) / (Abs(cp2) + Abs(cp1));
						float Compl = 1.0f - Scale;

						int32 out = numVerts2++;

						Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[10].x;
						Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[10].y;
						List[out].x    = Compl*List[in-1].x    + Scale*List[10].x;
						List[out].y    = Compl*List[in-1].y    + Scale*List[10].y;
					}
				}

				int32 numVerts3 = 0;
				int16 vertType3 = 0;
				{					
					for ( int32 j = 0; j < numVerts2; j++ )
					{
						start = PointC;
						dist  = PointA - PointC;
					
						int32 in = j;
						float cp = CrossProduct2D(CVector2D(List[in]) - start, dist);

						if ( cp > 0.0f )
						{
							switch ( vertType3 )
							{
								case 0:
								{
									int32 out = numVerts3++ + 10;

									Texture[out].x = Texture[in].x;
									Texture[out].y = Texture[in].y;
									List[out].x    = List[in].x;
									List[out].y    = List[in].y;
									
									break;
								}

								case 1:
								{
									int32 out = numVerts3++ + 10;

									Texture[out].x = Texture[in].x;
									Texture[out].y = Texture[in].y;
									List[out].x    = List[in].x;
									List[out].y    = List[in].y;
									
									break;
								}

								case 2:
								{
									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
									float Compl = 1.0f - Scale;

									int32 out1 = numVerts3++ + 10;
									int32 out2 = numVerts3++ + 10;

									Texture[out1].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
									Texture[out1].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
									List[out1].x    = Compl*List[in-1].x    + Scale*List[in].x;
									List[out1].y    = Compl*List[in-1].y    + Scale*List[in].y;

									Texture[out2].x = Texture[in].x;
									Texture[out2].y = Texture[in].y;
									List[out2].x    = List[in].x;
									List[out2].y    = List[in].y;
									
									break;
								}
							}

							vertType3 = 1;
						}
						else
						{
							switch ( vertType3 )
							{
								case 1:
								{
									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
									float Compl = 1.0f - Scale;

									int32 out = numVerts3++ + 10;

									Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
									Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
									List[out].x    = Compl*List[in-1].x    + Scale*List[in].x;
									List[out].y    = Compl*List[in-1].y    + Scale*List[in].y;
									
									break;
								}
							}

							vertType3 = 2;
						}
					}

					float cp1 = CrossProduct2D(CVector2D(List[0]) - start, dist);
					if ( cp1 > 0.0f && vertType3 == 2 || cp1 <= 0.0f && vertType3 == 1 )
					{
						int32 in = numVerts2;

						float cp2 = CrossProduct2D(CVector2D(List[in-1]) - start, dist);

						float Scale = Abs(cp2) / (Abs(cp2) + Abs(cp1));
						float Compl = 1.0f - Scale;

						int32 out = numVerts3++ + 10;

						Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[0].x;
						Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[0].y;
						List[out].x    = Compl*List[in-1].x    + Scale*List[0].x;
						List[out].y    = Compl*List[in-1].y    + Scale*List[0].y;
					}
				}
					
				if ( numVerts3 >= 3 )
				{
					CVector norm;

					pColTriPlanes[i].GetNormal(norm);

					float dot = DotProduct(norm, PointA);

					for ( int32 j = 0; j < numVerts3; j++ )
					{
						int32 idx = j + 10;

						List[idx].z = -(DotProduct2D(norm, List[idx]) - dot) / norm.z;
					}

					for ( int32 j = 0; j < numVerts3; j++ )
					{
						int32 idx = j + 10;

						CVector p = List[idx];
						
						List[idx].x = p.y * pEntity->GetForward().x + p.x * pEntity->GetRight().x + pEntity->GetPosition().x;
						List[idx].y = p.y * pEntity->GetForward().y + p.x * pEntity->GetRight().y + pEntity->GetPosition().y;
						List[idx].z = p.z + pEntity->GetPosition().z;
					}

					
					if ( ppPolyBunch != NULL )
					{
						if ( pEmptyBunchList != NULL )
						{
							CPolyBunch *pBunch = pEmptyBunchList;
							ASSERT(pBunch != NULL);
							pEmptyBunchList = pEmptyBunchList->m_pNext;
							pBunch->m_pNext = *ppPolyBunch;
							*ppPolyBunch = pBunch;
	
							pBunch->m_nNumVerts = numVerts3;
	
							for ( int32 j = 0; j < numVerts3; j++ )
							{
								int32 in = j + 10;
	
								pBunch->m_aVerts[j] = List[in];
	
								pBunch->m_aU[j] = (int32)(Texture[in].x * 200.0f);
								pBunch->m_aV[j] = (int32)(Texture[in].y * 200.0f);
							}
						}
					}
					else
					{
						RwImVertexIndex *pIndexes;
						RwIm3DVertex *pVerts;

						RenderBuffer::StartStoring(3 * (numVerts3 - 2), numVerts3, &pIndexes, &pVerts);

						ASSERT(pIndexes != NULL);
						ASSERT(pVerts != NULL);


						for ( int32 j = 0; j < numVerts3; j++ )
						{
							int32 in = j + 10;

							RwIm3DVertexSetRGBA(&pVerts[j], nRed, nGreen, nBlue, nIntensity);
							RwIm3DVertexSetU   (&pVerts[j], Texture[in].x*fScale);
							RwIm3DVertexSetV   (&pVerts[j], Texture[in].y*fScale);
							RwIm3DVertexSetPos (&pVerts[j], List[in].x, List[in].y, List[in].z + 0.03f);
						}

						for ( int32 j = 0; j < 3*(numVerts3 - 2); j++ )
							pIndexes[j] = ShadowIndexList[j];

						RenderBuffer::StopStoring();
					}
				}
			}
		}
	}
}

void
CShadows::UpdateStaticShadows(void)
{
	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
	{
		if ( aStaticShadows[i].m_pPolyBunch != NULL && !aStaticShadows[i].m_bJustCreated
			&& (!aStaticShadows[i].m_bTemp || CTimer::GetTimeInMilliseconds() > aStaticShadows[i].m_nTimeCreated + 5000) )
		{
			aStaticShadows[i].Free();
		}

		aStaticShadows[i].m_bJustCreated = false;
	}
}

void
CShadows::UpdatePermanentShadows(void)
{
	for ( int32 i = 0; i < MAX_PERMAMENTSHADOWS; i++ )
	{
		if ( aPermanentShadows[i].m_nType != SHADOWTYPE_NONE )
		{
			uint32 timePassed = CTimer::GetTimeInMilliseconds() - aPermanentShadows[i].m_nTimeCreated;

			if ( timePassed >= aPermanentShadows[i].m_nLifeTime )
				aPermanentShadows[i].m_nType = SHADOWTYPE_NONE;
			else
			{
				if ( timePassed >= (aPermanentShadows[i].m_nLifeTime * 3 / 4) )
				{
					// timePassed == 0                                -> 4
					// timePassed == aPermanentShadows[i].m_nLifeTime -> 0
					float fMult = 1.0f - float(timePassed - (aPermanentShadows[i].m_nLifeTime * 3 / 4)) / (aPermanentShadows[i].m_nLifeTime / 4);

					StoreStaticShadow((uint32)&aPermanentShadows[i],
						aPermanentShadows[i].m_nType,
						aPermanentShadows[i].m_pTexture,
						&aPermanentShadows[i].m_vecPos,
						aPermanentShadows[i].m_vecFront.x,
						aPermanentShadows[i].m_vecFront.y,
						aPermanentShadows[i].m_vecSide.x,
						aPermanentShadows[i].m_vecSide.y,
						(int32)(aPermanentShadows[i].m_nIntensity * fMult),
						(int32)(aPermanentShadows[i].m_nRed       * fMult),
						(int32)(aPermanentShadows[i].m_nGreen     * fMult),
						(int32)(aPermanentShadows[i].m_nBlue      * fMult),
						aPermanentShadows[i].m_fZDistance,
						1.0f, 40.0f, false, 0.0f);
				}
				else
				{
					StoreStaticShadow((uint32)&aPermanentShadows[i],
						aPermanentShadows[i].m_nType,
						aPermanentShadows[i].m_pTexture,
						&aPermanentShadows[i].m_vecPos,
						aPermanentShadows[i].m_vecFront.x,
						aPermanentShadows[i].m_vecFront.y,
						aPermanentShadows[i].m_vecSide.x,
						aPermanentShadows[i].m_vecSide.y,
						aPermanentShadows[i].m_nIntensity,
						aPermanentShadows[i].m_nRed,
						aPermanentShadows[i].m_nGreen,
						aPermanentShadows[i].m_nBlue,
						aPermanentShadows[i].m_fZDistance,
						1.0f, 40.0f, false, 0.0f);
				}
			}
		}
	}
}

void
CStaticShadow::Free(void)
{
	if ( m_pPolyBunch != NULL )
	{
		CPolyBunch *pFree = CShadows::pEmptyBunchList;
		CShadows::pEmptyBunchList = m_pPolyBunch;

		CPolyBunch *pUsed = m_pPolyBunch;
		while (pUsed->m_pNext != NULL)
			pUsed = pUsed->m_pNext;

			pUsed->m_pNext = pFree;
	}

	m_pPolyBunch = NULL;

	m_nId = 0;
}

void
CShadows::CalcPedShadowValues(CVector vecLightDir,
							float *pfDisplacementX, float *pfDisplacementY,
							float *pfFrontX, float *pfFrontY,
							float *pfSideX, float *pfSideY)
{
	ASSERT(pfDisplacementX != NULL);
	ASSERT(pfDisplacementY != NULL);
	ASSERT(pfFrontX != NULL);
	ASSERT(pfFrontY != NULL);
	ASSERT(pfSideX != NULL);
	ASSERT(pfSideY != NULL);

	*pfDisplacementX = -vecLightDir.x;
	*pfDisplacementY = -vecLightDir.y;

	float fDist = Sqrt(*pfDisplacementY * *pfDisplacementY + *pfDisplacementX * *pfDisplacementX);
	float fMult = (fDist + 1.0f) / fDist;

	*pfDisplacementX *= fMult;
	*pfDisplacementY *= fMult;

	*pfFrontX = -vecLightDir.y / fDist;
	*pfFrontY =  vecLightDir.x / fDist;

	*pfSideX = -vecLightDir.x;
	*pfSideY = -vecLightDir.y;

	*pfDisplacementX /= 2;
	*pfDisplacementY /= 2;

	*pfFrontX /= 2;
	*pfFrontY /= 2;

	*pfSideX /= 2;
	*pfSideY /= 2;
}

void
CShadows::RenderExtraPlayerShadows(void)
{
#ifdef FIX_BUGS
	if (CReplay::IsPlayingBack())
		return;
#endif
	if ( CTimeCycle::GetLightShadowStrength() != 0 )
	{
		CVehicle *pCar = FindPlayerVehicle();

		if ( pCar == NULL )
		{
			for ( int32 i = 0; i < CPointLights::NumLights; i++ )
			{
				if (   0.0f != CPointLights::aLights[i].red
					|| 0.0f != CPointLights::aLights[i].green
					|| 0.0f != CPointLights::aLights[i].blue )
				{
					if ( CPointLights::aLights[i].castExtraShadows )
					{
						CVector vecLight = CPointLights::aLights[i].coors - FindPlayerCoors();
						float fLightDist = vecLight.Magnitude();
						float fRadius = CPointLights::aLights[i].radius;

						if ( fLightDist < fRadius )
						{
							// fLightDist == fRadius -> 2.0f
							// fLightDist == 0       -> 0.0f
							float fMult = (1.0f - (2.0f * fLightDist - fRadius) / fRadius);

							int32 nColorStrength;
							if ( fLightDist < fRadius*0.5f )
								nColorStrength = (5*CTimeCycle::GetLightShadowStrength()/8);
							else
								nColorStrength = int32((5*CTimeCycle::GetLightShadowStrength()/8) * fMult);

							float fInv = 1.0f / fLightDist;
							vecLight.x *= fInv;
							vecLight.y *= fInv;
							vecLight.z *= fInv;

							float fDisplacementX, fDisplacementY, fFrontX, fFrontY, fSideX, fSideY;

							CalcPedShadowValues(vecLight,
														&fDisplacementX, &fDisplacementY,
														&fFrontX, &fFrontY,
														&fSideX, &fSideY);

							CVector shadowPos = FindPlayerCoors();

							shadowPos.x += fSideX;
							shadowPos.y += fSideY;


							StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowPedTex, &shadowPos,
									fDisplacementX, fDisplacementY,
									fFrontX, fFrontY,
									nColorStrength, 0, 0, 0,
									4.0f, false, 1.0f);
						}
					}
				}
			}
		}
		else
		{
			if ( pCar->GetModelIndex() != MI_RCBANDIT )
			{
				for ( int32 i = 0; i < CPointLights::NumLights; i++ )
				{
					if (  CPointLights::aLights[i].type == CPointLights::LIGHT_POINT
						&& CPointLights::aLights[i].castExtraShadows
						&&(0.0f != CPointLights::aLights[i].red
						|| 0.0f != CPointLights::aLights[i].green
						|| 0.0f != CPointLights::aLights[i].blue) )
					{
						CVector vecLight = CPointLights::aLights[i].coors - FindPlayerCoors();
						float fLightDist = vecLight.Magnitude();
						float fRadius = CPointLights::aLights[i].radius;

						if ( fLightDist < fRadius )
						{
							// fLightDist == 0       -> 2.0f
							// fLightDist == fRadius -> 0.0f
							float fMult = (1.0f - (2.0f * fLightDist - fRadius) / fRadius);

							int32 nColorStrength;
							if ( fLightDist < fRadius*0.5f )
								nColorStrength = (5*CTimeCycle::GetLightShadowStrength()/8);
							else
								nColorStrength = int32((5*CTimeCycle::GetLightShadowStrength()/8) * fMult);

							float fInv = 1.0f / fLightDist;
							vecLight.x *= fInv;
							vecLight.y *= fInv;
							vecLight.z *= fInv;

							CVector shadowPos = pCar->GetPosition();

							shadowPos.x -= vecLight.x * 1.2f;
							shadowPos.y -= vecLight.y * 1.2f;

							float fVehicleWidth   = pCar->GetColModel()->boundingBox.GetSize().x;
							float fVehicleHeight  = pCar->GetColModel()->boundingBox.GetSize().y;

							shadowPos.x -= ((fVehicleHeight/2) - pCar->GetColModel()->boundingBox.max.y)
											* pCar->GetForward().x;

							shadowPos.y -= ((fVehicleHeight/2) - pCar->GetColModel()->boundingBox.max.y)
											* pCar->GetForward().y;

							if ( pCar->GetUp().z > 0.0f )
							{
								StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &shadowPos,
									pCar->GetForward().x * (fVehicleHeight/2),
									pCar->GetForward().y * (fVehicleHeight/2),
									pCar->GetRight().x   * (fVehicleWidth/3),
									pCar->GetRight().y   * (fVehicleWidth/3),
									nColorStrength, 0, 0, 0,
									4.5f, false, 1.0f);
							}
							else
							{
								StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &shadowPos,
									pCar->GetForward().x * (fVehicleHeight/2),
									pCar->GetForward().y * (fVehicleHeight/2),
									-pCar->GetRight().x  * (fVehicleWidth/2),
									-pCar->GetRight().y  * (fVehicleWidth/2),
									nColorStrength, 0, 0, 0,
									4.5f, false, 1.0f);
							}
						}
					}
				}
			}
		}
	}
}

void
CShadows::TidyUpShadows(void)
{
	for ( int32 i = 0; i < MAX_PERMAMENTSHADOWS; i++ )
		aPermanentShadows[i].m_nType = SHADOWTYPE_NONE;
}

void
CShadows::RenderIndicatorShadow(uint32 nID, uint8 ShadowType, RwTexture *pTexture,  CVector *pPosn,
								float fFrontX, float fFrontY, float fSideX, float fSideY,
								int16 nIntensity)
{
	ASSERT(pPosn != NULL);

	C3dMarkers::PlaceMarkerSet(nID, _TODOCONST(4), *pPosn, Max(fFrontX, -fSideY),
			0, 128, 255, 128,
			2048, 0.2f, 0);
}