// ==============================================================
//      This file is part of Glest (www.glest.org)
//
//      Copyright (C) 2001-2008 Martiño Figueroa
//
//      You can redistribute this code and/or modify it under
//      the terms of the GNU General Public License as published
//      by the Free Software Foundation; either version 2 of the
//      License, or (at your option) any later version
// ==============================================================
#include "intro.h"

#include "main_menu.h"
#include "util.h"
#include "game_util.h"
#include "config.h"
#include "program.h"
#include "renderer.h"
#include "sound_renderer.h"
#include "core_data.h"
#include "metrics.h"
#include "auto_test.h"
#include "util.h"
//#include "glm.h"
//#include "md5util.h"
//#include "Mathlib.h"

#include "video_player.h"

#include "leak_dumper.h"

using namespace
  Shared::Util;
using
  namespace
  Shared::Graphics;
using
  namespace
  Shared::Xml;

namespace Glest
{
  namespace Game
  {

//struct Timer {
//public:
//  Timer ()
//    : current_time (0.0), last_time (0.0) { }
//
//public:
//  void update () {
//    last_time = current_time;
//    current_time = static_cast<double>(SDL_GetTicks ()) / 1000.0;
//  }
//
//  double deltaTime () const {
//    return (current_time - last_time);
//  }
//
//public:
//  double current_time;
//  double last_time;
//
//} animTimer;

// =====================================================
//      class Text
// =====================================================

    IntroText::IntroText (const string & text, const Vec2i & pos, int time,
                          Font2D * font, Font3D * font3D)
    {
      this->text = text;
      this->pos = pos;
      this->time = time;
      this->texture = NULL;
      this->font = font;
      this->font3D = font3D;
    }

    IntroText::IntroText (const Texture2D * texture, const Vec2i & pos,
                          const Vec2i & size, int time)
    {
      this->pos = pos;
      this->size = size;
      this->time = time;
      this->texture = texture;
      this->font = NULL;
      this->font3D = NULL;
    }

// =====================================================
//      class Intro
// =====================================================

    int
      Intro::introTime = 50000;
    int
      Intro::appearTime = 2500;
    int
      Intro::showTime = 3500;
    int
      Intro::disapearTime = 2500;

  Intro::Intro (Program * program):
    ProgramState (program)
    {
      if (SystemFlags::
          getSystemSettingType (SystemFlags::debugSystem).enabled)
        SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                  "In [%s::%s Line: %d]\n", __FILE__,
                                  __FUNCTION__, __LINE__);

      CoreData & coreData = CoreData::getInstance ();
      SoundRenderer & soundRenderer = SoundRenderer::getInstance ();

      if (GlobalStaticFlags::getIsNonGraphicalModeEnabled () == false &&
          (::Shared::Graphics::VideoPlayer::hasBackEndVideoPlayer () == false
           || CoreData::getInstance ().hasIntroVideoFilename () == false))
      {
        soundRenderer.playMusic (CoreData::getInstance ().getIntroMusic ());
      }

      const
        Metrics &
        metrics = Metrics::getInstance ();
      int
        w = metrics.getVirtualW ();
      int
        h = metrics.getVirtualH ();
      timer = 0;
      mouseX = 0;
      mouseY = 0;
      mouse2d = 0;
      exitAfterIntroVideo = false;

      Renderer & renderer = Renderer::getInstance ();
//renderer.init3dListMenu(NULL);
      renderer.initMenu (NULL);
      fade = 0.f;
      anim = 0.f;
      targetCamera = NULL;
      t = 0.f;

      startPosition.x = 5;;
      startPosition.y = 10;
      startPosition.z = 40;
      camera.setPosition (startPosition);

      Vec3f startRotation;
      startRotation.x = 0;
      startRotation.y = 0;
      startRotation.z = 0;

      camera.setOrientation (Quaternion
                             (EulerAngles
                              (degToRad (startRotation.x),
                               degToRad (startRotation.y),
                               degToRad (startRotation.z))));

      Intro::introTime = 3000;
      Intro::appearTime = 500;
      Intro::showTime = 500;
      Intro::disapearTime = 500;
      int
        showIntroPics = 0;
      int
        showIntroPicsTime = 0;
      bool showIntroPicsRandom = false;
      bool showIntroModels = false;
      bool showIntroModelsRandom = false;
      modelMinAnimSpeed = 0;
      modelMaxAnimSpeed = 0;

