/*** Crealysm 3D engine, by Cristiaan Kop - updated					     15-08-2013 ***/
/*** ============================================================================== ***/
/*** NAMESPACE: CREALYSM_RENDERER													***/
/*** cpp file with Crealysm scenegraph functions, API independent; CD3dscene src	***/

#include <algorithm>
#include <fstream>
#include <vector>

#include "Crealysm_scenegraph.h"

#include "Crealysm_d3dscene.h"
#include "Crealysm_d3dlight.h"
#include "Crealysm_d3dcam.h"
#include "Crealysm_d3dshader.h"
#include "Crealysm_math.h"
#include "Crealysm_dxmath.h"		// for d3dx vector comparisons

using namespace Crealysm_d3drenderer;
using namespace Crealysm_math;

using namespace std;

namespace Crealysm_renderer
{

/**************************************************************************************/
/***								CONSTRUCTOR										***/
/*** ==> usage: when creating a CSceneGraph object									***/
/*** ==> sets all variables in the CSceneGraph object to initial values				***/
/**************************************************************************************/

CSceneGraph::CSceneGraph()
{
	mMaxDirLights			= 0;
	mMaxPointLights			= 0;

	mMeshDataCreated		= false;
	mMeshInstDataCreated	= false;
	mLightDataCreated		= false;
	mEffectDataCreated		= false;
	mEffectMeshDataCreated	= false;
	mEffectMatDataCreated	= false;
}

/**************************************************************************************/
/***								DESTRUCTOR										***/
/*** ==> usage: when CSceneGraph object is not needed anymore						***/
/*** ==> deletes all dynamic arrays with render queue and scene data				***/
/**************************************************************************************/

CSceneGraph::~CSceneGraph()
{
//	no memory freeing, using std::vector now
}

/**************************************************************************************/
/***								CREATE											***/
/*** ==> usage: when cd3dscene is loaded and scenegraph is needed					***/
/*** ==> creates the scenegraph data and generates all indices						***/
/**************************************************************************************/

bool CSceneGraph::Create(const Crealysm_d3drenderer::CD3dscene &pD3dscene, const int pLightingEffectId)
{
	if(!pD3dscene.IsLoaded()) return false;

	mMaxDirLights	= pD3dscene.mShaders[pLightingEffectId].GetNrDirLights();
	mMaxPointLights	= pD3dscene.mShaders[pLightingEffectId].GetNrMaxPointLights();

	if(!CreateMeshData(pD3dscene))			return false;
	if(!CreateMeshInstData(pD3dscene))		return false;
	if(!CreateMaterialData(pD3dscene))		return false;

	if(!CreateLightData(pD3dscene))			return false;
	
	// Effects - shaders
	if(!CreateEffectMeshData(pD3dscene))	return false;
	if(!CreateEffectMaterialData())			return false;
	if(!CreateEffectMatMeshIndex())			return false;
	mEffectDataCreated = true;

	return true;
}

/**************************************************************************************/
/***						UPDATE DIST TO CAM MI BLENDED							***/
/*** ==> usage: during updating the 3d scene graph									***/
/*** ==> updates distance to camera for all blended meshinstances					***/
/**************************************************************************************/

void CSceneGraph::UpdateDistToCamMIBlended(const CD3dscene &pD3dscene, const CD3dcam &pCam)
{
	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		for(size_t mat=0;mat<mEffect[fx].materialsBlended.size();++mat)
		{
			for(size_t m=0;m<mEffect[fx].meshesPerMatBlended[mat].meshes.size();++m)
			{
				auto &mesh = mEffect[fx].meshesPerMatBlended[mat].instance[m];
				for(size_t mi=0;mi<mesh.instances.size();++mi)

					mMeshInst[mesh.instances[mi]].distToCam = pD3dscene.mMeshInst[mesh.instances[mi]].GetDistToCam(pCam.GetPosition());
			}
		}
	}
}

/**************************************************************************************/
/***							UPDATE DIST TO CAM LIGHTS							***/
/*** ==> usage: during updating the 3d scene graph									***/
/*** ==> updates distance to camera for all positional lights (i.e. point lights)	***/
/**************************************************************************************/

void CSceneGraph::UpdateDistToCamLights(const CD3dscene &pD3dscene, const CD3dcam &pCam)
{
	for(size_t lc=0;lc<mPointLights.size();++lc)
	{
		mLights[mPointLights[lc]].distToCam = pD3dscene.mLights[mPointLights[lc]].UpdateDistToCam(pCam.GetPosition());
	}
}

