#include < irrlicht.h >
#include "driverChoice.h"

using namespace irr;
using namespace core;

#if defined(_MSC_VER)
#pragma comment(lib, "Irrlicht.lib")
#endif // MSC_VER

class CMyLightManager : public scene::ILightManager, public IEventReceiver
{
         typedef enum
         {
                 NO_MANAGEMENT,
                 LIGHTS_NEAREST_NODE,
                 LIGHTS_IN_ZONE
         }
         LightManagementMode;

         LightManagementMode Mode;
         LightManagementMode RequestedMode;

         // Эти данные представляют собой информацию о состояниях, используемых менеджером освещения.
         scene::ISceneManager * SceneManager;
         core::array< scene::ILightSceneNode* > * SceneLightList;
         scene::E_SCENE_NODE_RENDER_PASS CurrentRenderPass;
         scene::ISceneNode * CurrentSceneNode;

public:
         CMyLightManager(scene::ISceneManager* sceneManager)
                 : Mode(NO_MANAGEMENT), RequestedMode(NO_MANAGEMENT),
                 SceneManager(sceneManager),  SceneLightList(0),
                 CurrentRenderPass(scene::ESNRP_NONE), CurrentSceneNode(0)
         { }

         virtual ~CMyLightManager(void) { }

         // обработка событий: переключение стратегии менеджера освещения
         bool OnEvent(const SEvent & event)
         {
                 bool handled = false;

                 if (event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.PressedDown)
                 {
                         handled = true;
                         switch(event.KeyInput.Key)
                         {
                         case irr::KEY_KEY_1:
                    RequestedMode = NO_MANAGEMENT;
                    break;
                         case irr::KEY_KEY_2:
                    RequestedMode = LIGHTS_NEAREST_NODE;
                    break;
                         case irr::KEY_KEY_3:
                    RequestedMode = LIGHTS_IN_ZONE;
                    break;
                         default:
                    handled = false;
                    break;
                         }

                         if(NO_MANAGEMENT == RequestedMode)
                    // Указать, что менеджер освещения не работает
                    SceneManager->setLightManager(0);
                         else
                    SceneManager->setLightManager(this);
                 }

                 return handled;
         }

         // Это вызывается перед рендерингом первой ноды сцены.
         virtual void OnPreRender(core::array< scene::ILightSceneNode* > & lightList)
         {
                 // ринудительно устанавливаем режим, на всякий случай
                 Mode = RequestedMode;

                 // Сохраняем список источников света, которым будем оперировать до OnPostRender().
                 SceneLightList = &lightList;
         }

         // Вызывается после рендеринга последней ноды сцены.
         virtual void OnPostRender()
         {
                 // Так как менеджер освещения может быть выключен в обработчике событий, мы включим
                 // источники света, чтобы гарантировать, что они находятся в согласованном состоянии.  
                 // Обычно вам не нужно делать этого при использовании менеджера освещения, так как вы
                 //управляете источниками света самостоятельно.
                 for(u32 i = 0; i < SceneLightList->size(); i++)
                         (*SceneLightList)[i]->setVisible(true);
         }

         virtual void OnRenderPassPreRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
         {
                 // Я ничего не делаю здесь кроме того, что сохраняю текущий проходе рендера
                 CurrentRenderPass = renderPass;
         }

         virtual void OnRenderPassPostRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
         {
                 // Я хочу осветить лишь твёрдотелые ноды, поэтому после
                 // прохождения твёрдых, выключить все источники света.
                 if(scene::ESNRP_SOLID == renderPass)
                 {
                         for(u32 i = 0; i < SceneLightList->size(); ++i)
                    (*SceneLightList)[i]->setVisible(false);
                 }
         }