      XmlTree xmlTree;
      string
        data_path =
        getGameReadWritePath (GameConstants::path_data_CacheLookupKey);
      xmlTree.load (getGameCustomCoreDataPath
                    (data_path, "data/core/menu/menu.xml"),
                    Properties::getTagReplacementValues ());
      const XmlNode *
        menuNode = xmlTree.getRootNode ();

      if (menuNode->hasChild ("intro") == true)
      {
        const XmlNode *
          introNode = menuNode->getChild ("intro");

        if (SystemFlags::
            getSystemSettingType (SystemFlags::debugSystem).enabled)
          SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                    "In [%s::%s %d]\n", __FILE__,
                                    __FUNCTION__, __LINE__);

//camera
        const XmlNode *
          cameraNode = introNode->getChild ("camera");

//position
        const XmlNode *
          positionNode = cameraNode->getChild ("start-position");
        startPosition.x = positionNode->getAttribute ("x")->getFloatValue ();
        startPosition.y = positionNode->getAttribute ("y")->getFloatValue ();
        startPosition.z = positionNode->getAttribute ("z")->getFloatValue ();
        camera.setPosition (startPosition);

//rotation
        const XmlNode *
          rotationNode = cameraNode->getChild ("start-rotation");
        Vec3f startRotation;
        startRotation.x = rotationNode->getAttribute ("x")->getFloatValue ();
        startRotation.y = rotationNode->getAttribute ("y")->getFloatValue ();
        startRotation.z = rotationNode->getAttribute ("z")->getFloatValue ();
        camera.setOrientation (Quaternion
                               (EulerAngles
                                (degToRad (startRotation.x),
                                 degToRad (startRotation.y),
                                 degToRad (startRotation.z))));

// intro info
        const XmlNode *
          introTimeNode = introNode->getChild ("intro-time");
        Intro::introTime =
          introTimeNode->getAttribute ("value")->getIntValue ();
        const XmlNode *
          appearTimeNode = introNode->getChild ("appear-time");
        Intro::appearTime =
          appearTimeNode->getAttribute ("value")->getIntValue ();
        const XmlNode *
          showTimeNode = introNode->getChild ("show-time");
        Intro::showTime =
          showTimeNode->getAttribute ("value")->getIntValue ();
        const XmlNode *
          disappearTimeNode = introNode->getChild ("disappear-time");
        Intro::disapearTime =
          disappearTimeNode->getAttribute ("value")->getIntValue ();
        const XmlNode *
          showIntroPicturesNode = introNode->getChild ("show-intro-pictures");
        showIntroPics =
          showIntroPicturesNode->getAttribute ("value")->getIntValue ();
        showIntroPicsTime =
          showIntroPicturesNode->getAttribute ("time")->getIntValue ();
        showIntroPicsRandom =
          showIntroPicturesNode->getAttribute ("random")->getBoolValue ();