/**************************************************************************************/
/***							SORT BLENDED MESHES									***/
/*** ==> usage: during updating the 3d scene graph									***/
/*** ==> updates meshInstBlended inst vector sorted back to front on cam distance	***/
/**************************************************************************************/

bool CSceneGraph::SortBlendedMeshes()
{
	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		for(size_t mat=0;mat<mEffect[fx].materialsBlended.size();++mat)
		{
			for(size_t m=0;m<mEffect[fx].meshesPerMatBlended[mat].meshes.size();++m)
			{
				auto &inst = mEffect[fx].meshesPerMatBlended[mat].instance[m];

				for(size_t mi=0;mi<inst.instances.size();++mi) 
				{
					inst.blendedMeshIndexTemp[mi] = inst.instances[mi];
					inst.blendedMeshDistToCam[mi] = mMeshInst[inst.instances[mi]].distToCam;
				}

				sort(inst.blendedMeshOrderTemp.begin(), inst.blendedMeshOrderTemp.end(), [&](int a, int b) 
					{ return inst.blendedMeshDistToCam[a] > inst.blendedMeshDistToCam[b]; });

				for(size_t mi=0;mi<inst.instances.size();++mi) 
					inst.instances[mi] = inst.blendedMeshIndexTemp[inst.blendedMeshOrderTemp[mi]];
			}
		}
	}
	return true;
}

/**************************************************************************************/
/***								CULL LIGHTS										***/
/*** ==> usage: during updating the 3d scene graph									***/
/*** ==> updates active light indices for pos lights, no sorting overall for scene	***/
/**************************************************************************************/

bool CSceneGraph::CullLights(const CD3dscene &pD3dscene)
{
	// find all visible positional lights, now only point lights
	mVisiblePointLights.resize(0);

	for(size_t lc=0;lc<mPointLights.size();++lc)
	{
		if(pD3dscene.mLights[mPointLights[lc]].IsVisible())
		{
			mVisiblePointLights.push_back(1);
			mVisiblePointLights.back() = mPointLights[lc];
		}
	}
	return true;
}

/**************************************************************************************/
/***							CREATE MESH DATA									***/
/*** ==> usage: during scenegraph creation, 1st step								***/
/*** ==> fills the mMesh index with all mesh specific data, no submesh data			***/
/**************************************************************************************/

bool CSceneGraph::CreateMeshData(const CD3dscene &pD3dscene)
{
	bool found;

	mMesh.resize(pD3dscene.GetNrMeshes());

	for(size_t m=0;m<mMesh.size();++m)
	{
		mMesh[m].matIds.resize(0);
		mMesh[m].matIds.reserve(pD3dscene.mMeshes[m].GetNrMaterials());

		for(size_t mat=0;mat<pD3dscene.GetNrMaterials();++mat)
		{
			found = false;
			for(DWORD sub=0;sub<pD3dscene.GetNrSubmeshes();++sub)
			{
				if(pD3dscene.mMatSubMeshIndex[sub].mesh == m && pD3dscene.mMatSubMeshIndex[sub].mat == mat)
				{
					found = true;
				}
			}
			if(found)
			{
				mMesh[m].matIds.push_back(1);
				mMesh[m].matIds.back() = mat;
			}
		}
	}
	mMeshDataCreated = true;
	return true;
}

/**************************************************************************************/
/***							CREATE MESH INST DATA								***/
/*** ==> usage: during scenegraph creation, after mesh data is created (2nd step)	***/
/*** ==> fills the mMeshInst index with all mesh instance specific data 			***/
/**************************************************************************************/

bool CSceneGraph::CreateMeshInstData(const CD3dscene &pD3dscene)
{
	if(!mMeshDataCreated) return false;
	mMeshInst.resize(pD3dscene.GetNrMeshInst());
	mDynamicMeshInstIndex.resize(0);
	mDynamicMeshInstIndex.reserve(mMeshInst.size());

	for(size_t mi=0;mi<mMeshInst.size();++mi)
	{
		mMeshInst[mi].meshId		= pD3dscene.mMeshInst[mi].GetMeshId();
		mMeshInst[mi].effectId		= pD3dscene.mMeshInst[mi].GetEffectIndex();
		mMeshInst[mi].distToCam		= 0.0f;

		if(pD3dscene.mMeshInst[mi].IsDynamic())
		{
			mDynamicMeshInstIndex.push_back(1);
			mDynamicMeshInstIndex.back() = mi;
		}
		mMeshInst[mi].affectedPointLights.reserve(mMaxPointLights);
	}
	mMeshInstDataCreated = true;

	// WEAPON
	mMeshInstWeapon.affectedPointLights.reserve(mMaxPointLights);

	return true;
}

