Example #1
0
void initShadows()
{
    GlbVar.ogreSmgr->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED);

    //3 textures per directional light.
    GlbVar.ogreSmgr->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, 3);
    GlbVar.ogreSmgr->setShadowTextureCount(3);
    GlbVar.ogreSmgr->setShadowTextureConfig(0, 2048, 2048, Ogre::PF_FLOAT32_R);
    GlbVar.ogreSmgr->setShadowTextureConfig(1, 2048, 2048, Ogre::PF_FLOAT32_R);
    GlbVar.ogreSmgr->setShadowTextureConfig(2, 1024, 1024, Ogre::PF_FLOAT32_R);
    GlbVar.ogreSmgr->setShadowTextureSelfShadow(true);
    GlbVar.ogreSmgr->setShadowCasterRenderBackFaces(true);

    //Caster material.
    GlbVar.ogreSmgr->setShadowTextureCasterMaterial("BaseShadowCaster");

    //Shadow camera setup.
    Ogre::PSSMShadowCameraSetup::SplitPointList splits;
    splits.push_back(0.1f);
    splits.push_back(18.7167f);
    splits.push_back(77.4301f);
    splits.push_back(1000.0f);

    Ogre::PSSMShadowCameraSetup* pssmSetup = new Ogre::PSSMShadowCameraSetup();
    pssmSetup->setSplitPoints(splits);
    pssmSetup->setSplitPadding(10);
    pssmSetup->setOptimalAdjustFactor(0, 5);
    pssmSetup->setOptimalAdjustFactor(1, 3);
    pssmSetup->setOptimalAdjustFactor(2, 0.1);
    GlbVar.ogreSmgr->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(pssmSetup));
}
void ShadowManager::updatePSSM(Ogre::Terrain* terrain)
{
	if (!mPSSMSetup.get())  return;

	Ogre::TerrainMaterialGeneratorA::SM2Profile *matProfile  = 0;
	if (Ogre::TerrainGlobalOptions::getSingletonPtr())
	{
		matProfile = static_cast<Ogre::TerrainMaterialGeneratorA::SM2Profile*>(Ogre::TerrainGlobalOptions::getSingleton().getDefaultMaterialGenerator()->getActiveProfile());
		matProfile->setReceiveDynamicShadowsEnabled(true);
		matProfile->setReceiveDynamicShadowsLowLod(true);
		matProfile->setGlobalColourMapEnabled(false);
	}


	Ogre::PSSMShadowCameraSetup* pssmSetup = static_cast<Ogre::PSSMShadowCameraSetup*>(mPSSMSetup.get());
	const Ogre::PSSMShadowCameraSetup::SplitPointList& splitPointList = pssmSetup->getSplitPoints();

	Ogre::Vector4 splitPoints;
	for (size_t i = 0; i < /*3*/splitPointList.size(); ++i)
		splitPoints[i] = splitPointList[i];

	// TODO: fix this
	//setMaterialSplitPoints("road", splitPoints);
	//setMaterialSplitPoints("road2", splitPoints);


	if (matProfile && terrain)
	{
		matProfile->generateForCompositeMap(terrain);
		matProfile->setReceiveDynamicShadowsDepth(mDepthShadows);
		matProfile->setReceiveDynamicShadowsPSSM(static_cast<Ogre::PSSMShadowCameraSetup*>(mPSSMSetup.get()));
	}
}
void ShadowManager::updatePSSM(Ogre::Terrain* terrain)
{
	if (!PSSM_Shadows.mPSSMSetup.get())  return;

	Ogre::TerrainMaterialGeneratorA::SM2Profile *matProfile = 0;
	if (Ogre::TerrainGlobalOptions::getSingletonPtr())
	{
		matProfile = static_cast<Ogre::TerrainMaterialGeneratorA::SM2Profile*>(Ogre::TerrainGlobalOptions::getSingleton().getDefaultMaterialGenerator()->getActiveProfile());
		matProfile->setReceiveDynamicShadowsEnabled(true);
		matProfile->setReceiveDynamicShadowsLowLod(true);
		matProfile->setGlobalColourMapEnabled(true);
	}


	Ogre::PSSMShadowCameraSetup* pssmSetup = static_cast<Ogre::PSSMShadowCameraSetup*>(PSSM_Shadows.mPSSMSetup.get());
	Ogre::PSSMShadowCameraSetup::SplitPointList splitPointList = pssmSetup->getSplitPoints();

	
	splitPointList[0] = 1.0;
	splitPointList[1] = 95.0;
	splitPointList[2] = 255.0;
	splitPointList[3] = 512.0;
	pssmSetup->setSplitPoints(splitPointList);
	
	
	Ogre::Vector4 splitPoints;
	for (int i = 0; i < PSSM_Shadows.ShadowsTextureNum; ++i)
		splitPoints[i] = splitPointList[i];

	MaterialPtr mat = MaterialManager::getSingleton().getByName("RoR/Managed_Mats/Base");
	mat->getTechnique("ShadowTechnique")->getPass(0)->getFragmentProgramParameters()->setNamedConstant("pssmSplitPoints", splitPoints);

	// TODO: fix this
/*	setMaterialSplitPoints("road", splitPoints);
	setMaterialSplitPoints("road2", splitPoints);
	*/

	if (matProfile && terrain)
	{
		matProfile->generateForCompositeMap(terrain);
		matProfile->setReceiveDynamicShadowsDepth(PSSM_Shadows.mDepthShadows);
		matProfile->setReceiveDynamicShadowsPSSM(static_cast<Ogre::PSSMShadowCameraSetup*>(PSSM_Shadows.mPSSMSetup.get()));
	}
}
//-------------------------------------------------------------------------------
void CSceneManagerEditor::setupPSSM()
{
    if(mShadowsTechnique->get() >= (int)Ogre::SHADOWTYPE_TEXTURE_ADDITIVE && mShadowsTechnique->get() <= (int)Ogre::SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED)
    {
        Ogre::Camera *mCamera = mOgitorsRoot->GetViewport()->getCameraEditor()->getCamera();
        mPSSMSetup.setNull();

        // shadow camera setup
        Ogre::PSSMShadowCameraSetup* pssmSetup = OGRE_NEW Ogre::PSSMShadowCameraSetup();
        pssmSetup->setSplitPadding(mCamera->getNearClipDistance());
        pssmSetup->calculateSplitPoints(3, mCamera->getNearClipDistance(), mHandle->getShadowFarDistance());
        pssmSetup->setOptimalAdjustFactor(0, 2);
        pssmSetup->setOptimalAdjustFactor(1, 1);
        pssmSetup->setOptimalAdjustFactor(2, 0.5);

        mPSSMSetup.bind(pssmSetup);

        mHandle->setShadowCameraSetup(mPSSMSetup);
    }
}
void ShadowManager::processPSSM()
{
	gEnv->sceneManager->setShadowFarDistance(2000);
	gEnv->sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);

	gEnv->sceneManager->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, PSSM_Shadows.ShadowsTextureNum);

	if (PSSM_Shadows.mPSSMSetup.isNull())
	{
		// shadow camera setup
		Ogre::PSSMShadowCameraSetup* pssmSetup = new Ogre::PSSMShadowCameraSetup();
		//pssmSetup->setCameraLightDirectionThreshold(Ogre::Degree(15.0));
		//pssmSetup->setUseAggressiveFocusRegion(true);
		//pssmSetup->setUseSimpleOptimalAdjust(false);

		/*pssmSetup->calculateSplitPoints(3, 0.5, 600, 0.91f);
		*/
		pssmSetup->setSplitPadding(5);
		pssmSetup->setOptimalAdjustFactor(0, 2);
		pssmSetup->setOptimalAdjustFactor(1, 1);
		pssmSetup->setOptimalAdjustFactor(2, 0.5);

		PSSM_Shadows.mPSSMSetup.bind(pssmSetup);

	}
	gEnv->sceneManager->setShadowCameraSetup(PSSM_Shadows.mPSSMSetup);


	gEnv->sceneManager->setShadowTextureCount(PSSM_Shadows.ShadowsTextureNum);

	gEnv->sceneManager->setShadowTextureConfig(0, 2048, 2048, PF_FLOAT16_RGB);
	gEnv->sceneManager->setShadowTextureConfig(1, 1024, 1024, PF_FLOAT16_RGB);
	gEnv->sceneManager->setShadowTextureConfig(2, 512,  512,  PF_FLOAT16_RGB);

	gEnv->sceneManager->setShadowTextureSelfShadow(true);
	gEnv->sceneManager->setShadowCasterRenderBackFaces(true);

	gEnv->sceneManager->setShadowTextureCasterMaterial(PSSM_Shadows.mDepthShadows ? "PSSM/shadow_caster" : Ogre::StringUtil::BLANK);

	updatePSSM();
}
void ShadowManager::processPSSM()
{
	// 3 textures per directional light (PSSM)
	int num = 3;

	gEnv->sceneManager->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, num);	

	if (mPSSMSetup.isNull())
	{
		// shadow camera setup
		Ogre::PSSMShadowCameraSetup* pssmSetup = new Ogre::PSSMShadowCameraSetup();
		pssmSetup->setSplitPadding(gEnv->mainCamera->getNearClipDistance());
		pssmSetup->calculateSplitPoints(3, gEnv->mainCamera->getNearClipDistance(), gEnv->sceneManager->getShadowFarDistance());
		for (int i = 0; i < num; ++i)
		{	//int size = i==0 ? 2048 : 1024;
			const Ogre::Real cAdjfA[5] = { 2, 1, 0.5, 0.25, 0.125 };
			pssmSetup->setOptimalAdjustFactor(i, cAdjfA[std::min(i, 4)]);
		}
		mPSSMSetup.bind(pssmSetup);

	}
	gEnv->sceneManager->setShadowCameraSetup(mPSSMSetup);


	gEnv->sceneManager->setShadowTextureCount(num);

	for (int i = 0; i < num; ++i)
	{
		int size = i == 0 ? 2048 : 1024;
		gEnv->sceneManager->setShadowTextureConfig(i, size, size, mDepthShadows ? Ogre::PF_FLOAT32_R : Ogre::PF_X8B8G8R8);
	}

	gEnv->sceneManager->setShadowTextureSelfShadow(true);
	gEnv->sceneManager->setShadowCasterRenderBackFaces(false);

	gEnv->sceneManager->setShadowTextureCasterMaterial(mDepthShadows ? "PSSM/shadow_caster" : Ogre::StringUtil::BLANK);

	updatePSSM();
}
Example #7
0
void ShadowManager::processPSSM()
{
    gEnv->sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);

    gEnv->sceneManager->setShadowDirectionalLightExtrusionDistance(299.0f);
    gEnv->sceneManager->setShadowFarDistance(350.0f);
    gEnv->sceneManager->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, PSSM_Shadows.ShadowsTextureNum);
    gEnv->sceneManager->setShadowTextureCount(PSSM_Shadows.ShadowsTextureNum);

    gEnv->sceneManager->setShadowTextureSelfShadow(true);
    gEnv->sceneManager->setShadowCasterRenderBackFaces(true);

    //Caster is set via materials
    gEnv->sceneManager->setShadowTextureCasterMaterial("Ogre/shadow/depth/caster");

    if (PSSM_Shadows.Quality == 3)
    {
        gEnv->sceneManager->setShadowTextureConfig(0, 4096, 4096, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(1, 3072, 3072, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(2, 2048, 2048, PF_FLOAT32_R);
        PSSM_Shadows.lambda = 0.965f;
    }
    else if (PSSM_Shadows.Quality == 2)
    {
        gEnv->sceneManager->setShadowTextureConfig(0, 3072, 3072, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(1, 2048, 2048, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(2, 2048, 2048, PF_FLOAT32_R);
        PSSM_Shadows.lambda = 0.97f;
    }
    else if (PSSM_Shadows.Quality == 1)
    {
        gEnv->sceneManager->setShadowTextureConfig(0, 2048, 2048, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(1, 1024, 1024, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(2, 1024, 1024, PF_FLOAT32_R);
        PSSM_Shadows.lambda = 0.975f;
    }
    else
    {
        gEnv->sceneManager->setShadowTextureConfig(0, 1024, 1024, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(1, 1024, 1024, PF_FLOAT32_R);
        gEnv->sceneManager->setShadowTextureConfig(2, 512, 512, PF_FLOAT32_R);
        PSSM_Shadows.lambda = 0.98f;
    }

    if (PSSM_Shadows.mPSSMSetup.isNull())
    {
        // shadow camera setup
        Ogre::PSSMShadowCameraSetup* pssmSetup = new Ogre::PSSMShadowCameraSetup();

        pssmSetup->calculateSplitPoints(3, gEnv->mainCamera->getNearClipDistance(), gEnv->sceneManager->getShadowFarDistance(), PSSM_Shadows.lambda);
        pssmSetup->setSplitPadding(gEnv->mainCamera->getNearClipDistance());

        pssmSetup->setOptimalAdjustFactor(0, -1);
        pssmSetup->setOptimalAdjustFactor(1, -1);
        pssmSetup->setOptimalAdjustFactor(2, -1);

        PSSM_Shadows.mPSSMSetup.bind(pssmSetup);

        //Send split info to managed materials
        setManagedMaterialSplitPoints(pssmSetup->getSplitPoints());
    }
    gEnv->sceneManager->setShadowCameraSetup(PSSM_Shadows.mPSSMSetup);
}
	void Main::initScene()
	{
		Ogre::LogManager::getSingleton().logMessage("Main initScene");

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::UPDATE_PER_FRAME);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::RENDERING_BEGIN);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::PHYSICS_BEGIN);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::PHYSICS_SUBSTEP);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::PHYSICS_END);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::UPDATE_INDEPENDANT);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::KEY_DOWN);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::KEY_UP);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::MOUSE_DOWN);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::MOUSE_UP);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::MOUSE_MOVE);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::GAMESTATE_ENTER);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::GAMESTATE_LEAVE);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::CONSOLE_INGAME);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::LOADLEVEL_BEGIN);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::LOADLEVEL_END);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::SAVELEVEL_BEGIN);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::SAVELEVEL_END);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::ACTOR_ONSLEEP);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::ACTOR_ONWAKE);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::MATERIAL_ONCONTACT);

		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::REPARSE_SCRIPTS_PRE);
		Ice::MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::REPARSE_SCRIPTS_POST);

		MessageSystem::Instance().CreateNewsgroup(GlobalMessageIDs::ENABLE_GAME_CLOCK);

		Ogre::LogManager::getSingleton().logMessage("Starting PhysX");

		//Start up OgrePhysX
		OgrePhysX::World::getSingleton().init();

		mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "Esgaroth");
		mCamera = mSceneMgr->createCamera("MainCamera");
		mCamera->lookAt(Ogre::Vector3(0,0,1));
		mCamera->setNearClipDistance(0.4f);
		mCamera->setFarClipDistance(50000);

		mViewport = mWindow->addViewport(mCamera);
		mViewport->setBackgroundColour(Ogre::ColourValue::Black);
		mCamera->setAspectRatio(Ogre::Real(mViewport->getActualWidth()) / Ogre::Real(mViewport->getActualHeight()));

		//Create PhysX Scene
		PxSceneDesc sceneDesc(OgrePhysX::getPxPhysics()->getTolerancesScale());
		sceneDesc.gravity = PxVec3(0, -9.81f, 0);
		sceneDesc.filterShader = &PhysXSimulationFilterShader;
		mPhysXSimulationCallback = ICE_NEW PhysXSimulationEventCallback();
		sceneDesc.simulationEventCallback = mPhysXSimulationCallback;
		mPhysXScene = OgrePhysX::World::getSingleton().addScene("Main", mSceneMgr, sceneDesc);

		mPreviewSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "Esgaroth_Preview");

		InitOgreResources();

		Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
		Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_ANISOTROPIC);
		Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(8); 

		Ogre::MaterialManager::getSingleton().addListener(new DepthSchemeHandler(), "depth");

		//mPreviewSceneMgr->setSkyBox(true, "Sky/ClubTropicana", 2000);
		mPreviewSceneMgr->setAmbientLight(Ogre::ColourValue(0.8f, 0.8f, 0.8f));
		Ogre::Light *ambientlight = mPreviewSceneMgr->createLight("SkyLight");
		ambientlight->setType(Ogre::Light::LightTypes::LT_DIRECTIONAL);
		ambientlight->setDirection(Ogre::Vector3(0,-1,0.4f).normalisedCopy());
		ambientlight->setDiffuseColour(Ogre::ColourValue(1,1,1));
		ambientlight->setSpecularColour(Ogre::ColourValue(1,1,1));

		mSceneMgr->setAmbientLight(Ogre::ColourValue(0.3f,0.2f,0.2f));
		//mSceneMgr->setFog(Ogre::FOG_LINEAR, Ogre::ColourValue::Blue, 0.015);

		mCameraController = ICE_NEW FreeFlightCameraController();
		SceneManager::Instance().AcquireCamera(mCameraController);

		//init scripting stuff
		ScriptSystem::GetInstance();
		LuaScript::SetLoader(OgreFileLoader);
		LuaScript::SetLogFn(ScriptLogFn);
		/*	GUISystem::GetInstance();
		MusicSystem::GetInstance();
		ScriptedControls::GetInstance();*/

		//sound
		mSoundManager = OgreOggSound::OgreOggSoundManager::getSingletonPtr();
		mSoundManager->init("");
		mSoundManager->setSceneManager(mSceneMgr);
		mSoundManager->setDistanceModel(AL_LINEAR_DISTANCE);
		//mCamera->getParentSceneNode()->attachObject(mSoundManager->getListener());

		InitCompositor();

		Ogre::MovableObject::setDefaultVisibilityFlags( Ice::VisibilityFlags::V_DEFAULT);

		/*mCollisionCallback = ICE_NEW ScriptedCollisionCallback();
		NxOgre::ActorGroup *dynamicbodies = mScene->createActorGroup("DynamicBody");
		mScene->addMaterialPair(
		dynamicbodies->((NxOgre::GroupCallback::InheritedCallback*)(mCollisionCallback));
		dynamicbodies->setCollisionCallback(dynamicbodies, NX_NOTIFY_ALL, false);*/

		mSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);

		mSceneMgr->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, 3);
		mSceneMgr->setShadowTextureCountPerLightType(Ogre::Light::LT_SPOTLIGHT, 1);
		mSceneMgr->setShadowTextureCount(3);
		mSceneMgr->setShadowTextureConfig(0, 2048, 2048, Ogre::PF_FLOAT32_R);
		mSceneMgr->setShadowTextureConfig(1, 2048, 2048, Ogre::PF_FLOAT32_R);
		mSceneMgr->setShadowTextureConfig(2, 2048, 2048, Ogre::PF_FLOAT32_R);
		/*mSceneMgr->setShadowTextureConfig(3, 1024, 1024, Ogre::PF_FLOAT32_R);
		mSceneMgr->setShadowTextureConfig(4, 1024, 1024, Ogre::PF_FLOAT32_R);
		mSceneMgr->setShadowTextureConfig(5, 1024, 1024, Ogre::PF_FLOAT32_R);
		mSceneMgr->setShadowTextureConfig(6, 1024, 1024, Ogre::PF_FLOAT32_R);
		mSceneMgr->setShadowTextureConfig(7, 1024, 1024, Ogre::PF_FLOAT32_R);*/
		/*mSceneMgr->setShadowTextureSelfShadow(true);*/
		mSceneMgr->setShadowTextureCasterMaterial("shadow_caster");

		mSceneMgr->getShadowTexture(0)->getBuffer()->getRenderTarget()->getViewport(0)->setBackgroundColour(Ogre::ColourValue::White);
		mSceneMgr->getShadowTexture(0)->getBuffer()->getRenderTarget()->getViewport(0)->setClearEveryFrame(true);
		mSceneMgr->getShadowTexture(1)->getBuffer()->getRenderTarget()->getViewport(0)->setBackgroundColour(Ogre::ColourValue::White);
		mSceneMgr->getShadowTexture(1)->getBuffer()->getRenderTarget()->getViewport(0)->setClearEveryFrame(true);
		mSceneMgr->getShadowTexture(2)->getBuffer()->getRenderTarget()->getViewport(0)->setBackgroundColour(Ogre::ColourValue::White);
		mSceneMgr->getShadowTexture(2)->getBuffer()->getRenderTarget()->getViewport(0)->setClearEveryFrame(true);

		mSceneMgr->setShadowCasterRenderBackFaces(false);

		// shadow camera setup
		Ogre::FocusedShadowCameraSetup* spotSetup = ICE_NEW Ogre::FocusedShadowCameraSetup();
		mSpotShadowCameraSetup = Ogre::ShadowCameraSetupPtr(spotSetup);

		Ogre::PSSMShadowCameraSetup* pssmSetup = ICE_NEW Ogre::PSSMShadowCameraSetup();
		pssmSetup->calculateSplitPoints(3, 0.4f, 300, 0.95f);
		pssmSetup->setSplitPadding(1);
		pssmSetup->setOptimalAdjustFactor(0, 2);
		pssmSetup->setOptimalAdjustFactor(1, 0.6f);
		pssmSetup->setOptimalAdjustFactor(2, 0.3f);//0.4f);//2, 0.5);
		mDirectionalShadowCameraSetup = Ogre::ShadowCameraSetupPtr(pssmSetup);
		mSceneMgr->setShadowCameraSetup(mDirectionalShadowCameraSetup);
		const Ogre::PSSMShadowCameraSetup::SplitPointList& splitPointList = pssmSetup->getSplitPoints();
		Ogre::Vector4 PSSMSplitPoints;
		for (int i = 0; i < 3; ++i)
		{
			PSSMSplitPoints[i] = splitPointList[i];
		}

		IceNote("PSSMSplitPoints: " + Ogre::StringConverter::toString(PSSMSplitPoints));

		SceneManager::Instance().Init();

		//Load save initialisation
		RegisterStandardAtoms();
		LoadSave::LoadSave::Instance().SetLogFunction(LogMessage);

		LoadSave::LoadSave::Instance().RegisterObject(&DataMap::Register);
		LoadSave::LoadSave::Instance().RegisterObject(&DataMap::Item::Register);
		LoadSave::LoadSave::Instance().RegisterObject(&GenericProperty::Register);
		LoadSave::LoadSave::Instance().RegisterObject(&GameObject::Register);
		LoadSave::LoadSave::Instance().RegisterObject(&ObjectReference::Register);
		LoadSave::LoadSave::Instance().RegisterObject(&LoadSave::SaveableDummy::Register);

		LoadSave::LoadSave::Instance().RegisterObject(&NavigationMesh::Register);

		LoadSave::LoadSave::Instance().RegisterAtom((LoadSave::AtomHandler*)new SaveableVectorHandler<GameObject>("vector<GameObjectPtr>"));
		LoadSave::LoadSave::Instance().RegisterAtom((LoadSave::AtomHandler*)new SaveableVectorHandler<ObjectReference>("vector<ObjectReferencePtr>"));
		LoadSave::LoadSave::Instance().RegisterAtom((LoadSave::AtomHandler*)new SaveableVectorHandler<GOComponent>("vector<GOComponentPtr>"));
		LoadSave::LoadSave::Instance().RegisterAtom((LoadSave::AtomHandler*)new SaveableVectorHandler<NavigationMesh::PathNodeTree>("vector<PathNodeTreePtr>"));
		LoadSave::LoadSave::Instance().RegisterAtom((LoadSave::AtomHandler*)new SaveableVectorHandler<DataMap::Item>("vector<DataMapItemPtr>"));

		//Init script functions
		InitCoreLuaFunctions();

		//Load Plugins
		LoadPlugins();
		//initialize scripts
		ScriptSystem::GetInstance().CreateInstance("StartEngine.lua");
		ScriptSystem::GetInstance().CreateInstance("InitEngine.lua");

		MaterialTable::Instance().InitBindingsFromCfg("OgreMaterialSoundBindings.cfg");

		SceneManager::Instance().PostInit();

		/*Ogre::TexturePtr t_depth = Ogre::TextureManager::getSingleton().createManual("rt_SceneDepth",
		Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_FLOAT16_RGB, Ogre::TU_RENDERTARGET);
		Ogre::RenderTarget* depth_rtt = t_depth->getBuffer()->getRenderTarget();
		depth_rtt->addViewport(mCamera)->setOverlaysEnabled(false);
		depth_rtt->getViewport(0)->setShadowsEnabled(false);
		depth_rtt->getViewport(0)->setAutoUpdated(true);
		depth_rtt->getViewport(0)->setBackgroundColour(Ogre::ColourValue::Black);
		depth_rtt->getViewport(0)->setClearEveryFrame(true);
		depth_rtt->getViewport(0)->setVisibilityMask(4294967281);
		depth_rtt->getViewport(0)->setMaterialScheme("depth");

		Ogre::TexturePtr t_volumetrics = Ogre::TextureManager::getSingleton().createManual("rt_VolumetricObjects",
		Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_FLOAT16_RGB, Ogre::TU_RENDERTARGET);
		Ogre::RenderTarget* volumetrics_rtt = t_volumetrics->getBuffer()->getRenderTarget();
		volumetrics_rtt->addViewport(mCamera)->setOverlaysEnabled(false);
		volumetrics_rtt->getViewport(0)->setAutoUpdated(true);
		volumetrics_rtt->getViewport(0)->setShadowsEnabled(false);
		volumetrics_rtt->getViewport(0)->setClearEveryFrame(true);
		volumetrics_rtt->getViewport(0)->setVisibilityMask(2);
		volumetrics_rtt->getViewport(0)->setMaterialScheme("Volumetrics");*/


	};