////////////////////////////////////////////////////////////////////////////
//
//  Crytek Engine Source File.
//  Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
//  File name:   statobjman.cpp
//  Version:     v1.00
//  Created:     28/5/2001 by Vladimir Kajalin
//  Compilers:   Visual Studio.NET
//  Description: objects container, streaming, common part for indoor and outdoor sectors
// -------------------------------------------------------------------------
//  History:
//
////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "StatObj.h"
#include "objman.h"
#include "visareas.h"
#include "terrain_sector.h"
#include "cbuffer.h"
#include "3DEngine.h"
#include "meshidx.h"
#include "watervolumes.h"
#include "brush.h"
#include "LMCompStructures.h"

void CBasicArea::SerializeArea(bool bSave)
{
  char szFileName[256]="";                        
  sprintf(szFileName,"visarea_objects_%.1f_%.1f_%.1f_%.1f.cache", m_vBoxMin.x, m_vBoxMin.y, m_vBoxMax.x, m_vBoxMax.y);

  FILE * f = GetPak()->FOpen(Get3DEngine()->GetFilePath(szFileName), bSave ? "wb" : "rb");
  if(!f)
    return;

  if(bSave)
  {
    for(int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++)
    {
      EERType eType = m_lstEntities[STATIC_ENTITIES].GetAt(i)->GetEntityRenderType();

      if(eType == eERType_Brush || eType == eERType_Vegetation)
      {
        GetPak()->FWrite(&eType,sizeof(eType),1,f);        

//        if(m_lstEntities[STATIC_ENTITIES].GetAt(i)->GetEntityRS())
        {
          m_lstEntities[STATIC_ENTITIES].GetAt(i)->m_pVisArea = 0;
          m_lstEntities[STATIC_ENTITIES].GetAt(i)->m_pSector = 0;
        }

        m_lstEntities[STATIC_ENTITIES].GetAt(i)->Dephysicalize();
        m_lstEntities[STATIC_ENTITIES].GetAt(i)->Dematerialize();

        m_lstEntities[STATIC_ENTITIES].GetAt(i)->Serialize(bSave,GetPak(),f);
      }
    }
    m_lstEntities[STATIC_ENTITIES].Reset();
  }
  else
  {
    assert(m_lstEntities[STATIC_ENTITIES].Count()==0);
    m_lstEntities[STATIC_ENTITIES].Reset();

    m_eSStatus = eSStatus_Ready;

    while(1)
    {
      EERType eType = eERType_Unknown;
      if(GetPak()->FRead(&eType,sizeof(eType),1,f)!=1)
        break;

      IEntityRender * pEntityRender = 0;
      if(eType == eERType_Brush)
        pEntityRender = new CBrush();      
      else if(eType == eERType_Vegetation)
        pEntityRender = new CStatObjInst();      

      if(pEntityRender)
      {
        pEntityRender->Serialize(bSave,GetPak(),f);
        pEntityRender->GetEntityRS() = new IEntityRenderState;
        pEntityRender->Physicalize();
        Get3DEngine()->RegisterEntity(pEntityRender);
      }
    }
  }

  GetPak()->FClose(f);
}

void CBasicArea::UnmakeAreaBrush()
{
	for( int i=0; i<m_lstAreaBrush.Count(); i++ )
		FreeAreaBrush(m_lstAreaBrush[i]);

	// mark all objects as unmerged
	if(m_lstAreaBrush.Count())
	for( int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++ )
	{
		IEntityRender * pEntityRender =	m_lstEntities[STATIC_ENTITIES].GetAt(i);
		pEntityRender->m_dwRndFlags &= ~ERF_MERGED;
		assert(!(pEntityRender->m_dwRndFlags & ERF_MERGED));
	}

	m_lstAreaBrush.Clear();
}