/**************************************************************************************/
/***							CREATE MATERIAL DATA								***/
/*** ==> usage: during scenegraph creation, 3rd step								***/
/*** ==> fills the mMaterials index with submesh and mesh ID's that uses material	***/
/**************************************************************************************/

bool CSceneGraph::CreateMaterialData(const CD3dscene &pD3dscene)
{
	if(!mMeshDataCreated) return false;
	
	mMaterials.resize(pD3dscene.GetNrMaterials());

	for(size_t mat=0;mat<mMaterials.size();++mat)
	{
		mMaterials[mat].meshes.resize(mMesh.size());

		bool matused;
		for(size_t m=0;m<mMesh.size();++m)
		{
			matused = false;	
			for(size_t mi=0;mi<mMesh[m].matIds.size();++mi)
			{
				if(mMesh[m].matIds[mi] == mat)
				{
					matused = true;				
					break;
				}
			}
		
			if(!matused) mMaterials[mat].meshes[m].submeshes.resize(0);
			else
			{
				auto &mesh = mMaterials[mat].meshes[m];
				mesh.submeshes.resize(0);
				mesh.submeshes.reserve(pD3dscene.GetNrSubmeshes());			
				for(DWORD sub=0;sub<pD3dscene.GetNrSubmeshes();++sub)
				{
					if(pD3dscene.mMatSubMeshIndex[sub].mesh == m && pD3dscene.mMatSubMeshIndex[sub].mat == mat)
					{
						mesh.submeshes.push_back(1);
						mesh.submeshes.back() = pD3dscene.mMatSubMeshIndex[sub].submesh;
					}
				}
			}
		}
	}
	return true;
}

/**************************************************************************************/
/***							CREATE LIGHT DATA									***/
/*** ==> usage: during scenegraph creation, 4th step								***/
/*** ==> fills the light source incides for both directional and point lights		***/
/**************************************************************************************/

bool CSceneGraph::CreateLightData(const CD3dscene &pD3dscene)
{
	mLights.resize(pD3dscene.GetNrLights());

	mDirLights.resize(0);
	mPointLights.resize(0);

	mVisibleDirLights.reserve(mDirLights.size());
	mVisibleDirLights.resize(0);

	for(size_t lc=0;lc<mLights.size();++lc)
	{
		if(pD3dscene.mLights[lc].IsDirectional())
		{
			mLights[lc].directional = true;
			mLights[lc].point = false;

			mDirLights.push_back(1);
			mDirLights.back() = lc;

			if(pD3dscene.mLights[lc].GetEnabled())
			{
				mVisibleDirLights.push_back(1);
				mVisibleDirLights.back() = lc;
			}
		}
		else if(pD3dscene.mLights[lc].IsPoint())
		{
			mLights[lc].point = true;
			mLights[lc].directional = false;

			mPointLights.push_back(1);
			mPointLights.back() = lc;
		}
		mLights[lc].distToCam = 0.0f;
	}

	mVisiblePointLights.reserve(mPointLights.size());		
	mLightDataCreated = true;
	return true;
}

/**************************************************************************************/			
/***						UPDATE LIGHT AFFECT MESH DATA							***/			
/*** ==> usage: during scenegraph updating, after mesh/light data created 			***/			
/*** ==> fills the mesh inst affected lights data with lighs affecting the meshinst ***/			
/**************************************************************************************/			

bool CSceneGraph::UpdateLightAffectMeshData(const CD3dscene &pD3dscene)							
{
	if(!mMeshInstDataCreated || !mLightDataCreated) return false;

	bool max = false;

	// Loop through all visible mesh instances and visible point lights to match
	for(size_t mi=0;mi<mMeshInst.size();++mi)
	{
		if(pD3dscene.mMeshInst[mi].IsVisible())
		{
			mMeshInst[mi].affectedPointLights.resize(0);
			max = false;

			for(size_t lc=0;lc<mVisiblePointLights.size();++lc)
			{
				float dist = Crealysm_dxmath::CoordToCoordDist(pD3dscene.mMeshInst[mi].GetWorldPos(), pD3dscene.mLights[mVisiblePointLights[lc]].GetPos());

				if(dist <= (pD3dscene.mLights[mVisiblePointLights[lc]].GetRange() + pD3dscene.mMeshInst[mi].GetSphereBoundingRadius()))	// LIGHT AFFECTS
				{
					mMeshInst[mi].affectedPointLights.push_back(1);
					mMeshInst[mi].affectedPointLights.back() = mVisiblePointLights[lc];
				
					if(mMeshInst[mi].affectedPointLights.size() == mMaxPointLights) max = true;
					/*** TO BE OPTIMIZED??? DYNAMIC / STATIC MESH INST AND LIGHTS ***/
					/*** TO BE IMPROVED??? SORT ON LIGHTS DISTANCE/IMPACT FOR EACH MESH INSTANCE, IF MORE THEN MAX LIGHTS? ***/
				}
				if(max) break;
			}
		}
	}
	return true;
}