        const XmlNode *
          showIntroModelsNode = introNode->getChild ("show-intro-models");
        showIntroModels =
          showIntroModelsNode->getAttribute ("value")->getBoolValue ();
        showIntroModelsRandom =
          showIntroModelsNode->getAttribute ("random")->getBoolValue ();
        modelMinAnimSpeed =
          showIntroModelsNode->
          getAttribute ("min-anim-speed")->getFloatValue ();
        modelMaxAnimSpeed =
          showIntroModelsNode->
          getAttribute ("max-anim-speed")->getFloatValue ();
      }

//load main model
      modelIndex = 0;
      models.clear ();
      if (showIntroModels == true)
      {

//getGameCustomCoreDataPath(data_path, "data/core/menu/menu.xml")
        string
          introPath =
          getGameCustomCoreDataPath (data_path,
                                     "") +
          "data/core/menu/main_model/intro*.g3d";
        vector < string > introModels;
        findAll (introPath, introModels, false, false);
        for (int i = 0; i < (int) introModels.size (); ++i)
        {
          string logo = introModels[i];
          Model *
            model = renderer.newModel (rsMenu,
                                       getGameCustomCoreDataPath (data_path,
                                                                  "") +
                                       "data/core/menu/main_model/" + logo);
          if (model)
          {
            models.push_back (model);
//printf("#1 Intro model [%s]\n",model->getFileName().c_str());
          }
        }

        if (models.empty () == true)
        {
          introPath = data_path + "data/core/menu/main_model/intro*.g3d";
//vector<string> introModels;
          findAll (introPath, introModels, false, false);
          for (int i = 0; i < (int) introModels.size (); ++i)
          {
            string logo = introModels[i];
            Model *
              model = renderer.newModel (rsMenu,
                                         data_path +
                                         "data/core/menu/main_model/" + logo);
            if (model)
            {
              models.push_back (model);
//printf("#2 Intro model [%s]\n",model->getFileName().c_str());
            }
          }
        }

        if (showIntroModelsRandom == true)
        {
          std::vector < Model * >modelList;

//unsigned int seed = time(NULL);
          Chrono seed (true);
          srand ((unsigned int) seed.getCurTicks ());
          int
            failedLookups = 0;
          std::map < int,
            bool >
            usedIndex;
          for (; modelList.size () < models.size ();)
          {
            int
              index = rand () % models.size ();
            if (usedIndex.find (index) != usedIndex.end ())
            {
              failedLookups++;
              srand ((unsigned int) seed.getCurTicks () / failedLookups);
              continue;
            }
//printf("picIndex = %d list count = %d\n",picIndex,coreData.getMiscTextureList().size());
            modelList.push_back (models[index]);
            usedIndex[index] = true;
            srand ((unsigned int) seed.getCurTicks () /
                   (unsigned int) modelList.size ());
          }
          models = modelList;
        }
      }

      int
        displayItemNumber = 1;
      int
        appear = Intro::appearTime;
      int
        disappear =
        Intro::showTime + Intro::appearTime + (Intro::disapearTime * 2);