void CBasicArea::DrawEntities( int nFogVolumeID, int nDLightMask,
                              bool bLMapGeneration, const CCamera & EntViewCamera, Vec3d * pvAmbColor, Vec3d * pvDynAmbColor,
                              VolumeInfo * pFogVolume, bool bNotAllInFrustum, float fSectorMinDist,
                              CObjManager * pObjManager, bool bAllowBrushMerging, char*fake, uint nStatics)
{
	FUNCTION_PROFILER_FAST( GetSystem(),PROFILE_3DENGINE,m_bProfilerEnabled );

	if(!GetCVars()->e_objects)
		return;

  if(GetCVars()->e_stream_areas && GetCVars()->e_stream_for_visuals && CStatObj::m_fStreamingTimePerFrame<CGF_STREAMING_MAX_TIME_PER_FRAME)
  {
    m_nLastUsedFrameId = GetFrameID();

    if(m_eSStatus != eSStatus_Ready)
    {
      CStatObj::m_fStreamingTimePerFrame -= GetTimer()->GetAsyncCurTime();
      SerializeArea(false);
      CStatObj::m_fStreamingTimePerFrame += GetTimer()->GetAsyncCurTime();
    }
  }

	// apply zoom factor
	fSectorMinDist *= pObjManager->m_fZoomFactor;

	// make lmask for vegetations
	int nDLightMaskNoSun = nDLightMask;
	list2<CDLight> * pSources = ((C3DEngine*)m_p3DEngine)->GetDynamicLightSources();
	for(int i=0; i<pSources->Count(); i++)
	{
		CDLight * pDynLight = pSources->Get(i);
		assert(pDynLight->m_Id == i || pDynLight->m_Id == -1);
		if(pDynLight->m_Flags & DLF_SUN)
		{
			nDLightMaskNoSun &= ~(1<<pDynLight->m_Id);
			break;
		}
	}

	if(nStatics && m_StaticEntitiesSorted && GetCVars()->e_optimized_render_object && 
		!bLMapGeneration && pObjManager->m_fZoomFactor >= 0.99f)
	{ // render statics compiled
		const Vec3d vCamPos = EntViewCamera.GetPos();

		const Plane PlaneR = *EntViewCamera.GetFrustumPlane(FR_PLANE_RIGHT);
		const Plane PlaneL = *EntViewCamera.GetFrustumPlane(FR_PLANE_LEFT);

		static list2<IEntityRenderInfo*> TmpEntList; TmpEntList.Clear();
		list2<struct IEntityRender*> & SrcEntList = m_lstEntities[STATIC_ENTITIES];

		if(GetCVars()->e_vegetation)
		{	// fill simple vegetations
//		FRAME_PROFILER( "*fill simple vegetations", GetSystem(), PROFILE_3DENGINE );
			for( int i=0; i<m_lstStatEntInfoVegetNoCastersNoVolFog.Count(); i++ )
			{
				IEntityRenderInfo & inf = m_lstStatEntInfoVegetNoCastersNoVolFog[i];

				if(fSectorMinDist >= inf.m_fWSMaxViewDist)
					break;

				// check max view distance sq
				const Vec3d vCamPos = EntViewCamera.GetPos();
				const float dx = vCamPos.x-inf.m_vWSCenter.x;
				const float dy = vCamPos.y-inf.m_vWSCenter.y;
				const float fEntDistanceSQ = (dx*dx+dy*dy); // must be 2d for sprites
				if(fEntDistanceSQ > inf.m_fWSMaxViewDistSQ)
					continue;

				// early sphere test agains left and right camera planes
				if( bNotAllInFrustum && 
						PlaneR.DistFromPlane(inf.m_vWSCenter) > inf.m_fWSRadius ||
						PlaneR.DistFromPlane(inf.m_vWSCenter) > inf.m_fWSRadius )
					continue;

				// get view distance
				inf.m_fEntDistance = cry_sqrtf(fEntDistanceSQ);
				assert(inf.m_fEntDistance>=0 && _finite(inf.m_fEntDistance));
				assert(inf.m_fEntDistance <= inf.m_fWSMaxViewDist);

				TmpEntList.Add(&inf);
			}

			// render simple vegetations
//		FRAME_PROFILER( "*render simple vegetations", GetSystem(), PROFILE_3DENGINE );
			for( int i=0; i<TmpEntList.Count(); i++ )
			{
				IEntityRender * pEntityRender =	TmpEntList.GetAt(i)->m_pEntityRender;
				
				if (i+1 < TmpEntList.Count())
				{ // prefech next element
					IEntityRender * pNext = TmpEntList.GetAt(i+1)->m_pEntityRender;
					cryPrefetchT0SSE(pNext);
				}

				assert(fSectorMinDist < pEntityRender->m_fWSMaxViewDist);

				pObjManager->RenderObjectVegetationNonCastersNoFogVolume( pEntityRender, 
					nDLightMaskNoSun, EntViewCamera, bNotAllInFrustum,
					pEntityRender->m_fWSMaxViewDist, TmpEntList.GetAt(i));
			}
		}

		TmpEntList.Clear();

		if(GetCVars()->e_vegetation || GetCVars()->e_brushes)
		{ // fill complex objects
//		FRAME_PROFILER( "*fill complex objects", GetSystem(), PROFILE_3DENGINE );
			for( int i=0; i<m_lstStatEntInfoOthers.Count(); i++ )
			{
				IEntityRenderInfo & inf = m_lstStatEntInfoOthers[i];

				if(fSectorMinDist >= inf.m_fWSMaxViewDist)
					break;

				// check max view distance sq
				const Vec3d vCamPos = EntViewCamera.GetPos();
				const float dx = vCamPos.x-inf.m_vWSCenter.x;
				const float dy = vCamPos.y-inf.m_vWSCenter.y;
				const float fEntDistanceSQ = (dx*dx+dy*dy); // must be 2d for sprites
				if(fEntDistanceSQ > inf.m_fWSMaxViewDistSQ)
					continue;

				// early sphere test agains left and right camera planes
				if( bNotAllInFrustum &&
						PlaneR.DistFromPlane(inf.m_vWSCenter) > inf.m_fWSRadius+TERRAIN_SECTORS_MAX_OVERLAPPING ||
						PlaneR.DistFromPlane(inf.m_vWSCenter) > inf.m_fWSRadius+TERRAIN_SECTORS_MAX_OVERLAPPING )
					continue;

				// get view distance
				inf.m_fEntDistance = cry_sqrtf(fEntDistanceSQ);
				assert(inf.m_fEntDistance>=0 && _finite(inf.m_fEntDistance));
				assert(inf.m_fEntDistance <= inf.m_fWSMaxViewDist);

				TmpEntList.Add(&inf);
			}

			// render complex objects
//		FRAME_PROFILER( "*render complex objects", GetSystem(), PROFILE_3DENGINE );
			for( int i=0; i<TmpEntList.Count(); i++ )
			{
				IEntityRender * pEntityRender =	TmpEntList.GetAt(i)->m_pEntityRender;

				if (i+1 < TmpEntList.Count())
				{ // prefech next element
					IEntityRender * pNext = TmpEntList.GetAt(i+1)->m_pEntityRender;
					cryPrefetchT0SSE(pNext);
				}

				assert(fSectorMinDist < pEntityRender->m_fWSMaxViewDist);

				pObjManager->RenderObject( pEntityRender, nFogVolumeID, 
					nDLightMask, bLMapGeneration, EntViewCamera, pvAmbColor, pvDynAmbColor, pFogVolume, bNotAllInFrustum,
					pEntityRender->m_fWSMaxViewDist, TmpEntList.GetAt(i));
			}
		}
	}
	else if(nStatics && m_StaticEntitiesSorted && !bLMapGeneration)
	{

#ifdef VEGETATION_MEM_STATS
		static int64 t0=0,t1=0,t2=0;
#endif // VEGETATION_MEM_STATS

		list2<struct IEntityRender*> & EntList = m_lstEntities[STATIC_ENTITIES];
		for( int i=0; i<EntList.Count(); i++ )
		{
			IEntityRender * pEntityRender =	EntList.GetAt(i);

			if (i+1 < EntList.Count())
			{ // prefech next element
				IEntityRender * pNext = EntList.GetAt(i+1);
				cryPrefetchT0SSE(pNext);
			}

#ifdef VEGETATION_MEM_STATS
			if (i+1 < EntList.Count())
			{
				IEntityRender * pNext = EntList.GetAt(i+1);
				IEntityRender * pThis = EntList.GetAt(i);

				if(pNext>pThis)
				{
					if(((int64)pNext-(int64)pThis)<=128)
						t0++;
					else
						t1++;
				}
				else
					t2++;
			}
#endif // VEGETATION_MEM_STATS

			if(fSectorMinDist > pEntityRender->m_fWSMaxViewDist)
				break;

			pObjManager->RenderObject( pEntityRender, nFogVolumeID, 
				nDLightMask, bLMapGeneration, EntViewCamera, pvAmbColor, pvDynAmbColor, pFogVolume, bNotAllInFrustum,
				pEntityRender->m_fWSMaxViewDist);
		}

#ifdef VEGETATION_MEM_STATS
		static int fr=0;
		if((GetFrameID()&63)==0 && fr!=GetFrameID())
		{
			fr=GetFrameID();
			if(t0+t1+t2)
				GetLog()->Log(
				"<128 = %.1f, >128 = %.1f, NEG = %.1f",
				0.1f*float((t0*1000/(t0+t1+t2))),
				0.1f*float((t1*1000/(t0+t1+t2))), 
				0.1f*float((t2*1000/(t0+t1+t2))));
		}
#endif // VEGETATION_MEM_STATS
	}
	else if(nStatics || GetCVars()->e_entities)
	{ // render dynamics or statics uncompiled
		assert(!m_StaticEntitiesSorted || !nStatics);
		list2<struct IEntityRender*> & EntList = m_lstEntities[nStatics];
		for( int i=0; i<EntList.Count(); i++ )
		{
			IEntityRender * pEntityRender =	EntList.GetAt(i);
			pEntityRender->m_fWSMaxViewDist = pEntityRender->GetMaxViewDist();
			if(fSectorMinDist > pEntityRender->m_fWSMaxViewDist)
				continue;

			pObjManager->RenderObject( pEntityRender, nFogVolumeID, 
				nDLightMask, bLMapGeneration, EntViewCamera, pvAmbColor, pvDynAmbColor, pFogVolume, bNotAllInFrustum,
				pEntityRender->m_fWSMaxViewDist);
		}
	}
}