/**************************************************************************************/			
/***						UPDATE LIGHT AFFECT WEAPON MESH 						***/			
/*** ==> usage: during scenegraph updating, after mesh/light data created 			***/			
/*** ==> fills the weapon mesh inst affected array with affecting point lights		***/			
/**************************************************************************************/			

bool CSceneGraph::UpdateLightAffectWeaponMesh(const CD3dscene &pD3dscene, const Crealysm_d3drenderer::CD3dcam &pCam)
{
	if(!pD3dscene.WeaponInScene()) return true;

	mMeshInstWeapon.affectedPointLights.resize(0);
	bool max = false;

	for(size_t lc=0;lc<mVisiblePointLights.size();++lc)
	{
		float dist = Crealysm_dxmath::CoordToCoordDist(pCam.GetPosition(), pD3dscene.mLights[mVisiblePointLights[lc]].GetPos());

		if(dist <= (pD3dscene.mLights[mVisiblePointLights[lc]].GetRange() + pD3dscene.mWeaponMeshInst[pD3dscene.GetCurrentWeapon()].GetSphereBoundingRadius()))	// LIGHT AFFECTS
		{
			mMeshInstWeapon.affectedPointLights.push_back(1);
			mMeshInstWeapon.affectedPointLights.back() = mVisiblePointLights[lc]; ////[mMeshInstWeapon.nrAffectedPointLights] = mVisiblePointLights[lc];
				
			if(mMeshInstWeapon.affectedPointLights.size() == mMaxPointLights) max = true;
			/*** TO BE OPTIMIZED??? DYNAMIC / STATIC MESH INST AND LIGHTS ***/
			/*** TO BE IMPROVED??? SORT ON LIGHTS DISTANCE/IMPACT FOR EACH MESH INSTANCE, IF MORE THEN MAX LIGHTS? ***/
		}
		if(max) break;
	}
	return true;
}

/**************************************************************************************/
/***							CREATE EFFECT MESH DATA								***/
/*** ==> usage: during scenegraph creation, after mesh/inst/material data 			***/
/*** ==> fills the mEffect structs with all indices for each effect/shader			***/
/**************************************************************************************/

bool CSceneGraph::CreateEffectMeshData(const Crealysm_d3drenderer::CD3dscene &pD3dscene)
{
	if(!mMeshDataCreated) return false;
	
	mEffect.resize(pD3dscene.GetNrShaders());

	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		// find and save MESH INSTANCES for each effect
		mEffect[fx].meshInst.resize(0);
		mEffect[fx].meshInst.reserve(mMeshInst.size());
		
		for(size_t mi=0;mi<mMeshInst.size();++mi)
		{
			if(mMeshInst[mi].effectId == fx)
			{
				mEffect[fx].meshInst.push_back(1);
				mEffect[fx].meshInst.back() = mi;
			}
		}


		// find and save MESHES for each effect
		mEffect[fx].mesh.resize(0);
		mEffect[fx].mesh.reserve(mMesh.size());

		for(size_t m=0;m<mMesh.size();++m)
		{
			bool meshtemp = false;
			for(size_t mi=0;mi<mEffect[fx].meshInst.size();++mi)
			{
				int test = mMeshInst[mEffect[fx].meshInst[mi]].meshId;
				if(test == m) meshtemp = true;
			}
			if(meshtemp)
			{
				mEffect[fx].mesh.push_back(1);
				mEffect[fx].mesh.back() = m;
			}
		}

		bool *meshtempOpaque	= new bool[mEffect[fx].mesh.size()];
		bool *meshtempBlended	= new bool[mEffect[fx].mesh.size()];
		bool opaqueFound		= false;
		bool blendedFound		= false;

		int nrOpaque		= 0;
		int nrBlended		= 0;

		for(size_t m=0;m<mEffect[fx].mesh.size();++m)		// loop through all, independent of meshes in this effect
		{
			if(opaqueFound) ++nrOpaque;
			if(blendedFound) ++nrBlended;

			opaqueFound			= false;
			blendedFound		= false;

			meshtempOpaque[m]	= false;
			meshtempBlended[m]	= false;

			for(size_t mi=0;mi<mEffect[fx].meshInst.size();++mi)
			{
				auto &inst = mEffect[fx].meshInst[mi];
				if(mMeshInst[inst].meshId == mEffect[fx].mesh[m])
				{
					if(pD3dscene.mMeshInst[inst].IsBlended() && !blendedFound)
					{
						meshtempBlended[m] = true; 
						blendedFound = true;
					}
					if(!pD3dscene.mMeshInst[inst].IsBlended() && !opaqueFound) 
					{
						meshtempOpaque[m] = true;
						opaqueFound = true;
					}
				}
			}
		}

		mEffect[fx].meshOpaque.resize(0);
		mEffect[fx].meshOpaque.reserve(nrOpaque);
		mEffect[fx].meshBlended.resize(0);
		mEffect[fx].meshBlended.reserve(nrBlended);

		for(size_t m=0;m<mEffect[fx].mesh.size();++m)
		{
			if(meshtempOpaque[m])
			{
				mEffect[fx].meshOpaque.push_back(1);
				mEffect[fx].meshOpaque.back() = mEffect[fx].mesh[m];
			}
			if(meshtempBlended[m])
			{
				mEffect[fx].meshBlended.push_back(1);
				mEffect[fx].meshBlended.back() = mEffect[fx].mesh[m];
			}
		}

		delete[] meshtempOpaque;
		delete[] meshtempBlended;
	}
	mEffectMeshDataCreated = true;
	return true;
}

