#include <irrlicht.h>
#include <iostream>
using namespace irr;

#ifdef _MSC_VER
#pragma comment(lib, "Irrlicht.lib")
#endif


////
IrrlichtDevice* device = 0;
bool UseHighLevelShaders = true;

class MyShaderCallBack : public video::IShaderConstantSetCallBack
{
public:
        virtual void OnSetConstants(video::IMaterialRendererServices* services,
                        s32 userData)
        {
                video::IVideoDriver* driver = services->getVideoDriver();
                // set clip matrix
                core::matrix4 worldViewProj;
				core::matrix4 world;
                worldViewProj = driver->getTransform(video::ETS_PROJECTION);
                worldViewProj *= driver->getTransform(video::ETS_VIEW);
                worldViewProj *= driver->getTransform(video::ETS_WORLD);
				world          = driver->getTransform(video::ETS_WORLD);
				if (UseHighLevelShaders){
                        services->setVertexShaderConstant("matViewProjection", worldViewProj.pointer(), 16);
						services->setVertexShaderConstant("World", world.pointer(), 16);
				}
                else
                        services->setVertexShaderConstant(worldViewProj.pointer(), 4, 4);

				//send camPos
				core::vector3df pos = device->getSceneManager()->getActiveCamera()->getAbsolutePosition();

				if (UseHighLevelShaders)
					services->setPixelShaderConstant("camPos", reinterpret_cast<f32*>(&pos), 3);
				else
					services->setPixelShaderConstant(reinterpret_cast<f32*>(&pos), 8, 1);
		}
};