void CBasicArea::Unload(bool bUnloadOnlyVegetations, const Vec3d & vVegetPos)
{
  if(bUnloadOnlyVegetations)
  {
    for(int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++)
    {
      EERType eType = m_lstEntities[STATIC_ENTITIES].GetAt(i)->GetEntityRenderType();
      if(eType == eERType_Vegetation)
      {
        Vec3d vEntPos = m_lstEntities[STATIC_ENTITIES].GetAt(i)->GetPos();
        float fDist = (vVegetPos==Vec3d(0,0,0)) ? 0 : GetDist2D(vVegetPos.x,vVegetPos.y,vEntPos.x,vEntPos.y);
        if(fDist<0.01f)
        {
          int nCountBefore = m_lstEntities[STATIC_ENTITIES].Count();
          delete m_lstEntities[STATIC_ENTITIES].GetAt(i); // will also remove it from this list
          assert(m_lstEntities[STATIC_ENTITIES].Count() == (nCountBefore-1));
          i--;
        }
      }
    }
  }
  else
  {
    while(m_lstEntities[STATIC_ENTITIES].Count())
    {
      EERType eType = m_lstEntities[STATIC_ENTITIES].GetAt(0)->GetEntityRenderType();
      assert(eType == eERType_Brush || eType == eERType_Vegetation);
      int nCountBefore = m_lstEntities[STATIC_ENTITIES].Count();
			
			if(eType != eERType_Vegetation)
				Get3DEngine()->ReleaseObject(m_lstEntities[STATIC_ENTITIES].GetAt(0)->GetEntityStatObj(0));
			m_lstEntities[STATIC_ENTITIES].GetAt(0)->SetEntityStatObj(0,0);

			IEntityRender * pEntityRender =	m_lstEntities[STATIC_ENTITIES].GetAt(0); // will also remove it from this list
      delete pEntityRender; // will also remove it from this list

      assert(m_lstEntities[STATIC_ENTITIES].Count() == (nCountBefore-1));
    }
    assert(m_lstEntities[STATIC_ENTITIES].Count()==0);
    m_eSStatus = eSStatus_Unloaded;
  }

	UnmakeAreaBrush();
}