/**************************************************************************************/
/***						CREATE EFFECT MATERIAL DATA								***/
/*** ==> usage: during scenegraph creation, for each effect							***/
/*** ==> fills the material relevant data for each effect, indices for rendering	***/
/**************************************************************************************/

bool CSceneGraph::CreateEffectMaterialData()
{
	if(!mEffectMeshDataCreated) return false;
	
	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		mEffect[fx].materials.resize(0);
		mEffect[fx].materials.reserve(mMaterials.size());

		bool matfound;

		// determine total number of materials per effect
		for(size_t mat=0;mat<mMaterials.size();++mat)
		{
			matfound = false;
			for(size_t m=0;m<mEffect[fx].mesh.size();++m)
			{
				for(size_t mi=0;mi<mMesh[mEffect[fx].mesh[m]].matIds.size();++mi)
				{
					if(mMesh[mEffect[fx].mesh[m]].matIds[mi] == mat) matfound = true;
				}
			}
			if(matfound)
			{
				mEffect[fx].materials.push_back(1);
				mEffect[fx].materials.back() = mat;
			}
		}

		// determine number of/ and ID's of opaque materials
		
		mEffect[fx].materialsOpaque.resize(0);
		mEffect[fx].materialsOpaque.reserve(mMaterials.size());

		for(size_t mat=0;mat<mMaterials.size();++mat)
		{
			matfound = false;
			for(size_t m=0;m<mEffect[fx].meshOpaque.size();++m)
			{
				for(size_t mi=0;mi<mMesh[mEffect[fx].meshOpaque[m]].matIds.size();++mi)
				{
					if(mMesh[mEffect[fx].meshOpaque[m]].matIds[mi] == mat) matfound = true;
				}
			}
			if(matfound)
			{
				mEffect[fx].materialsOpaque.push_back(1);
				mEffect[fx].materialsOpaque.back() = mat;
			}
		}

		// determine number of/ and ID's of blended materials
		mEffect[fx].materialsBlended.resize(0);
		mEffect[fx].materialsBlended.reserve(mMaterials.size());
		
		for(size_t mat=0;mat<mMaterials.size();++mat)
		{
			matfound = false;
			for(size_t m=0;m<mEffect[fx].meshBlended.size();++m)
			{
				for(size_t mi=0;mi<mMesh[mEffect[fx].meshBlended[m]].matIds.size();++mi)
				{
					if(mMesh[mEffect[fx].meshBlended[m]].matIds[mi] == mat) matfound = true;
				}
			}
			if(matfound)
			{
				mEffect[fx].materialsBlended.push_back(1);
				mEffect[fx].materialsBlended.back() = mat;
			}
		}
	}
	mEffectMatDataCreated = true;
	return true;
}

/**************************************************************************************/
/***						CREATE EFFECT MAT MESH INDEX							***/
/*** ==> usage: during scenegraph creation, for each effect							***/
/*** ==> creates indices per material, which meshes use the materials				***/
/**************************************************************************************/