      const unsigned int
        maxIntroLines = 100;
      Lang & lang = Lang::getInstance ();
      for (unsigned int i = 1; i < maxIntroLines; ++i)
      {
        string introTagName = "IntroText" + intToStr (i);
        string introTagTextureName = "IntroTexture" + intToStr (i);

        if (lang.hasString (introTagName, "", true) == true ||
            lang.hasString (introTagTextureName, "", true) == true)
        {
          string lineText = "";

          if (lang.hasString (introTagName, "", true) == true)
          {
            lineText = lang.getString (introTagName, "", true);
          }

          string showStartTime = "IntroStartMilliseconds" + intToStr (i);

          int
            displayTime = appear;
          if (lang.hasString (showStartTime, "", true) == true)
          {
            displayTime = strToInt (lang.getString (showStartTime, "", true));
          }
          else
          {
            if (i == 1)
            {
              displayTime = appear;
            }
            else if (i == 2)
            {
              displayTime = disappear;
            }
            else if (i >= 3)
            {
              displayTime = disappear * (++displayItemNumber);
            }
          }

// Is this a texture?
          if (lang.hasString (introTagName, "", true) == false &&
              lang.hasString (introTagTextureName, "", true) == true)
          {

            string
              introTagTextureWidthName = "IntroTextureWidth" + intToStr (i);
            string
              introTagTextureHeightName = "IntroTextureHeight" + intToStr (i);

            lineText = lang.getString (introTagTextureName, "", true);
            Texture2D *
              logoTexture = renderer.newTexture2D (rsGlobal);
            if (logoTexture)
            {
              logoTexture->setMipmap (false);
              logoTexture->getPixmap ()->load (lineText);

              renderer.initTexture (rsGlobal, logoTexture);
            }


            int
              textureWidth = 256;
            if (logoTexture != NULL)
            {
              textureWidth = logoTexture->getTextureWidth ();
            }
            if (lang.hasString (introTagTextureWidthName, "", true) == true)
            {
              textureWidth =
                strToInt (lang.getString
                          (introTagTextureWidthName, "", true));
            }

            int
              textureHeight = 128;
            if (logoTexture != NULL)
            {
              textureHeight = logoTexture->getTextureHeight ();
            }
            if (lang.hasString (introTagTextureHeightName, "", true) == true)
            {
              textureHeight =
                strToInt (lang.getString
                          (introTagTextureHeightName, "", true));
            }

            texts.push_back (new
                             IntroText (logoTexture,
                                        Vec2i (w / 2 - (textureWidth / 2),
                                               h / 2 - (textureHeight / 2)),
                                        Vec2i (textureWidth, textureHeight),
                                        displayTime));
          }
// This is a line of text
          else
          {
            string introTagTextXName = "IntroTextX" + intToStr (i);
            string introTagTextYName = "IntroTextY" + intToStr (i);
            string
              introTagTextFontTypeName = "IntroTextFontType" + intToStr (i);

            int
              textX = -1;
            if (lang.hasString (introTagTextXName, "", true) == true)
            {
              string value = lang.getString (introTagTextXName, "", true);
              if (value.length () > 0 && (value[0] == '+' || value[0] == '-'))
              {
                textX = w / 2 + strToInt (value);
              }
              else
              {
                textX = strToInt (value);
              }
            }

            int
              textY = -1;
            if (lang.hasString (introTagTextYName, "", true) == true)
            {
              string value = lang.getString (introTagTextYName, "", true);
              if (value.length () > 0 && (value[0] == '+' || value[0] == '-'))
              {
                textY = h / 2 + strToInt (value);
              }
              else
              {
                textY = strToInt (value);
              }
            }

            Font2D *
              font = coreData.getMenuFontVeryBig ();
            Font3D *
              font3d = coreData.getMenuFontVeryBig3D ();

            if (lang.hasString (introTagTextFontTypeName, "", true) == true)
            {
              string
                value = lang.getString (introTagTextFontTypeName, "", true);
              if (value == "displaynormal")
              {
                font = coreData.getDisplayFont ();
                font3d = coreData.getDisplayFont3D ();
              }
              else if (value == "displaysmall")
              {
                font = coreData.getDisplayFontSmall ();
                font3d = coreData.getDisplayFontSmall3D ();
              }
              else if (value == "menunormal")
              {
                font = coreData.getMenuFontNormal ();
                font3d = coreData.getMenuFontNormal3D ();
              }
              else if (value == "menubig")
              {
                font = coreData.getMenuFontBig ();
                font3d = coreData.getMenuFontBig3D ();
              }
              else if (value == "menuverybig")
              {
                font = coreData.getMenuFontVeryBig ();
                font3d = coreData.getMenuFontVeryBig3D ();
              }
              else if (value == "consolenormal")
              {
                font = coreData.getConsoleFont ();
                font3d = coreData.getConsoleFont3D ();
              }

            }
            texts.push_back (new
                             IntroText (lineText, Vec2i (textX, textY),
                                        displayTime, font, font3d));
          }
        }
        else
        {
          break;
        }
      }
      modelShowTime = disappear * (displayItemNumber);
      if (lang.hasString ("IntroModelStartMilliseconds", "", true) == true)
      {
        modelShowTime =
          strToInt (lang.getString ("IntroModelStartMilliseconds", "", true));
      }
      else
      {
        modelShowTime = disappear * (displayItemNumber);
      }

/*
string lineText = "Based on award-winning classic Glest";
texts.push_back(new Text(lineText, Vec2i(-1, -1), appear, coreData.getMenuFontVeryBig(),coreData.getMenuFontVeryBig3D()));
lineText = "the MegaGlest Team presents";
texts.push_back(new Text(lineText, Vec2i(-1, -1), disappear, coreData.getMenuFontVeryBig(),coreData.getMenuFontVeryBig3D()));
lineText = "a libre software real-time strategy game";
texts.push_back(new Text(lineText, Vec2i(-1, -1), disappear *(++displayItemNumber), coreData.getMenuFontVeryBig(),coreData.getMenuFontVeryBig3D()));

texts.push_back(new Text(coreData.getLogoTexture(), Vec2i(w/2-128, h/2-64), Vec2i(256, 128), disappear *(++displayItemNumber)));
texts.push_back(new Text(glestVersionString, Vec2i(w/2+45, h/2-45), disappear *(displayItemNumber++), coreData.getMenuFontNormal(),coreData.getMenuFontNormal3D()));
lineText = "www.megaglest.org";
//texts.push_back(new Text(lineText, Vec2i(-1, -1), disappear *(displayItemNumber++), coreData.getMenuFontVeryBig(),coreData.getMenuFontVeryBig3D()));
texts.push_back(new Text(lineText, Vec2i(-1, h/2-45-18), disappear *(displayItemNumber-1), coreData.getMenuFontVeryBig(),coreData.getMenuFontVeryBig3D()));
*/