bool CBasicArea::CheckUnload()
{
  if(CStatObj::m_fStreamingTimePerFrame>=CGF_STREAMING_MAX_TIME_PER_FRAME)
    return (m_eSStatus == eSStatus_Ready);

  CStatObj::m_fStreamingTimePerFrame -= GetTimer()->GetAsyncCurTime();

  if(m_nLastUsedFrameId < GetFrameID() - 100)// && m_lstEntities[STATIC_ENTITIES].Count())
  { // unload
    Unload();
  }

  CStatObj::m_fStreamingTimePerFrame += GetTimer()->GetAsyncCurTime();

  return (m_eSStatus == eSStatus_Ready);
}

void CBasicArea::CheckPhysicalized()
{
  if(m_eSStatus != eSStatus_Ready)
    SerializeArea(false);

  for(int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++)
    m_lstEntities[STATIC_ENTITIES][i]->CheckPhysicalized();

  m_nLastUsedFrameId = GetFrameID();
}

void CBasicArea::PreloadResources(Vec3d vPrevPortalPos, float fPrevPortalDistance)
{
	FUNCTION_PROFILER( GetSystem(),PROFILE_3DENGINE );
	int nFrameId = GetFrameID();
	for(int nStatic=0; nStatic<2; nStatic++)
	for( int i=0; i<m_lstEntities[nStatic].Count() && GetCurTimeSec()<(m_fPreloadStartTime+0.010f); i++ )
	{
		if((nFrameId%8) == (i%8))
			m_lstEntities[nStatic].GetAt(i)->PreloadInstanceResources(vPrevPortalPos, fPrevPortalDistance, 1.f);	
	}
}

void CBasicArea::UnregisterDynamicEntities()
{
	while(m_lstEntities[DYNAMIC_ENTITIES].Count())
	{
		EERType eType = m_lstEntities[DYNAMIC_ENTITIES].GetAt(0)->GetEntityRenderType();
		assert(eType != eERType_Brush && eType != eERType_Vegetation);
		int nCountBefore = m_lstEntities[DYNAMIC_ENTITIES].Count();
		//		delete m_lstEntities[DYNAMIC_ENTITIES].GetAt(0); // will also remove it from this list
		Get3DEngine()->UnRegisterEntity(m_lstEntities[DYNAMIC_ENTITIES].GetAt(0));
		assert(m_lstEntities[DYNAMIC_ENTITIES].Count() == (nCountBefore-1));
	}
	assert(m_lstEntities[DYNAMIC_ENTITIES].Count()==0);
}

int __cdecl CObjManager__Cmp_EntTmpDistance(const void* v1, const void* v2);