int main()
{
	irr::SIrrlichtCreationParameters params;
	params.DriverType=video::EDT_DIRECT3D9;
	params.WindowSize=core::dimension2d<u32>(1360, 768);
	device = createDeviceEx(params);

	if (device == 0)
		return 1; // could not create selected driver.



	video::IVideoDriver* driver = device->getVideoDriver();
	scene::ISceneManager* smgr = device->getSceneManager();
	gui::IGUIEnvironment* env = device->getGUIEnvironment();

	//driver->setFog(video::SColor(255,60,60,60));
	driver->setFog(video::SColor(255,60,250,60), video::EFT_FOG_LINEAR, 10, 20, 0.01f, false,false);

	// add camera
	scene::ICameraSceneNode* camera =
		smgr->addCameraSceneNodeFPS(0,100.0f,3.2f);

	camera->setPosition(core::vector3df(2700,4000,2600));
	camera->setTarget(core::vector3df(2397*2,343*2,2700*2));
	camera->setFarValue(42000.0f);

	scene::ISceneNode* test = smgr->addCubeSceneNode(600,0,0,irr::core::vector3df(0,2000,0));
	test->setMaterialFlag(video::EMF_LIGHTING, false);
	test->setMaterialTexture(0, driver->getTexture("sandstone.jpg"));

	// disable mouse cursor
	device->getCursorControl()->setVisible(false);

	// add terrain scene node
	scene::ITerrainSceneNode* terrain = smgr->addTerrainSceneNode(
		"heightmap.jpg",
		0,					// parent node
		-1,					// node id
		core::vector3df(0.f, 0.f, 0.f),		// position
		core::vector3df(0.f, 0.f, 0.f),		// rotation
		core::vector3df(50, 5, 50),	// scale
		video::SColor ( 255, 255, 255, 255 ),	// vertexColor
		5,					// maxLOD
		scene::ETPS_17,				// patchSize
		4					// smoothFactor
		);
	terrain->scaleTexture(1.0f, 20.0f);


	// create triangle selector for the terrain
	scene::ITriangleSelector* selector
		= smgr->createTerrainTriangleSelector(terrain, 0);
	terrain->setTriangleSelector(selector);

	// create collision response animator and attach it to the camera
	scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
		selector, camera, core::vector3df(60,100,60),
		core::vector3df(0,0,0),
		core::vector3df(0,50,0));
	selector->drop();
	camera->addAnimator(anim);
	anim->drop();
	//////////////
	// create skydome
    driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
       scene::ISceneNode* skydome=smgr->addSkyDomeSceneNode(driver->getTexture("skydome.jpg"),16,8,0.95f,2.0f);
     driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true);
	// create event receiver

	 io::path vsFileName = "Dx_Shader.hlsl";
	 io::path psFileName = "Dx_Shader.hlsl";
	 if (!driver->queryFeature(video::EVDF_PIXEL_SHADER_2_0))
	 {
                device->getLogger()->log("WARNING: Pixel shaders disabled "\
                        "because of missing driver/hardware support.");
                psFileName = "";
        }

        if (!driver->queryFeature(video::EVDF_VERTEX_SHADER_2_0))
        {
                device->getLogger()->log("WARNING: Vertex shaders disabled "\
                        "because of missing driver/hardware support.");
                vsFileName = "";
        }
	// create materials

    video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();
    s32 newMaterialType = 0;
    if (gpu)
    {
            MyShaderCallBack* mc = new MyShaderCallBack();
            // create the shaders depending on if the user wanted high level
            // or low level shaders:
            if (UseHighLevelShaders)
            {
                    // create material from high level shaders (hlsl or glsl)
                    newMaterialType = gpu->addHighLevelShaderMaterialFromFiles(
                            vsFileName, "vs_main", video::EVST_VS_2_0,
                            psFileName, "ps_main", video::EPST_PS_2_0,
							mc, video::EMT_DETAIL_MAP);
            }
            mc->drop();
    }


	irr::video::ITexture * tex = driver->getTexture("base.png");
	terrain->setMaterialTexture(0,tex);
	terrain->setMaterialTexture(1,driver->getTexture("tex1.jpg"));
	terrain->setMaterialTexture(2,driver->getTexture("tex2.jpg"));
	terrain->setMaterialTexture(3,driver->getTexture("tex3.JPG"));
	terrain->setMaterialTexture(4,driver->getTexture("tex4.JPG"));
	terrain->setMaterialTexture(5,driver->getTexture("tex5.JPG"));
	terrain->setMaterialTexture(6,driver->getTexture("tex6.JPG"));
	terrain->setMaterialTexture(7,driver->getTexture("tex7.JPG"));
	terrain->setMaterialType((video::E_MATERIAL_TYPE)newMaterialType);


	terrain->setMaterialFlag(video::EMF_LIGHTING, false);
	//terrain->setMaterialFlag(video::EMF_FOG_ENABLE, true);


	int texSize=256;

	int count=0;

	int lastFPS = -1;

	while(device->run())
	if (device->isWindowActive())
	{
		driver->beginScene(true, true, 0 );

		smgr->drawAll();
		env->drawAll();

		count++;


		float camPosition[] = {0,0,0};
		//pEffect->SetValue("camposition",campos,3*sizeof(float));
		//D3DDEVICE->SetVertexShaderConstantF( 0, camPosition, 1);

		//test change of terrain-texture
		if(count>200){
			count=-10000;

				u8 * pixel=(u8*)tex->lock();
				int pitch = tex->getPitch();
				int pPixel = 4;
				int texType=0;
				int texCount=0;

				if(1)
				for(int x=texSize/3;x<texSize*2/3;x++){
				for(int y=0;y<texSize;y++)
					pixel[pitch*y + x*pPixel+1] =255;
				}
				if(1)
				for(int x=0;x<texSize*1/3;x++){
				for(int y=0;y<texSize;y++)
					pixel[pitch*y + x*pPixel+0] =255;
				}



				tex->unlock();
				tex->regenerateMipMapLevels();
		}


		driver->endScene();

		// display frames per second in window title
		int fps = driver->getFPS();
		if (lastFPS != fps)
		{
			core::stringw str = L"Terrain Renderer - Irrlicht Engine [";
			str += driver->getName();
			str += "] FPS:";
			str += fps;
			// Also print terrain height of current camera position
			// We can use camera position because terrain is located at coordinate origin
			str += " Height: ";

			str += terrain->getHeight(camera->getAbsolutePosition().X,
					camera->getAbsolutePosition().Z);


			device->setWindowCaption(str.c_str());
			lastFPS = fps;
		}
	}
	device->drop();
	return 0;
}