         // Это вызывается перед рендерингом текущей ноды
         virtual void OnNodePreRender(scene::ISceneNode* node)
         {
                 CurrentSceneNode = node;

                 // Этот менеджер освещения работает только с "твёрдыми" объектами, но вы можете  
                 // свободно манипулировать светом на любом этапе, в зависимости от ваших намерений.
                 if (scene::ESNRP_SOLID != CurrentRenderPass)
                         return;

                 // Практически в этом примере, Я только хочу рассмотреть освещение узлов(нод) с 3д моделью куба  
                 if (node->getType() != scene::ESNT_CUBE)
                         return;

                 if (LIGHTS_NEAREST_NODE == Mode)
                 {
                         // Это демонстрационная реализация, которая расставляет приоритеты для каждого  
                         // источника света на сцене согласно его близости к узлу(ноде) во время рендеринга.  
                         // Это приводит к некоторому мерцанию, когда орбита чужого источника света ближе к кубу,  
                         // чем источник света из собственный 'зоны'.
                         const vector3df nodePosition = node->getAbsolutePosition();

                         // Список для сортировки источников света по приоритетам основанным на их удалении от
                         // ноды для последующего рендеринга.
                         array< LightDistanceElement > sortingArray;
                         sortingArray.reallocate(SceneLightList->size());

                         u32 i;
                         for(i = 0; i < SceneLightList->size(); ++i)
                         {
                    scene::ILightSceneNode* lightNode = (*SceneLightList)[i];
                    f64 distance = lightNode->getAbsolutePosition().getDistanceFromSQ(nodePosition);
                    sortingArray.push_back(LightDistanceElement(lightNode, distance));
                         }

                         sortingArray.sort();

                         // Список теперь сортируется по близости к ноде.
                         // Включить 3 ближайших источника света и отключить остальные.
                         for(i = 0; i < sortingArray.size(); ++i)
                    sortingArray[i].node->setVisible(i < 3);

                 }
                 else if(LIGHTS_IN_ZONE == Mode)
                 {
                         // Режим когда Ноды-пустышки используются для представления 'зоны'. При рендеринге
                         // каждой 3д модели которая визуализируется, сначала отключаем все освещение и включаем  
                         // только те источники, которые принадлежат текущей зоне. Этот алгоритм имеет главную  
                         // цель: не использовать никаких специальных знаний о том как организована графика данной сцены.
                         for (u32 i = 0; i < SceneLightList->size(); ++i)
                         {
                    scene::ILightSceneNode* lightNode = (*SceneLightList)[i];
                    video::SLight & lightData = lightNode->getLightData();

                    if (video::ELT_DIRECTIONAL != lightData.Type)
                    lightNode->setVisible(false);
                         }

                         scene::ISceneNode * parentZone = findZone(node);
                         if (parentZone)
                    turnOnZoneLights(parentZone);
                 }
         }

         // ызывается после рендеринга узла(ноды) на сцене
         virtual void OnNodePostRender(scene::ISceneNode* node)
         {
                 // Мне не нужно управлять источниками света после рендеринга индивидуальной ноды.
         }

private:

         // Найти ноду-пустышку(зону) являющуюся родителем запрошенного узла
         scene::ISceneNode * findZone(scene::ISceneNode * node)
         {
                 if(!node)
                         return 0;

                 if(node->getType() == scene::ESNT_EMPTY)
                         return node;

                 return findZone(node->getParent());
         }

         // Включить все освещение, т.е. источники света которые являются потомками запрошенной ноды.
         void turnOnZoneLights(scene::ISceneNode * node)
         {
                 core::list< scene::ISceneNode* > const & children = node->getChildren();
                 for (core::list< scene::ISceneNode* >::ConstIterator child = children.begin();
                         child != children.end();
                         ++child)
                 {
                         if((*child)->getType() == scene::ESNT_LIGHT)
                    static_cast< scene::ILightSceneNode* >(*child)->setVisible(true);
                         else  
                    // Предположим, что нода не имеет источников света, но имеет  
                    // потомков, которые в свою очередь могут иметь свои источники освещения
                    turnOnZoneLights(*child);
                 }
         }

         // Вспомогательный класс для оказания помощи в сортировке нод сцены в зависимости от расстояния
         class LightDistanceElement
         {
         public:
                 LightDistanceElement() {};

                 LightDistanceElement(scene::ILightSceneNode* n, f64 d)
                         : node(n), distance(d) { }

                 scene::ILightSceneNode* node;
                 f64 distance;

                 // Элементы на меньшей дистанции перемещаются в начало массива
                 bool operator < (const LightDistanceElement& other) const
                 {
                         return (distance < other.distance);
                 }
         };
};