void CBasicArea::SortStaticInstancesBySize(VolumeInfo * pFogVolume)
{
	// sort lists instances in sector by size ( for rendering speed up )
	for( int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++)
	{
		m_lstEntities[STATIC_ENTITIES][i]->GetEntityRS()->fTmpDistance = 
			-m_lstEntities[STATIC_ENTITIES][i]->GetMaxViewDist();

		m_lstEntities[STATIC_ENTITIES][i]->m_fWSMaxViewDist = m_lstEntities[STATIC_ENTITIES][i]->GetMaxViewDist();
	}

	// sort
	if(m_lstEntities[STATIC_ENTITIES].Count())
		qsort(m_lstEntities[STATIC_ENTITIES].GetElements(), m_lstEntities[STATIC_ENTITIES].Count(), 
		sizeof(m_lstEntities[STATIC_ENTITIES][0]), CObjManager__Cmp_EntTmpDistance);

	m_lstStaticShadowMapCasters.Clear();
	for( int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++)
	{
		IEntityRender * pEntityRender =	m_lstEntities[STATIC_ENTITIES][i];
		if(pEntityRender->GetRndFlags()&ERF_CASTSHADOWMAPS)
			m_lstStaticShadowMapCasters.Add(pEntityRender);
	}

	m_lstStatEntInfoVegetNoCastersNoVolFog.Clear();
	m_lstStatEntInfoOthers.Clear();
	for( int i=0; i<m_lstEntities[STATIC_ENTITIES].Count(); i++)
	{
		IEntityRender * pEntityRender =	m_lstEntities[STATIC_ENTITIES][i];
		IEntityRenderInfo inf(pEntityRender);

		bool bInFogVolume = false;
		if(pFogVolume)
		{ // fog is set only for outdoors
			Vec3d vBoxMin,vBoxMax;
			assert(pEntityRender->m_pSector);
			pEntityRender->GetBBox(vBoxMin,vBoxMax);
			if(pFogVolume->IntersectBBox(vBoxMin,vBoxMax))
				bInFogVolume = true;
		}

		if(	!(pEntityRender->GetRndFlags() & (ERF_CASTSHADOWMAPS|ERF_CASTSHADOWVOLUME|ERF_RECVSHADOWMAPS|ERF_SELFSHADOW)) && 
				pEntityRender->GetEntityRenderType() ==	eERType_Vegetation && 
				!bInFogVolume)
			m_lstStatEntInfoVegetNoCastersNoVolFog.Add(inf);
		else
			m_lstStatEntInfoOthers.Add(inf);
	}

	m_StaticEntitiesSorted = true;

	// swap to disk
	if(GetCVars()->e_stream_areas)
		SerializeArea(true);
}

int __cdecl CBasicArea__Cmp_MatChunks(const void* v1, const void* v2)
{
	CMatInfo * pMat1 = (CMatInfo*)v1;
	CMatInfo * pMat2 = (CMatInfo*)v2;

	// shader
	if(pMat1->shaderItem.m_pShader->GetTemplate(-1) > pMat2->shaderItem.m_pShader->GetTemplate(-1))
		return  1;
	else if(pMat1->shaderItem.m_pShader->GetTemplate(-1) < pMat2->shaderItem.m_pShader->GetTemplate(-1))
		return -1;

	// shader resources
	if(pMat1->shaderItem.m_pShaderResources > pMat2->shaderItem.m_pShaderResources)
		return  1;
	else if(pMat1->shaderItem.m_pShaderResources < pMat2->shaderItem.m_pShaderResources)
		return -1;

	// lm tex id
	if(pMat1->m_Id > pMat2->m_Id)
		return  1;
	else if(pMat1->m_Id < pMat2->m_Id)
		return -1;

	return 0;

/*
	const char * pName1 = ((*(((*(pMat1)).shaderItem).m_pShaderResources)).m_Textures)[0] ? (*(((*(((*(pMat1)).shaderItem).m_pShaderResources)).m_Textures)[0])).m_Name.c_str() : "";
	const char * pName2 = ((*(((*(pMat2)).shaderItem).m_pShaderResources)).m_Textures)[0] ? (*(((*(((*(pMat2)).shaderItem).m_pShaderResources)).m_Textures)[0])).m_Name.c_str() : "";

	return strcmp(pName1,pName2);*/
}

struct LMTexCoord
{
	float s,t;
};