bool CSceneGraph::CreateEffectMatMeshIndex()
{
	if(!mEffectMatDataCreated) return false;
	bool found;

	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		// meshes per material index + instances, opaque
		mEffect[fx].meshesPerMatOpaque.resize(mEffect[fx].materialsOpaque.size());

		for(size_t mat=0;mat<mEffect[fx].materialsOpaque.size();++mat)
		{
			mEffect[fx].meshesPerMatOpaque[mat].meshesVisibleInst.resize(mEffect[fx].meshOpaque.size());
			mEffect[fx].meshesPerMatOpaque[mat].meshes.resize(0);
			mEffect[fx].meshesPerMatOpaque[mat].meshes.reserve(mEffect[fx].meshOpaque.size());

			for(size_t m=0;m<mEffect[fx].meshOpaque.size();++m)
			{
				found = false;
				for(size_t mi=0;mi<mMesh[mEffect[fx].meshOpaque[m]].matIds.size();++mi)
				{
					if(mMesh[mEffect[fx].meshOpaque[m]].matIds[mi] == mEffect[fx].materialsOpaque[mat]) found = true;
				}
				if(found)
				{
					mEffect[fx].meshesPerMatOpaque[mat].meshes.push_back(1);
					mEffect[fx].meshesPerMatOpaque[mat].meshes.back() = mEffect[fx].meshOpaque[m];
				}
			}
		}

		mEffect[fx].meshesPerMatOpaque.resize(mEffect[fx].materialsOpaque.size());

		for(size_t mat=0;mat<mEffect[fx].materialsOpaque.size();++mat)
		{
			// mesh instances per opaque mesh per material
			mEffect[fx].meshesPerMatOpaque[mat].instance.resize(mEffect[fx].meshesPerMatOpaque[mat].meshes.size());

			for(size_t m=0;m<mEffect[fx].meshesPerMatOpaque[mat].meshes.size();++m)
			{
				mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances.resize(0);
				mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances.reserve(mMeshInst.size());

				for(size_t mi=0;mi<mEffect[fx].meshInst.size();++mi)
				{
					if(mMeshInst[mEffect[fx].meshInst[mi]].meshId == mEffect[fx].meshesPerMatOpaque[mat].meshes[m])
					{
						mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances.push_back(1);
						mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances.back() = mEffect[fx].meshInst[mi];
					}
				}
			}
		}
	}


	ofstream bla("a_fxmeshmat.txt");
	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		bla << "FX: " << fx << ", has " << mEffect[fx].meshesPerMatOpaque.size() << " opaque meshes" << endl << endl;
		for(size_t mat=0;mat<mEffect[fx].materialsOpaque.size();++mat)
		{
			bla << "Material: " << mat << ", has: " << mEffect[fx].meshesPerMatOpaque[mat].meshes.size() << " meshes" << endl;
			for(size_t mo=0;mo<mEffect[fx].meshesPerMatOpaque[mat].meshes.size();++mo)
			{
				bla << "Mesh: " << mEffect[fx].meshesPerMatOpaque[mat].meshes[mo] << ", with " << mEffect[fx].meshesPerMatOpaque[mat].instance[mo].instances.size() << " instances: ";
				for(size_t mi=0;mi<mEffect[fx].meshesPerMatOpaque[mat].instance[mo].instances.size();++mi) bla << mEffect[fx].meshesPerMatOpaque[mat].instance[mo].instances[mi] << " ";
				bla << endl;
			}
			bla << endl;
		}
	}
	bla.close();

	int jk = 8;

