/*
 * Game.cpp
 *
 * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "Game.h"
#include "BSPTree.h"
#include "Level.h"
#include "Shader.h"
#include "Triangle.h"
#include "gl.h"
#include <algorithm>

namespace Zoom {

Game::Game(bool multisample) : angle(0), lightPos(0) {
  glClearColor(0.0, 0.0, 0.0, 1.0);
  glClearDepth(1.0);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LEQUAL);

  //glEnable(GL_BLEND);
  //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

#ifndef _WIN32
  if(multisample)
    glEnable(GL_MULTISAMPLE_ARB);
#endif

  glShadeModel(GL_SMOOTH);

  glEnable(GL_LIGHTING);
  glLightfv(GL_LIGHT0, GL_AMBIENT, vmml::vec4f::ZERO.array);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, vmml::vec4f::ONE.array);
  glLightfv(GL_LIGHT0, GL_SPECULAR, vmml::vec4f::ONE.array);
  glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0);
  glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.3);
  glEnable(GL_LIGHT0);

  glEnable(GL_COLOR_MATERIAL);
  glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, vmml::vec4f::ONE.array);
  glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 128);

  glEnable(GL_CULL_FACE);
  glFrontFace(GL_CCW);

  Shader::loadProgram("default.vert", "default.frag");

  loadLevel("level.xml");
  triangles.insert(triangles.end(), level->getRooms().front().walls.begin(), level->getRooms().front().walls.end());
  std::sort(triangles.begin(), triangles.end(), Renderer::TextureSorter());
}

bool Game::loadLevel(const std::string &name) {
  level = Level::loadLevel(name);

  return level;
}

void Game::run(int delta) {
  angle += delta*0.01;

  if(angle >= 360)
    angle -= 360;

  lightPos += delta;
  lightPos %= 24000;
}

void Game::render() {
  int i;
  float light[] = {0, 0, 0, 1};

  if(lightPos < 12000) i = lightPos;
  else i = 24000 - lightPos;

  if(i < 4000) {
    light[0] = 0.0;
    light[2] = -i * 0.001;
  }
  else if(i < 8000) {
    light[0] = (i-4000) * 0.001;
    light[2] = -4.0;
  }
  else if(i < 12000) {
    light[0] = 4.0;
    light[2] = -4.0 - (i-8000) * 0.001;
  }
  else {
    light[0] = 4.0;
    light[2] = -8.0;
  }

  /*std::vector<BSPTree::TriangleRecord> triangles(level->getRooms().front().walls.begin(),
      level->getRooms().front().walls.end());
  std::sort(triangles.begin(), triangles.end(), Renderer::TextureSorter());*/

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();
  glRotatef(15, 1, 2, 1);
  /*glRotatef(5*angle, 0, -1, 2);
  glRotatef(7*angle, 2, -1, 0);
  glRotatef(11*angle, 2, -1, 2);*/

  glLightfv(GL_LIGHT0, GL_POSITION, light);
  //renderer.render(std::list<BSPTree::TriangleRecord>(triangles.begin(), triangles.end()));
  renderer.render(triangles);

  glPopMatrix();
}

}