void CBasicArea::MakeAreaBrush()
{
	const Vec3d vCamPos = GetViewCamera().GetPos();

	int nEntityId=0;
	int nNextStartId=-1;
	while(nEntityId<m_lstEntities[STATIC_ENTITIES].Count() || nNextStartId>=0)
	{
		static list2<struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F> lstVerts;lstVerts.Clear();
		static list2<LMTexCoord> lstLMTexCoords; lstLMTexCoords.Clear();
		static list2<ushort> lstIndices; lstIndices.Clear();
		static list2<ushort> lstIndicesSorted; lstIndicesSorted.Clear();
		static list2<CMatInfo> lstChunks; lstChunks.Clear();
		static list2<CMatInfo> lstChunksMerged; lstChunksMerged.Clear();
		static list2<SPipTangents> lstTangBasises; lstTangBasises.Clear();

		Vec3d vBoxMax(-10000,-10000,-10000);
		Vec3d vBoxMin( 10000, 10000, 10000);

		int nLMTexId=-1;
		int nHDRLMTexId=-1;
		int nLMDirTexId=-1;
		int nCurVertsNum=0;
		
		if(nNextStartId>=0)
			nEntityId = nNextStartId;
		nNextStartId=-1;

		for( ; nEntityId<m_lstEntities[STATIC_ENTITIES].Count(); nEntityId++)
		{
			IEntityRender * pEntityRender	= m_lstEntities[STATIC_ENTITIES][nEntityId];

			if(	pEntityRender->m_dwRndFlags & ERF_MERGED ||
					pEntityRender->m_dwRndFlags & ERF_CASTSHADOWVOLUME ||
					pEntityRender->m_dwRndFlags & ERF_CASTSHADOWMAPS)
				continue;

//			Vec3d vCenter = (pEntityRender->m_vWSBoxMin+pEntityRender->m_vWSBoxMax)*0.5f;
//			float fEntDistance = GetDist2D( vCamPos.x, vCamPos.y, vCenter.x, vCenter.y );
//			if(fEntDistance > pEntityRender->GetMaxViewDist())
//				continue;

//			if(fEntDistance > GetCVars()->e_area_merging_distance)
	//			continue;

			if(nLMTexId<0)
			{
				nLMTexId = pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetColorLerpTex() : 0;
				nHDRLMTexId = pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetHDRColorLerpTex() : 0;
				nLMDirTexId = pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetDomDirectionTex() : 0;
			}
			else
			{
				if(nLMTexId != (pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetColorLerpTex() : 0) ||
					nLMDirTexId != (pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetDomDirectionTex() : 0) ||
					nHDRLMTexId != (pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetHDRColorLerpTex() : 0))
				{
					if(nNextStartId<0)
						nNextStartId = nEntityId;
					continue;
				}
			}

			Matrix44 mat;
			mat.SetIdentity();
			mat*=0;
			IStatObj * pStatObj = pEntityRender->GetEntityStatObj(0,&mat);
			if(!pStatObj)
				continue;

			EERType eType = pEntityRender->GetEntityRenderType();
			if(eType == eERType_Vegetation)
			{
				Matrix33diag diag	=	Vec3(pEntityRender->GetScale(),pEntityRender->GetScale(),pEntityRender->GetScale());	//use diag-matrix for scaling
				mathCalcMatrix(mat, pEntityRender->GetPos(), Vec3d(0,0,0), 
					Vec3d(pEntityRender->GetScale(),pEntityRender->GetScale(),pEntityRender->GetScale()),
					Cry3DEngineBase::m_CpuFlags);
			}

			if(!CBrush::IsMatrixValid(mat))
				continue;

			CLeafBuffer * pLMLB = pEntityRender->GetLightmapTexCoord(0);

			CLeafBuffer * pLB = pStatObj->GetLeafBuffer();
			if(!pLB->m_SecVertCount)
				continue;

			if(nCurVertsNum + pLB->m_SecVertCount>65000)
				break;
 
			int nIndCount=0;
			pLB->GetIndices(&nIndCount);
			if(nIndCount > GetCVars()->e_area_merging_max_tris_in_input_brush*3)
				continue;

			int nInitVertCout = lstVerts.Count();
			for(int m=0; m<pLB->m_pMats->Count(); m++)
			{
				CMatInfo newMatInfo = *pLB->m_pMats->Get(m);

				if(GetCVars()->e_materials)
				{ // Override default material
					CMatInfo * pCustMat = (CMatInfo *)pEntityRender->GetMaterial();
					if (pCustMat)
					{
						int nMatId = newMatInfo.m_nCGFMaterialID;
						if(nMatId<0)
							continue;

						if (nMatId == 0)
							pCustMat = (CMatInfo*)pCustMat;
						else if (nMatId-1 < pCustMat->GetSubMtlCount())
							pCustMat = (CMatInfo*)pCustMat->GetSubMtl(nMatId-1);

						newMatInfo.shaderItem = pCustMat->shaderItem;
					}
				}

				// copy indices
				for(int i=newMatInfo.nFirstIndexId; i<newMatInfo.nFirstIndexId+newMatInfo.nNumIndices; i++)
					lstIndices.Add(pLB->GetIndices(0)[i]+nInitVertCout);
				newMatInfo.nFirstIndexId = lstIndices.Count() - newMatInfo.nNumIndices;

				// copy verts
				int nPosStride=0;
				const byte * pPos = pLB->GetPosPtr(nPosStride,0,true);
				int nTexStride=0;
				const byte * pTex = pLB->GetUVPtr(nTexStride,0,true);

				// get tengent basis
				int nTangStride=0;
				const byte * pTang = pLB->GetTangentPtr(nTangStride,0,true);
				int nTnormStride=0;
				const byte * pTNorm = pLB->GetTNormalPtr(nTnormStride,0,true);
				int nBNormStride=0;
				const byte * pBNorm = pLB->GetBinormalPtr(nBNormStride,0,true);
				int nColorStride=0;
				const byte * pColor = pLB->GetColorPtr(nColorStride,0,true);

				// get LM TexCoords
				int nLMStride=0;
				const byte * pLMTexCoords = pLMLB ? pLMLB->GetPosPtr(nLMStride,0,true) : 0;

				for(int v=newMatInfo.nFirstVertId; v<newMatInfo.nFirstVertId+newMatInfo.nNumVerts; v++)
				{
					struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F vert;

					// set pos
					Vec3d vPos = *(Vec3d*)&pPos[nPosStride*v];				
					vPos = mat.TransformPointOLD(vPos);
          vert.xyz = vPos;

          // set uv
          float * pUV = (float*)&pTex[nTexStride*v];				
          vert.st[0] = pUV[0];
          vert.st[1] = pUV[1];

          vert.color.dcolor = *(DWORD*)&pColor[nColorStride*v+0];

					// calc bbox
					vBoxMin.CheckMin(vPos);
					vBoxMax.CheckMax(vPos);

					lstVerts.Add(vert);

					// add tbasis
					SPipTangents basis;
					basis.m_Tangent = mat.TransformVectorOLD(*(Vec3d*)&pTang[nTangStride*v]);
					basis.m_TNormal = mat.TransformVectorOLD(*(Vec3d*)&pTNorm[nTnormStride*v]);
					basis.m_Binormal= mat.TransformVectorOLD(*(Vec3d*)&pBNorm[nBNormStride*v]);
					lstTangBasises.Add(basis);

					// add LM texcoords
					LMTexCoord vLMTC;
					if(pLMTexCoords)
						vLMTC = *(LMTexCoord*)&pLMTexCoords[nLMStride*v];
					else
						vLMTC.s = vLMTC.t = 0;

					lstLMTexCoords.Add(vLMTC);
				}

				// set vert range
				newMatInfo.nFirstVertId = lstVerts.Count() - newMatInfo.nNumVerts;

				newMatInfo.pRE = 0;
				newMatInfo.m_Id = pEntityRender->GetLightmap(0) ? pEntityRender->GetLightmap(0)->GetColorLerpTex() : 0;

				if(newMatInfo.nNumIndices)
				{
					lstChunks.Add(newMatInfo);
				}
				else
					assert(!newMatInfo.nNumVerts);
			}
			nCurVertsNum += pLB->m_SecVertCount;
			
			pEntityRender->m_dwRndFlags |= ERF_MERGED;
		}

		CBrush * pAreaBrush = 0;
		if(!lstVerts.Count())
		{ // make empty brush - no geometry in sector
			pAreaBrush = new CBrush;
			m_lstAreaBrush.Add(pAreaBrush);
			return;
		}

		// sort
		if(lstChunks.Count())
			qsort(lstChunks.GetElements(), lstChunks.Count(), 
			sizeof(lstChunks[0]), CBasicArea__Cmp_MatChunks);

		// merge chunks
		for(int nChunk=0; nChunk<lstChunks.Count(); nChunk++)
		{
			if(!nChunk || CBasicArea__Cmp_MatChunks(&lstChunks[nChunk], &lstChunks[nChunk-1]))
			{ // not equal materials - add new chunk
				lstChunksMerged.Add(lstChunks[nChunk]);
				lstChunksMerged.Last().nFirstIndexId = lstIndicesSorted.Count();
				lstChunksMerged.Last().nNumIndices = 0;

				lstChunksMerged.Last().nFirstVertId = 0;
				lstChunksMerged.Last().nNumVerts = lstVerts.Count();
			}

			// add indices
			for(int nId=lstChunks[nChunk].nFirstIndexId; nId<lstChunks[nChunk].nFirstIndexId+lstChunks[nChunk].nNumIndices; nId++)
				lstIndicesSorted.Add(lstIndices[nId]);

			// update start/stop pos
			lstChunksMerged.Last().nNumIndices += lstChunks[nChunk].nNumIndices;
		}

		lstChunks = lstChunksMerged;
		lstIndices = lstIndicesSorted;

		// make leaf buffer
		CLeafBuffer * pAreaLB = GetRenderer()->CreateLeafBufferInitialized(
			lstVerts.GetElements(), lstVerts.Count(), VERTEX_FORMAT_P3F_COL4UB_TEX2F, 
			lstIndices.GetElements(), lstIndices.Count(), R_PRIMV_TRIANGLES,
			"AreaLB", eBT_Static, lstChunks.Count());

		pAreaLB->UpdateTangBuffer(lstTangBasises.GetElements());

		for(int i=0; i<lstChunks.Count(); i++)
		{
			pAreaLB->SetChunk(lstChunks[i].GetShaderItem().m_pShader,
				lstChunks[i].nFirstVertId, lstChunks[i].nNumVerts,
				lstChunks[i].nFirstIndexId, lstChunks[i].nNumIndices, i, true);

			assert(lstChunks[i].GetShaderItem().m_pShaderResources);
			assert(lstChunks[i].GetShaderItem().m_pShader);
			pAreaLB->m_pMats->Get(i)->shaderItem = lstChunks[i].GetShaderItem();
			
			pAreaLB->m_pMats->Get(i)->shaderItem.m_pShader->AddRef();
			pAreaLB->m_pMats->Get(i)->shaderItem.m_pShaderResources->AddRef();
		}

		// make statobj
		CStatObj * pAreaStatObj = new CStatObj();
		pAreaStatObj->m_nLoadedTrisCount = lstIndices.Count()/3;
		pAreaStatObj->SetLeafBuffer(pAreaLB);
		pAreaStatObj->SetBBoxMin(vBoxMin);
		pAreaStatObj->SetBBoxMax(vBoxMax);
		pAreaStatObj->RegisterUser();

		// make brush
		pAreaBrush = new CBrush();

	//	if(m_pAreaBrush == (CBrush*)0x0e968358)
		//	int b=0;

		Matrix44 mat;
		mat.SetIdentity();
		pAreaBrush->SetEntityStatObj(0,pAreaStatObj,&mat);
		pAreaBrush->m_vWSBoxMin = vBoxMin;
		pAreaBrush->m_vWSBoxMax = vBoxMax;
		pAreaBrush->m_fWSRadius = vBoxMin.GetDistance(vBoxMax)*0.5f;

		// Make leafbuffer and fill it with texture coordinates
		if(nLMTexId && (nLMDirTexId || (GetCVars()->e_light_maps_quality==0)))
		{
			RenderLMData * pLMData = new RenderLMData(GetRenderer(), nLMTexId, nHDRLMTexId, nLMDirTexId);
			pAreaBrush->SetLightmap(pLMData, (float*)lstLMTexCoords.GetElements(), lstLMTexCoords.Count(), 0);
			pLMData->AddRef();
			pAreaBrush->SetRndFlags(ERF_USELIGHTMAPS,true);
		}

		Get3DEngine()->UnRegisterEntity(pAreaBrush);
		Get3DEngine()->RegisterEntity(pAreaBrush);

		// find distance to the camera
		const Vec3d vCamPos = GetViewCamera().GetPos();
		Vec3d vCenter = (pAreaBrush->m_vWSBoxMin+pAreaBrush->m_vWSBoxMax)*0.5f;
		float fEntDistance = GetDist2D( vCamPos.x, vCamPos.y, vCenter.x, vCenter.y );

		assert(fEntDistance>=0);
		assert(_finite(fEntDistance));

		m_lstAreaBrush.Add(pAreaBrush);
	}
}

