source: orxonox.OLD/branches/atmospheric_engine/src/lib/graphics/effects/cloud_effect.cc @ 8223

/*
        orxonox - the future of 3D-vertical-scrollers

        Copyright (C) 2004 orx

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2, or (at your option)
        any later version.

### File Specific:
        main-programmer: hdavid, amaechler

        INSPIRED BY http://www.codesampler.com/usersrc/usersrc_6.htm#oglu_sky_dome_shader
*/

#include "cloud_effect.h"

#include "util/loading/load_param.h"
#include "util/loading/factory.h"
#include "util/loading/resource_manager.h"

#include "glincl.h"
#include "material.h"
#include <math.h>
#include "state.h"
#include "p_node.h"
#include "shader.h"

#include "parser/tinyxml/tinyxml.h"

#include "sglmodel.h"

using namespace std;

CREATE_FACTORY(CloudEffect, CL_CLOUD_EFFECT);

CloudEffect::CloudEffect(const TiXmlElement* root)
{
        this->setClassID(CL_CLOUD_EFFECT, "CloudEffect");

        this->init();

        if (root != NULL)
                this->loadParams(root);

        this->activate();
}

CloudEffect::~CloudEffect()
{
        this->deactivate();

        delete this->cloudMaterial;

        g_sky_model.Delete();
        Shader::unload(this->skyShader);

}


bool CloudEffect::init()
{
        PRINTF(1)("Initializing CloudEffect\n");

        // glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        glShadeModel(GL_SMOOTH);
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
        glCullFace(GL_BACK);
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
        
        glLineWidth(3.0f);
        
        float diffuse[]  = {1.0f, 1.0f, 1.0f, 1.0f};
        float position[] = {0.0f, 2.0f, 0.0f, 1.0f};
        float specular[] = {1.0f, 1.0f, 1.0f, 1.0f};
        
        glEnable(GL_LIGHTING);
        glEnable( GL_LIGHT0);
        glLightfv(GL_LIGHT0, GL_DIFFUSE,  diffuse);
        glLightfv(GL_LIGHT0, GL_POSITION, position);
        glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
        
        float shininess = 5.0f;
        glEnable(GL_COLOR_MATERIAL);
        glMaterialf( GL_FRONT, GL_SHININESS, shininess);
        glMaterialfv(GL_FRONT, GL_SPECULAR,  specular);

        this->cloudTexture = "pictures/sky/cloud1.jpg";

        g_sky_model.Load("sky.sgl");
        g_sky_model.Unitize();

        /* Get the bounding box of the sky dome. */
        float bbox[3] = {0};
        g_sky_model.GetDimensions(bbox[0], bbox[1], bbox[2]);
        
        // this->skyShader = (Shader*)ResourceManager::getInstance()->load("shaders/sky.vert", SHADER, RP_GAME, "shaders/skyfrag");
        this->skyShader = new Shader( ResourceManager::getInstance()->getDataDir() + "/shaders/sky.vert", ResourceManager::getInstance()->getDataDir() +"/shaders/sky.frag");

        /* Tell the shader the bounding box of the sky dome. */
        this->skyShader->bindShader("bbox", bbox, 4);

        //g_cloud_texture = 0;

        g_tint[4] = ( 0.9f, 0.7f, 0.7f, 1.0f );
        g_scroll = 1.0f;
        time = 0.0f;
}


void CloudEffect::loadParams(const TiXmlElement* root)
{
        WeatherEffect::loadParams(root);

        LoadParam(root, "speed", this, CloudEffect, setCloudAnimation);
        LoadParam(root, "texture", this, CloudEffect, setCloudTexture);
}


bool CloudEffect::activate()
{
        PRINTF(0)( "Activating CloudEffect with Material %s\n", this->cloudTexture.c_str());

        this->cloudMaterial = new Material("Sky");
        this->cloudMaterial->setIllum(3);
        this->cloudMaterial->setAmbient(1.0, 1.0, 1.0);
        this->cloudMaterial->setDiffuseMap(this->cloudTexture);
}

bool CloudEffect::deactivate()
{
        PRINTF(0)("Deactivating CloudEffect\n");
}

void CloudEffect::draw() const
{

//      glMatrixMode(GL_MODELVIEW);
//      glPushMatrix();
// 
//      // Move sphere along with the camera
//      Vector r = State::getCameraNode()->getAbsCoor();
//      glTranslatef(r.x, r.y, r.z);
// 
//      // Sky movement
//      glRotatef(mover, 0, 0, 1);
// 
//      cloudMaterial->select();
//      gluSphere(this->sphereObj, this->sphereRadius, 20, 20);
//      glPopMatrix();

        // ******

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();

        static float time = 0.0f;
        // static vector3f eye = {0.0f, 0.0f, 0.0f}, look = {0.0f, 0.0f, 1.0f}, up = {0.0f, 1.0f, 0.0f};

        // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // glLoadIdentity();
        // gluLookAt(eye[x], eye[y], eye[z], look[x], look[y], look[z], up[x], up[y], up[z]);

        /* Turn off the depth buffer when rendering the background. */
        // glDisable(GL_DEPTH_TEST);

        this->skyShader->activateShader();

        /* Select the shader program and update parameters. */
        /* The "time" parameter controls the cloud scrolling. */
        this->skyShader->bindShader("time", &time, 1);
        /* The "horizon" parameter controls the sky tinting. */
        this->skyShader->bindShader("horizon", g_tint, 4);
        
        glActiveTexture(GL_TEXTURE0 + 0);
        glActiveTexture(GL_TEXTURE0 + 1);
        /* Load the cloud texture. */
        //glBindTexture(GL_TEXTURE_2D, g_cloud_texture);
        this->cloudMaterial->select();
        
        /* Render the sky dome. */
        g_sky_model.Render();
        
        /* Unselect the shader. */
        Shader::deactivateShader();

        /* Turn on the depth buffer when rendering the foreground. */
        // glEnable(GL_DEPTH_TEST);

        /* Render the forground, for example, a teapot or bunny. */
        //    glEnable(GL_LIGHTING);
        //    glColor3f(0.0f, 1.0f, 0.0f);
        //    glBegin(GL_QUADS);
        //    glNormal3f( 0.0f,  1.0f,  0.0f);
        //    glVertex3f( 20.0f, -1.0f,  20.0f);
        //    glVertex3f( 20.0f, -1.0f, -20.0f);
        //    glVertex3f(-20.0f, -1.0f, -20.0f);
        //    glVertex3f(-20.0f, -1.0f,  20.0f);
        //    glEnd();
        //    glDisable(GL_LIGHTING);

        glPopMatrix();
}

void CloudEffect::tick (float dt)
{
        // mover = mover + this->cloudSpeed * dt;

        /* Update the timer for scrolling the clouds. */
        time = time + ((1.0f / 2000.0f) * g_scroll);
}