      if (showIntroPics > 0 && coreData.getMiscTextureList ().size () > 0)
      {
        const int
          showMiscTime = showIntroPicsTime;

        std::vector < Texture2D * >intoTexList;
        if (showIntroPicsRandom == true)
        {
//unsigned int seed = time(NULL);
          Chrono seed (true);
          srand ((unsigned int) seed.getCurTicks ());
          int
            failedLookups = 0;
          std::map < int,
            bool >
            usedIndex;
          for (; (int) intoTexList.size () < showIntroPics;)
          {
            int
              picIndex = rand () % coreData.getMiscTextureList ().size ();
            if (usedIndex.find (picIndex) != usedIndex.end ())
            {
              failedLookups++;
              srand ((unsigned int) seed.getCurTicks () / failedLookups);

              if (failedLookups > 10000)
              {
                for (unsigned int i = 0;
                     i < coreData.getMiscTextureList ().size (); ++i)
                {
                  if (usedIndex.find (i) == usedIndex.end ())
                  {
                    picIndex = i;
                    break;
                  }
                }
              }
              else
              {
                continue;
              }
            }
//printf("picIndex = %d list count = %d\n",picIndex,coreData.getMiscTextureList().size());
            intoTexList.push_back (coreData.getMiscTextureList ()[picIndex]);
            usedIndex[picIndex] = true;
            srand ((unsigned int) seed.getCurTicks () /
                   (unsigned int) intoTexList.size ());
          }
        }
        else
        {
          for (unsigned int i = 0;
               i < (unsigned int) coreData.getMiscTextureList ().size () &&
               i < (unsigned int) showIntroPics; ++i)
          {
            Texture2D *
              tex = coreData.getMiscTextureList ()[i];
            intoTexList.push_back (tex);
          }
        }

        for (unsigned int i = 0; i < intoTexList.size (); ++i)
        {
          Texture2D *
            tex = intoTexList[i];
//printf("tex # %d [%s]\n",i,tex->getPath().c_str());

          Vec2i texPlacement;
          if (i == 0 || i % 9 == 0)
          {
            texPlacement = Vec2i (1, h - tex->getTextureHeight ());
          }
          else if (i == 1 || i % 9 == 1)
          {
            texPlacement = Vec2i (1, 1);
          }
          else if (i == 2 || i % 9 == 2)
          {
            texPlacement = Vec2i (w - tex->getTextureWidth (), 1);
          }
          else if (i == 3 || i % 9 == 3)
          {
            texPlacement =
              Vec2i (w - tex->getTextureWidth (),
                     h - tex->getTextureHeight ());
          }
          else if (i == 4 || i % 9 == 4)
          {
            texPlacement =
              Vec2i (w / 2 - tex->getTextureWidth () / 2,
                     h - tex->getTextureHeight ());
          }
          else if (i == 5 || i % 9 == 5)
          {
            texPlacement = Vec2i (w / 2 - tex->getTextureWidth () / 2, 1);
          }
          else if (i == 6 || i % 9 == 6)
          {
            texPlacement =
              Vec2i (1, (h / 2) - (tex->getTextureHeight () / 2));
          }
          else if (i == 7 || i % 9 == 7)
          {
            texPlacement =
              Vec2i (w - tex->getTextureWidth (),
                     (h / 2) - (tex->getTextureHeight () / 2));
          }

          int
            textureStartTime = disappear * displayItemNumber;
          if (lang.hasString ("IntroTextureStartMilliseconds", "", true) ==
              true)
          {
            textureStartTime =
              strToInt (lang.getString ("IntroTextureStartMilliseconds", "",
                                        true));
          }

          texts.push_back (new
                           IntroText (tex, texPlacement,
                                      Vec2i (tex->getTextureWidth (),
                                             tex->getTextureHeight ()),
                                      textureStartTime +
                                      (showMiscTime * (i + 1))));
        }
      }

      if (GlobalStaticFlags::getIsNonGraphicalModeEnabled () == false)
      {
        renderer.swapBuffers ();
      }

      SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                "In [%s::%s Line: %d]\n", __FILE__,
                                __FUNCTION__, __LINE__);

      if (GlobalStaticFlags::getIsNonGraphicalModeEnabled () == false
          &&::Shared::Graphics::VideoPlayer::hasBackEndVideoPlayer () == true
          && CoreData::getInstance ().hasIntroVideoFilename () == true)
      {
        string
          introVideoFile = CoreData::getInstance ().getIntroVideoFilename ();
        string
          introVideoFileFallback =
          CoreData::getInstance ().getIntroVideoFilenameFallback ();

        if (SystemFlags::VERBOSE_MODE_ENABLED)
          printf ("Intro Video [%s] [%s]\n", introVideoFile.c_str (),
                  introVideoFileFallback.c_str ());

        Context *
          c = GraphicsInterface::getInstance ().getCurrentContext ();
        PlatformContextGl *
          glCtx = static_cast < ContextGl * >(c)->getPlatformContextGlPtr ();
        SDL_Window *
          window = glCtx->getScreenWindow ();
        SDL_Surface *
          screen = glCtx->getScreenSurface ();

        string
          vlcPluginsPath =
          Config::getInstance ().getString ("VideoPlayerPluginsPath", "");
//printf("screen->w = %d screen->h = %d screen->format->BitsPerPixel = %d\n",screen->w,screen->h,screen->format->BitsPerPixel);
        ::Shared::Graphics::VideoPlayer player (&Renderer::getInstance (),
                                                introVideoFile,
                                                introVideoFileFallback,
                                                window,
                                                0, 0,
                                                screen->w,
                                                screen->h,
                                                screen->format->BitsPerPixel,
                                                false,
                                                vlcPluginsPath,
                                                SystemFlags::VERBOSE_MODE_ENABLED);
        player.PlayVideo ();
        exitAfterIntroVideo = true;
        return;
      }

      SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                "In [%s::%s Line: %d]\n", __FILE__,
                                __FUNCTION__, __LINE__);
    }

    Intro::~Intro ()
    {
      deleteValues (texts.begin (), texts.end ());

//deleteValues(introTextureList.begin(),introTextureList.end());
//      if(test) {
//              glmDelete(test);
//      }

//Shared::Graphics::md5::cleanupMD5OpenGL();
    }

    void
    Intro::update ()
    {
      if (exitAfterIntroVideo == true)
      {
        mouseUpLeft (0, 0);
//cleanup();
        return;
      }
      timer++;
      if (timer > introTime * GameConstants::updateFps / 1000)
      {
        SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                  "In [%s::%s Line: %d]\n", __FILE__,
                                  __FUNCTION__, __LINE__);

        cleanup ();
        return;
      }

      if (Config::getInstance ().getBool ("AutoTest"))
      {
        SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                  "In [%s::%s Line: %d]\n", __FILE__,
                                  __FUNCTION__, __LINE__);

        AutoTest::getInstance ().updateIntro (program);
        return;
      }

      mouse2d = (mouse2d + 1) % Renderer::maxMouse2dAnim;

      if (targetCamera != NULL)
      {
        t +=
          ((0.01f +
            (1.f - t) / 10.f) / 20.f) * (60.f / GameConstants::updateFps);

//interpolate position
        camera.setPosition (lastCamera.
                            getPosition ().lerp (t,
                                                 targetCamera->
                                                 getPosition ()));

//interpolate orientation
        Quaternion
          q =
          lastCamera.getOrientation ().lerp (t,
                                             targetCamera->getOrientation ());
        camera.setOrientation (q);

        if (t >= 1.f)
        {
          targetCamera = NULL;
          t = 0.f;
        }
      }

//fade
      if (fade <= 1.f)
      {
        fade += 0.6f / GameConstants::updateFps;
        if (fade > 1.f)
        {
          fade = 1.f;
        }
      }

//animation
//const float minSpeed = 0.015f;
//const float minSpeed = 0.010f;
//const float maxSpeed = 0.6f;
      const float
        minSpeed = modelMinAnimSpeed;
      const float
        maxSpeed = modelMaxAnimSpeed;
      anim +=
        (maxSpeed / GameConstants::updateFps) / 5 +
        random.randRange (minSpeed,
                          max (minSpeed + 0.0001f,
                               (maxSpeed / GameConstants::updateFps) / 5.f));
      if (anim > 1.f)
      {
        anim = 0.f;
      }