void CBasicArea::FreeAreaBrush(CBrush * pAreaBrush)
{
	if(!pAreaBrush)
		return;

	Get3DEngine()->UnRegisterEntity(pAreaBrush);

//	if(m_pAreaBrush == (CBrush*)0x0e968358)
	//	int b=0;

	CStatObj * pAreaStatObj = (CStatObj *)pAreaBrush->GetEntityStatObj(0);
	if(pAreaStatObj)
	{
		pAreaBrush->SetEntityStatObj(0,0);
		pAreaStatObj->UnregisterUser();
		CLeafBuffer * pAreaLB = pAreaStatObj->GetLeafBuffer();
		pAreaStatObj->SetLeafBuffer(0);
		
		GetRenderer()->DeleteLeafBuffer(pAreaLB);
		delete pAreaStatObj;
	}
	delete pAreaBrush;
	pAreaBrush=0;
}

CBasicArea::~CBasicArea()
{
	for( int i=0; i<m_lstAreaBrush.Count(); i++ )
		FreeAreaBrush(m_lstAreaBrush[i]);
	m_lstAreaBrush.Clear();
}


int CBasicArea::GetLastStaticElementIdWithInMaxViewDist(float fMaxViewDist)
{ // use binary search to find range of elements visible on fMaxViewDist
	int nCount = m_lstEntities[STATIC_ENTITIES].Count();
	int nCurrId = m_lstEntities[STATIC_ENTITIES].Count()/2;
	for(int nJump=2; (nCount>>nJump); nJump++)
	{
		IEntityRender * pCaster = m_lstEntities[STATIC_ENTITIES][nCurrId];
		if(pCaster->m_fWSMaxViewDist<fMaxViewDist)
			nCurrId -= nCount>>nJump;
		else
			nCurrId += nCount>>nJump;
	}

	return min(nCurrId+2,m_lstEntities[STATIC_ENTITIES].Count());
}