/*
 * 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 "gl.h"
#include "BSPTree.h"
#include "Level.h"
#include "Shader.h"
#include "ShadowVolume.h"
#include "Triangle.h"

#include <algorithm>

namespace Zoom {

Game::Game() : playerPos(vmml::vec3f::ZERO), playerRotY(vmml::mat4f::IDENTITY), playerRotX(0),
    input(0), lightPos(0) {
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_STENCIL_TEST);

  glEnable(GL_BLEND);

  glEnable(GL_MULTISAMPLE_ARB);

  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vmml::vec4f(0.1, 0.1, 0.1, 1).array);

  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_QUADRATIC_ATTENUATION, 0.2);

  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);

  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::resize(int width, int height) {
  if(height == 0) {
    height = 1;
  }


  glMatrixMode(GL_PROJECTION);
  glLoadMatrixf(MathUtil::perspective(50.0f, (float)width/(float)height, 0.1).array);

  glMatrixMode(GL_MODELVIEW);

  glViewport(0, 0, width, height);
}

void Game::turn(float x, float y) {
  playerRotY.rotate_y(-x*M_PI/180/10);

  playerRotX -= y*M_PI/180/10;
  if(playerRotX > M_PI_2)
    playerRotX = M_PI_2;
  else if(playerRotX < -M_PI_2)
    playerRotX = -M_PI_2;
}

void Game::run(int delta) {
  lightPos += delta;
  lightPos %= 24000;

  vmml::vec3f playerMove(vmml::vec3f::ZERO);

  if(input & FORWARD) {
    playerMove -= playerRotY*vmml::vec3f::UNIT_Z;
  }
  if(input & BACKWARD) {
    playerMove += playerRotY*vmml::vec3f::UNIT_Z;
  }
  if(input & LEFT) {
    playerMove -= playerRotY*vmml::vec3f::UNIT_X;
  }
  if(input & RIGHT) {
    playerMove += playerRotY*vmml::vec3f::UNIT_X;
  }

  playerMove.normalize();
  playerPos += playerMove*0.01*delta;
}

void Game::render() {
  int i;
  vmml::vec3f light(vmml::vec3f::ZERO);

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

  if(i < 4000) {
    light.x() = 0.0;
    light.z() = -i * 0.001;
  }
  else if(i < 8000) {
    light.x() = (i-4000) * 0.001;
    light.z() = -4.0;
  }
  else if(i < 12000) {
    light.x() = 4.0;
    light.z() = -4.0 - (i-8000) * 0.001;
  }
  else {
    light.x() = 4.0;
    light.z() = -8.0;
  }

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

  vmml::mat4f transform(playerRotY), inverse;
  transform.rotate_x(playerRotX);
  transform.set_translation(playerPos);
  transform.inverse(inverse);

  glLoadMatrixf(inverse.array);

  renderer.render(triangles, light);

  Shader::disable();
  glDepthMask(GL_FALSE);
  glBlendFunc(GL_ONE, GL_ONE);
  glBlendEquation(GL_FUNC_ADD);
  glDepthFunc(GL_GREATER);
  glColor3f(0.05, 0.05, 0.05);
  glFrontFace(GL_CCW);

  glBegin(GL_TRIANGLES);
  for(std::vector<BSPTree::TriangleRecord>::iterator t = triangles.begin(); t != triangles.end(); ++t) {
    ShadowVolume v(t->triangle, light);
    v.render();
  }
  glEnd();

  glFrontFace(GL_CW);
  glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);

  glBegin(GL_TRIANGLES);
  for(std::vector<BSPTree::TriangleRecord>::iterator t = triangles.begin(); t != triangles.end(); ++t) {
    ShadowVolume v(t->triangle, light);
    v.render();
  }
  glEnd();

  glFrontFace(GL_CCW);
  glDepthMask(GL_TRUE);
  glDepthFunc(GL_LEQUAL);
  glBlendEquation(GL_FUNC_ADD);
}

}