/*
		// meshes per material index + instances, blended
		mEffect[fx].meshesPerMatBlended.resize(mEffect[fx].materialsBlended.size());

		for(size_t mat=0;mat<mEffect[fx].materialsBlended.size();++mat)
		{
			mEffect[fx].meshesPerMatBlended[mat].meshesVisibleInst.resize(mEffect[fx].meshBlended.size());
			mEffect[fx].meshesPerMatBlended[mat].meshes.resize(0);
			mEffect[fx].meshesPerMatBlended[mat].meshes.reserve(mEffect[fx].meshBlended.size());

			for(size_t m=0;m<mEffect[fx].meshBlended.size();++m)
			{
				found = false;
				for(size_t mi=0;mi<mMesh[mEffect[fx].meshBlended[m]].matIds.size();++mi)
				{
					if(mMesh[mEffect[fx].meshBlended[m]].matIds[mi] == mEffect[fx].materialsBlended[mat]) found = true;
				}
				if(found)
				{
					mEffect[fx].meshesPerMatBlended[mat].meshes.push_back(1);
					mEffect[fx].meshesPerMatBlended[mat].meshes.back() = mEffect[fx].meshBlended[m];
				}
			}

			// mesh instances per blended meshinstance per material
			mEffect[fx].meshesPerMatBlended[mat].instance.resize(mEffect[fx].meshesPerMatBlended[mat].meshes.size());

			for(size_t m=0;m<mEffect[fx].meshesPerMatBlended[mat].meshes.size();++m)
			{
				mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.resize(0);
				mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.reserve(mMeshInst.size());

				for(size_t mi=0;mi<mEffect[fx].meshInst.size();++mi)
				{
					if(mMeshInst[mEffect[fx].meshInst[mi]].meshId == mEffect[fx].meshesPerMatBlended[mat].meshes[m])
					{
						mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.push_back(1);
						mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.back() = mEffect[fx].meshInst[mi];
					}
				}
			}

			// indices for sorting blended meshes back to front
			for(size_t m=0;m<mEffect[fx].meshesPerMatBlended[mat].meshes.size();++m) 
			{
				auto &mesh = mEffect[fx].meshesPerMatBlended[mat].instance[m];
				mesh.blendedMeshIndexTemp.resize(mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.size());
				mesh.blendedMeshOrderTemp.resize(mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.size());
				mesh.blendedMeshDistToCam.resize(mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.size());

				for(size_t mi=0;mi<mesh.instances.size();++mi) mesh.blendedMeshOrderTemp[mi] = mi;	// for sorting back to front
			}		
		}
	}*/
	return true;
}

/**************************************************************************************/
/***								GET NR MESHES							  CONST	***/
/*** ==> usage: when requesting number of meshes in scenegraph						***/
/*** ==> returns number of meshes													***/
/**************************************************************************************/

size_t CSceneGraph::GetNrMeshes() const
{
	return mMesh.size();
}

/**************************************************************************************/
/***								GET NR MESH INST						  CONST	***/
/*** ==> usage: when requesting number of mesh instances in scenegraph				***/
/*** ==> returns number of mesh instances											***/
/**************************************************************************************/

size_t CSceneGraph::GetNrMeshInst() const
{
	return mMeshInst.size();
}

/**************************************************************************************/
/***								GET NR MESH INST DYNAMIC				  CONST	***/
/*** ==> usage: when requesting number of dynamic mesh instances in scenegraph		***/
/*** ==> returns number of mesh instances											***/
/**************************************************************************************/
	
size_t CSceneGraph::GetNrMeshInstDynamic() const
{
	return mDynamicMeshInstIndex.size();
}

/**************************************************************************************/
/***								GET NR MATERIALS						  CONST	***/
/*** ==> usage: when requesting number of materials in scenegraph					***/
/*** ==> returns number of materials												***/
/**************************************************************************************/

size_t CSceneGraph::GetNrMaterials() const
{
	return mMaterials.size();
}

/**************************************************************************************/
/***								GET NR EFFECTS							  CONST	***/
/*** ==> usage: when requesting number of effects in scenegraph						***/
/*** ==> returns number of effects													***/
/**************************************************************************************/

size_t CSceneGraph::GetNrEffects() const
{
	return mEffect.size();
}

/**************************************************************************************/
/***								GET NR LIGHTS							  CONST	***/
/*** ==> usage: when requesting total number of lights in scenegraph				***/
/*** ==> returns total number of lights 											***/
/**************************************************************************************/

size_t CSceneGraph::GetNrLights() const
{
	return mLights.size();
}

/**************************************************************************************/
/***								GET NR DIR LIGHTS						  CONST	***/
/*** ==> usage: when requesting number of directional lights in scenegraph			***/
/*** ==> returns number of directional lights 										***/
/**************************************************************************************/

size_t CSceneGraph::GetNrDirLights() const
{
	return mDirLights.size();
}

/**************************************************************************************/
/***								GET NR POINT LIGHTS						  CONST	***/
/*** ==> usage: when requesting number of point lights in scenegraph				***/
/*** ==> returns number of point lights	 											***/
/**************************************************************************************/

size_t CSceneGraph::GetNrPointLights() const
{
	return mPointLights.size();
}

/**************************************************************************************/
/***								GET MAX DIR LIGHTS						  CONST	***/
/*** ==> usage: when requesting number of maximum directional lights in scenegraph	***/
/*** ==> returns maximum number of directional lights 								***/
/**************************************************************************************/