//animTimer.update();
    }

    void
    Intro::renderModelBackground ()
    {
// Black background
      glClearColor (0, 0, 0, 1);

      if (models.empty () == false)
      {
        int
          difTime = 1000 * timer / GameConstants::updateFps - modelShowTime;
        int
          totalModelShowTime = Intro::introTime - modelShowTime;
        int
          individualModelShowTime = totalModelShowTime / (int) models.size ();

//printf("difTime = %d individualModelShowTime = %d modelIndex = %d\n",difTime,individualModelShowTime,modelIndex);

//int difTime= 1;
        if (difTime > 0)
        {
          if (difTime > ((modelIndex + 1) * individualModelShowTime))
          {
//int oldmodelIndex = modelIndex;
            if (modelIndex + 1 < (int) models.size ())
            {
              modelIndex++;

//position
//nextCamera.setPosition(camera.getPosition());
//                                      nextCamera.setPosition(Vec3f(84,-9,11));
//
//                                      //rotation
//                                      //Vec3f startRotation(0,12,0);
//                                      Vec3f startRotation(0,-80,0);
//                                      nextCamera.setOrientation(Quaternion(EulerAngles(
//                                              degToRad(startRotation.x),
//                                              degToRad(startRotation.y),
//                                              degToRad(startRotation.z))));
//
//                                      this->targetCamera = &nextCamera;
//                                      this->lastCamera= camera;
//                                      this->t= 0.f;

            }
//printf("oldmodelIndex = %d, modelIndex = %d\n",oldmodelIndex,modelIndex);
          }
          Renderer & renderer = Renderer::getInstance ();
          vector < Model * >characterModels;
          characterModels.push_back (NULL);
          characterModels.push_back (NULL);
          characterModels.push_back (models[modelIndex]);
          const
            Vec3f
            characterPosition = startPosition;
          renderer.renderMenuBackground (&camera, fade, NULL, characterModels,
                                         characterPosition, anim);
        }
      }
    }

    void
    Intro::render ()
    {
      Renderer & renderer = Renderer::getInstance ();
      if (GlobalStaticFlags::getIsNonGraphicalModeEnabled () == true)
      {
        return;
      }

      canRender ();
      incrementFps ();

      renderer.clearBuffers ();
      renderer.reset3dMenu ();

      renderer.clearZBuffer ();
      renderer.loadCameraMatrix (&camera);

      renderModelBackground ();
      renderer.renderParticleManager (rsMenu);

      renderer.reset2d ();

      for (int i = 0; i < (int) texts.size (); ++i)
      {
        IntroText *
          text = texts[i];

        int
          difTime =
          1000 * timer / GameConstants::updateFps - text->getTime ();

        if (difTime > 0 && difTime < appearTime + showTime + disapearTime)
        {
          float
            alpha = 1.f;
          if (difTime > 0 && difTime < appearTime)
          {
//apearing
            alpha = static_cast < float >(difTime) /
              appearTime;
          }
          else if (difTime > 0
                   && difTime < appearTime + showTime + disapearTime)
          {
//disappearing
            alpha =
              1.f - static_cast < float >(difTime - appearTime - showTime) /
              disapearTime;
          }

          if (text->getText ().empty () == false)
          {
            int
              renderX = text->getPos ().x;
            int
              renderY = text->getPos ().y;

            if (Renderer::renderText3DEnabled)
            {
              if (renderX < 0)
              {
                const
                  Metrics &
                  metrics = Metrics::getInstance ();
                int
                  w = metrics.getVirtualW ();
                renderX =
                  (w / 2) -
                  (text->getFont3D ()->
                   getMetrics ()->getTextWidth (text->getText ()) / 2);
              }
              if (renderY < 0)
              {
                const
                  Metrics &
                  metrics = Metrics::getInstance ();
                int
                  h = metrics.getVirtualH ();
                renderY =
                  (h / 2) +
                  (text->getFont3D ()->
                   getMetrics ()->getHeight (text->getText ()) / 2);
              }

              renderer.renderText3D (text->getText (), text->getFont3D (),
                                     alpha, renderX, renderY, false);
            }
            else
            {
              if (renderX < 0)
              {
                const
                  Metrics &
                  metrics = Metrics::getInstance ();
                int
                  w = metrics.getVirtualW ();
                renderX = (w / 2);
              }
              if (renderY < 0)
              {
                const
                  Metrics &
                  metrics = Metrics::getInstance ();
                int
                  h = metrics.getVirtualH ();
                renderY = (h / 2);
              }

              renderer.renderText (text->getText (), text->getFont (), alpha,
                                   renderX, renderY, true);
            }
          }

          if (text->getTexture () != NULL)
          {
            renderer.renderTextureQuad (text->getPos ().x, text->getPos ().y,
                                        text->getSize ().x,
                                        text->getSize ().y,
                                        text->getTexture (), alpha);
          }
        }
      }

      if (program != NULL)
        program->renderProgramMsgBox ();

      if (this->forceMouseRender == true)
        renderer.renderMouse2d (mouseX, mouseY, mouse2d, 0.f);

      bool
        showIntroTiming =
        Config::getInstance ().getBool ("ShowIntroTiming", "false");
      if (showIntroTiming == true && Intro::introTime > 0)
      {
        CoreData & coreData = CoreData::getInstance ();
        int
          difTime = 1000 * timer / GameConstants::updateFps;
        string
          timingText =
          intToStr (difTime) + " / " + intToStr (Intro::introTime);

        if (Renderer::renderText3DEnabled)
        {
//const Metrics &metrics= Metrics::getInstance();
//int w= metrics.getVirtualW();
//int h= metrics.getVirtualH();

          renderer.renderText3D (timingText, coreData.getMenuFontVeryBig3D (),
                                 1, 10, 20, false);
        }
        else
        {
//const Metrics &metrics= Metrics::getInstance();
//int w= metrics.getVirtualW();
//int h= metrics.getVirtualH();

          renderer.renderText (timingText, coreData.getMenuFontVeryBig (), 1,
                               10, 20, false);
        }
      }

      renderer.renderFPSWhenEnabled (lastFps);
      renderer.swapBuffers ();
    }

    void
    Intro::keyDown (SDL_KeyboardEvent key)
    {
      SDL_keysym keystate = key.keysym;
//printf("keystate.mod = %d key = unicode[%d] regular[%d] lalt [%d] ralt [%d] alt [%d]\n",keystate.mod,key.keysym.unicode,key.keysym.sym,(keystate.mod & KMOD_LALT),(keystate.mod & KMOD_RALT),(keystate.mod & KMOD_ALT));

      if (keystate.mod & (KMOD_LALT | KMOD_RALT))
      {
//printf("ALT KEY #1\n");

        if (isKeyPressed (SDLK_RETURN, key) == true ||
            isKeyPressed (SDLK_RALT, key) == true ||
            isKeyPressed (SDLK_LALT, key) == true)
        {
          return;
        }
      }

//printf("Exiting intro\n");
      mouseUpLeft (0, 0);
    }

    void
    Intro::mouseUpLeft (int x, int y)
    {
      SoundRenderer & soundRenderer = SoundRenderer::getInstance ();

      SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                "In [%s::%s Line: %d]\n", __FILE__,
                                __FUNCTION__, __LINE__);
      soundRenderer.stopMusic (CoreData::getInstance ().getIntroMusic ());

      SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                "In [%s::%s Line: %d]\n", __FILE__,
                                __FUNCTION__, __LINE__);

      if (CoreData::getInstance ().hasMainMenuVideoFilename () == false)
      {
        soundRenderer.playMusic (CoreData::getInstance ().getMenuMusic ());
      }

      SystemFlags::OutputDebug (SystemFlags::debugSystem,
                                "In [%s::%s Line: %d]\n", __FILE__,
                                __FUNCTION__, __LINE__);

      cleanup ();
    }

    void
    Intro::cleanup ()
    {
      Renderer::getInstance ().endMenu ();

      program->setState (new MainMenu (program));
    }

    void
    Intro::mouseMove (int x, int y, const MouseState * ms)
    {
      mouseX = x;
      mouseY = y;
    }

}}                              //end namespace