size_t CSceneGraph::GetMaxDirLights() const
{
	return mMaxDirLights;
}

/**************************************************************************************/
/***								GET MAX POINT LIGHTS					  CONST	***/
/*** ==> usage: when requesting number of maximum point lights in scenegraph		***/
/*** ==> returns maximum number of point lights 									***/
/**************************************************************************************/

size_t CSceneGraph::GetMaxPointLights() const
{
	return mMaxPointLights;
}
	
/**************************************************************************************/
/***							GET NR VISIBLE DIR LIGHTS					  CONST	***/
/*** ==> usage: when requesting number of visible directional lights in scenegraph	***/
/*** ==> returns number of visible directional lights 								***/
/**************************************************************************************/
	
size_t CSceneGraph::GetNrVisibleDirLights() const
{
	return mVisibleDirLights.size();
}

/**************************************************************************************/
/***							GET NR VISIBLE POINT LIGHTS					  CONST	***/
/*** ==> usage: when requesting number of visible point lights in scenegraph		***/
/*** ==> returns number of visible point lights 									***/
/**************************************************************************************/

size_t CSceneGraph::GetNrVisiblePointLights() const
{
	return mVisiblePointLights.size();
}

/**************************************************************************************/
/***								UPDATE MESH VISIBLE INST				  CONST	***/
/*** ==> usage: during scenegraph update, has a mesh visible instances?				***/
/*** ==> updates the bool vectors if meshes have visible instances 					***/
/**************************************************************************************/

bool CSceneGraph::UpdateMeshVisibleInst(const Crealysm_d3drenderer::CD3dscene &pD3dscene)
{
	std::ofstream bla("avisinst.txt");
	bla << "Total instances: " << mMeshInst.size() << endl;

	int visible = 0;
	for(size_t mi=0;mi<mMeshInst.size();++mi)
	{
		if(pD3dscene.mMeshInst[mi].IsVisible())
		{
			++visible;
			bla << "Nr.:" << mi << endl;
		}
	}
	bla << endl;
	bla << "Total visible: " << visible << endl;
//	bla.close();

	bla << endl << "Found visible ones: " << endl;
	bool found;
	for(size_t fx=0;fx<mEffect.size();++fx)
	{
		// opaque meshes: are there visible instances?
		for(size_t mat=0;mat<mEffect[fx].materialsOpaque.size();++mat)
		{
			for(size_t m=0;m<mEffect[fx].meshesPerMatOpaque[mat].meshes.size();++m)
			{
				mEffect[fx].meshesPerMatOpaque[mat].meshesVisibleInst[m] = false;

				found = false;
				for(size_t mi=0;mi<mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances.size();++mi)
				{
					if(pD3dscene.mMeshInst[mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances[mi]].IsVisible())
					{
						mEffect[fx].meshesPerMatOpaque[mat].meshesVisibleInst[m] = true;
						bla << "Mat: " << mat << ", mesh: " << m << ", instance: " << mEffect[fx].meshesPerMatOpaque[mat].instance[m].instances[mi] << endl;
						found = true;
					}
					if(found) break;
				}
			}
		}

		bla << endl;
		bla << "MeshesPerMatOpaque[mat].meshesVisibleInst[m]" << endl;
		for(size_t mat=0;mat<mEffect[fx].materialsOpaque.size();++mat)
		{
			for(size_t m=0;m<mEffect[fx].meshesPerMatOpaque[mat].meshes.size();++m)
			{
				bla << "Opaque mat: " << mat << ", " << "mesh: " << m << " has visible instances: " << mEffect[fx].meshesPerMatOpaque[mat].meshesVisibleInst[m] << endl;
			}
		}
		bla.close();

		// blended meshes: are there visible instances?
		for(size_t mat=0;mat<mEffect[fx].materialsBlended.size();++mat)
		{
			for(size_t m=0;m<mEffect[fx].meshesPerMatBlended[mat].meshes.size();++m)
			{
				mEffect[fx].meshesPerMatBlended[mat].meshesVisibleInst[m] = false;

				found = false;
				for(size_t mi=0;mi<mEffect[fx].meshesPerMatBlended[mat].instance[m].instances.size();++mi)
				{
					if(pD3dscene.mMeshInst[mEffect[fx].meshesPerMatBlended[mat].instance[m].instances[mi]].IsVisible())
					{
						mEffect[fx].meshesPerMatBlended[mat].meshesVisibleInst[m] = true;
						found = true;
					}
				}
				if(found) break;
			}
		}
	}
	return true;
}

}