Changeset 8255 in orxonox.OLD for trunk/src/lib/graphics/effects

Timestamp:

Jun 8, 2006, 3:44:12 PM (18 years ago)

Author:

bensch

Message:

merged the atmos back with command: ​https://svn.orxonox.net/orxonox/branches/atmospheric_engine

Location:

trunk/src/lib/graphics/effects

Files:

• cloud_effect.cc (modified) (6 diffs)
• cloud_effect.h (modified) (2 diffs)
• fog_effect.cc (modified) (6 diffs)
• fog_effect.h (modified) (1 diff)
• lightening_effect.cc (modified) (8 diffs)
• lightening_effect.h (modified) (2 diffs)
• rain_effect.cc (modified) (12 diffs)
• rain_effect.h (modified) (3 diffs)
• sglmodel.h (copied) (copied from branches/atmospheric_engine/src/lib/graphics/effects/sglmodel.h)
• sky.sgl (copied) (copied from branches/atmospheric_engine/src/lib/graphics/effects/sky.sgl)
• snow_effect.cc (modified) (8 diffs)
• snow_effect.h (modified) (2 diffs)
• weather_effect.cc (modified) (1 diff)

trunk/src/lib/graphics/effects/cloud_effect.cc

@@ -11 +11 @@
 ### File Specific:
         main-programmer: hdavid, amaechler
+
+        INSPIRED BY http://www.codesampler.com/usersrc/usersrc_6.htm#oglu_sky_dome_shader
 */
 
@@ -17 +19 @@
 #include "util/loading/load_param.h"
 #include "util/loading/factory.h"
+#include "util/loading/resource_manager.h"
 
 #include "glincl.h"
-//#include "graphics_engine.h"
+#include "material.h"
 #include <math.h>
+#include "state.h"
+#include "p_node.h"
+#include "shader.h"
+#include "shell_command.h"
 
 #include "parser/tinyxml/tinyxml.h"
 
+#include "sglmodel.h"
+
 using namespace std;
+
+SHELL_COMMAND(activate, CloudEffect, activateCloud);
+SHELL_COMMAND(deactivate, CloudEffect, deactivateCloud);
 
 CREATE_FACTORY(CloudEffect, CL_CLOUD_EFFECT);
@@ -37 +49 @@
                 this->loadParams(root);
 
-        this->activate();
+        if(cloudActivate)
+                this->activate();
 }
 
@@ -43 +56 @@
 {
         this->deactivate();
-}
+
+        delete this->cloudMaterial;
+
+        cloudModel.Delete();
+        Shader::unload(this->cloudShader);
+
+}
+
+
+bool CloudEffect::init()
+{
+        PRINTF(1)("Initializing CloudEffect\n");
+
+        // Default values
+        this->cloudActivate = false;
+        this->cloudTint[4] = ( 0.9f, 0.7f, 0.7f, 1.0f );
+        this->cloudScroll = 1.0f;
+        this->time = 0.0f;
+        //g_cloud_texture = 0;
+
+        this->cloudTexture = "pictures/sky/cloud1.jpg";
+
+        cloudModel.Load("sky.sgl");
+        cloudModel.Unitize();
+
+        // Get the bounding box of the sky dome
+        float bbox[3] = {0};
+        cloudModel.GetDimensions(bbox[0], bbox[1], bbox[2]);
+        
+        // Load Shaders
+        this->cloudShader = 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->cloudShader->bindShader("bbox", bbox, 4);
+
+        // Initialze Cloud Material
+        this->cloudMaterial = new Material("Sky");
+        this->cloudMaterial->setIllum(3);
+        this->cloudMaterial->setAmbient(1.0, 1.0, 1.0);
+        this->cloudMaterial->setDiffuseMap(this->cloudTexture);
+
+}
+
 
 void CloudEffect::loadParams(const TiXmlElement* root)
@@ -49 +104 @@
         WeatherEffect::loadParams(root);
 
-        LoadParam(root, "animSpeed", this, CloudEffect, setCloudAnimation);
-
-}
-
-
-bool CloudEffect::init()
-{
-        // default values
-        this->cloudAnimTimeStep = 0;
-
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
-        // Generate noise map a
-        CloudEffect::genNoiseMap(cloudMap32_a);
-        
-        if (this->cloudAnimTimeStep > 0) {
-                // Generate noise map b
-                CloudEffect::genNoiseMap(cloudMap32_b);
+        // LoadParam(root, "speed", this, CloudEffect, setCloudAnimation);
+        // LoadParam(root, "texture", this, CloudEffect, setCloudTexture);
+
+        LOAD_PARAM_START_CYCLE(root, element);
+        {
+                LoadParam_CYCLE(element, "option", this, CloudEffect, setCloudOption);
         }
-}
+        LOAD_PARAM_END_CYCLE(element);
+}
+
 
 bool CloudEffect::activate()
 {
-        PRINTF(0)( "Activating CloudEffect\n");
-        if (this->cloudAnimTimeStep == 0) {
-                for (int i = 0; i < 32*32; i++)
-                        cloudMap32_c[i] = cloudMap32_a[i];
-
-                CloudEffect::overlapOctaves();
-                CloudEffect::expFilter();
-                CloudEffect::genCloudTexture();
-        }
+        PRINTF(0)( "Activating CloudEffect with Material %s\n", this->cloudTexture.c_str());
+
+        this->cloudActivate = true;
+        
 }
 
@@ -89 +126 @@
 {
         PRINTF(0)("Deactivating CloudEffect\n");
-}
-
-void CloudEffect::genCloudTexture() {
-        for(int i=0; i<256; i++)
-                for(int j=0; j<256; j++) 
-                {
-                        float color = cloudMap256[i*256+j]; 
-                        cloudTexture[i][j][0] = (char) color;
-                        cloudTexture[i][j][1] = (char) color;
-                        cloudTexture[i][j][2] = (char) color;
-                }
-
-        glGenTextures(2, &texID[0]);
-        glBindTexture(GL_TEXTURE_2D, texID[0]);
-        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, cloudTexture);
-}
-
-void CloudEffect::calcAnimMap(float timer) {
-
-        for (int x=0; x<32*32; x++)
-                cloudMap32_c[x] = (cloudMap32_a[x] * ((this->cloudAnimTimeStep - timer) / this->cloudAnimTimeStep)) + (cloudMap32_b[x] * (timer / this->cloudAnimTimeStep));
-
+
+        this->cloudActivate = false;
 }
 
 void CloudEffect::draw() const
 {
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
+        if (!this->cloudActivate)
+                return;
+                
+        //      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();
-        glEnable(GL_TEXTURE_2D);
-
-        glBindTexture(GL_TEXTURE_2D, texID[0]);
-
-        // FIXME : Bind this to the sky - how do I do this?
-        glBegin(GL_QUADS);
-                glTexCoord2f(0.0f, 0.0f); glVertex3f(20, 20,  60);      // Bottom Left Of The Texture and Quad
-                glTexCoord2f(1.0f, 0.0f); glVertex3f(60, 20,  60);      // Bottom Right Of The Texture and Quad
-                glTexCoord2f(1.0f, 1.0f); glVertex3f(60, 60,  60);      // Top Right Of The Texture and Quad
-                glTexCoord2f(0.0f, 1.0f); glVertex3f(20, 60,  60);      // Top Left Of The Texture and Quad
-        glEnd(); 
+
+        // 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);
+
+        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->cloudShader->activateShader();
+
+        /* Select the shader program and update parameters. */
+        /* The "time" parameter controls the cloud scrolling. */
+        this->cloudShader->bindShader("time", &time, 1);
+        /* The "horizon" parameter controls the sky tinting. */
+        this->cloudShader->bindShader("horizon", cloudTint, 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
+        cloudModel.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)
 {
-        if (this->cloudAnimTimeStep > 0) {
-                if (timer >= this->cloudAnimTimeStep) {
-                        timer -= this->cloudAnimTimeStep;
-                        for (int i = 0; i < 32*32; i++)
-                                cloudMap32_a[i] = cloudMap32_b[i];
-                        CloudEffect::genNoiseMap(cloudMap32_b);
-                }
-
-                //map32anim = (map32a * (10 - timer)) + (map32b * timer);
-                CloudEffect::calcAnimMap(timer);
-
-                CloudEffect::overlapOctaves();
-                CloudEffect::expFilter();
-                CloudEffect::genCloudTexture();
-
-                timer += dt;
-        }
-}
-
-/* 
-        Random noise generator
-*/
-float CloudEffect::noise(int x, int y, int random)
-{
-                int n = x + y * 57 + random * 131;
-                n = (n<<13) ^ n;
-                return (1.0f - ( (n * (n * n * 15731 + 789221) +
-                                                1376312589)&0x7fffffff)* 0.000000000931322574615478515625f);
-}
-
-/*
-        Set noise for the 32*32 noise map:
-*/
-void CloudEffect::genNoiseMap(float  *map)
-{
-        float temp[34][34];
-
-        int random = rand() % 5000;
-
-        for (int y = 1; y < 33; y++)
-                for (int x = 1; x < 33; x++)
-                        temp[x][y] = 128.0f + CloudEffect::noise(x,  y,  random) * 128.0f;
-
-        // Seamless cloud
-        for (int x=1; x<33; x++)
-        {
-                temp[0][x] = temp[32][x];
-                temp[33][x] = temp[1][x];
-                temp[x][0] = temp[x][32];
-                temp[x][33] = temp[x][1];
-        }
-        temp[0][0] = temp[32][32];
-        temp[33][33] = temp[1][1];
-        temp[0][33] = temp[32][1];
-        temp[33][0] = temp[1][32];
-
-        // We mirror the side and corner elements so our final cloud will be seamless without any ugly borders showing.
-        for (int y=1; y<33; y++)
-                for (int x=1; x<33; x++)
-                {
-                        float center = temp[x][y]/4.0f;
-                        float sides = (temp[x+1][y] + temp[x-1][y] + temp[x][y+1] + temp[x][y-1])/8.0f;
-                        float corners = (temp[x+1][y+1] + temp[x+1][y-1] + temp[x-1][y+1] + temp[x-1][y-1])/16.0f;
-
-                        map[((x-1)*32) + (y-1)] = center + sides + corners;
-                }
-}
-
-/*
-        Interpolation - average the value of each pixel value with that of its neighbors' values.
-*/
-float CloudEffect::interpolate(float x, float y, float  *map)
-{
-        int Xint = (int)x;
-        int Yint = (int)y;
-
-        float Xfrac = x - Xint;
-        float Yfrac = y - Yint;
-
-        int X0 = Xint % 32;
-        int Y0 = Yint % 32;
-        int X1 = (Xint + 1) % 32;
-        int Y1 = (Yint + 1) % 32;
-
-        float bot = map[X0*32 + Y0] + Xfrac * (map[X1*32 + Y0] - map[X0*32 + Y0]);
-        float top = map[X0*32 + Y1] + Xfrac * (map[X1*32 +  Y1] - map[X0*32 + Y1]);
-
-        return (bot + Yfrac * (top - bot));
-}
-
-
-/*
-        Octaves are overlapped together to give cloud more turbulence. We will use four octaves for our cloud.
-*/
-void CloudEffect::overlapOctaves()
-{
-        for (int x=0; x<256*256; x++)
-        {
-                cloudMap256[x] = 0;
-        }
-
-        for (int octave=0; octave<4; octave++)
-                for (int x=0; x<256; x++)
-                        for (int y=0; y<256; y++)
-                        {
-                                float scale = 1 / pow(2.0f, (float) 3-octave);
-                                float noise = CloudEffect::interpolate(x*scale, y*scale , cloudMap32_c);
-
-                                //The octaves are added together with the proper weight factors.
-                                //You could replace pow(2, i) with 1<<i for faster computation
-                                cloudMap256[(y*256) + x] += noise / pow(2.0f, (float) octave);
-                        }
-}
-
-
-/*
-        Filter the noise with exponential function
-*/
-void CloudEffect::expFilter()
-{
-        float cover = 20.0f;
-        float sharpness = 0.95f;
-
-        for (int x=0; x<256*256; x++)
-        {
-                float c = cloudMap256[x] - (255.0f-cover);
-                if (c<0)     c = 0;
-                cloudMap256[x] = 255.0f - ((float)(pow(sharpness, c))*255.0f);
-        }
-}
-
-
+        if (!this->cloudActivate)
+                return;
+
+        // Update the timer for scrolling the clouds
+        time = time + ((1.0f / 2000.0f) * cloudScroll);
+}
+

trunk/src/lib/graphics/effects/cloud_effect.h

@@ -6 +6 @@
 #define _CLOUD_EFFECT
 
-#include "vector.h"
-#include "vector2D.h"
-
 #include "weather_effect.h"
 
 #include "sound_buffer.h"
 #include "sound_source.h"
+
+#include "world_entity.h"
+#include "glincl.h"
+
+#include "sglmodel.h"
+
+class Shader;
+class Material;
+class Vector;
 
 class CloudEffect : public WeatherEffect
@@ -27 +33 @@
                 virtual bool deactivate();
 
+                inline void activateCloud() { this->activate(); }
+                inline void deactivateCloud() { this->deactivate(); }
+                
                 virtual void draw() const;
                 virtual void tick(float dt);
 
-                inline void setCloudAnimation(float timestep) { this->cloudAnimTimeStep = timestep; }
+                inline void setCloudOption(const std::string& option) {
+                        if (option == "activate") this->cloudActivate = true;
+                }
+
 
         private:
-                // Basic noise maps 32x32
-                float                                                                                                           cloudMap32_a[32 * 32];
-                float                                                                                                           cloudMap32_b[32 * 32];
-                float                                                                                                           cloudMap32_c[32 * 32];
+                void initialize(char* fileName);
 
-                // The cloud map 256x256
-                float                                                                                                           cloudMap256[256 * 256];
+                bool                            cloudActivate;
 
-                // Temporary array to hold texture RGB values 
-                char                                                                                                                    cloudTexture[256][256][3];
+                Material*                       cloudMaterial;          // A Material for the Sphere.
 
-                GLuint                                                                                                          texID[2];
-                float                                                                                                           timer;
+                std::string                     cloudTexture;
 
-                bool                                                                                                                    cloudAnimTimeStep;
+                Sglmodel_sgl                    cloudModel;
+                Shader*                         cloudShader;
 
-                float                                                                                                           noise(int x, int y, int random);
-                float                                                                                                           interpolate(float x, float y, float  *map);
-                void                                                                                                            overlapOctaves();
-                void                                                                                                            expFilter();
+                GLfloat                         cloudTint[4];
+                GLfloat                         cloudScroll;
 
-                void                                                                                                            genNoiseMap(float  *map);
-                void                                                                                                            genCloudTexture();
-                void                                                                                                            calcAnimMap(float timer);
+                float                           time;
 
 };

trunk/src/lib/graphics/effects/fog_effect.cc

@@ -20 +20 @@
 #include "glincl.h"
 
-/*#include "shell_command.h"
-SHELL_COMMAND(activateFog, FogEffect, FogEffect::activate)
-        ->setAlias("aFog");
-SHELL_COMMAND(deactivateFog, FogEffect, FogEffect::deactivate)
-        ->setAlias("dFog");*/
+#include "shell_command.h"
+
+SHELL_COMMAND(activate, FogEffect, activateFog);
+SHELL_COMMAND(deactivate, FogEffect, deactivateFog);
+SHELL_COMMAND(startfogging, FogEffect, startFogging);
 
 using namespace std;
@@ -39 +39 @@
                 this->loadParams(root);
 
-        this->activate();
+        if (this->fogActivate)
+                this->activate();
 }
 
@@ -57 +58 @@
         LoadParam(root, "range", this, FogEffect, setFogRange);
         LoadParam(root, "color", this, FogEffect, setFogColor);
+
+        LOAD_PARAM_START_CYCLE(root, element);
+        {
+                LoadParam_CYCLE(element, "option", this, FogEffect, setFogOption);
+        }
+        LOAD_PARAM_END_CYCLE(element);
 }
 
@@ -62 +69 @@
 {
         //default values
+        this->fogActivate = false;
+        this->fogFadeDuration = 0;
+        this->localTimer = 0;
+        
         this->fogMode = GL_EXP2;
         this->fogDensity = 0.001;
         this->fogStart = 0;
         this->fogEnd = 5000;
-  this->colorVector = Vector(0.7, 0.7, 0.7);
+        this->colorVector = Vector(0.7, 0.7, 0.7);
+
 }
-
 
 
@@ -75 +86 @@
         PRINTF(0)( "Enabling FogEffect, mode: %i, density: %f, start: %f, end: %f, color %f, %f, %f\n", this->fogMode, this->fogDensity, this->fogStart, this->fogEnd, this->colorVector.x, this->colorVector.y, this->colorVector.z);
 
+        this->fogActivate = true;
+        
+        GLfloat fogColor[4] = { colorVector.x, colorVector.y, colorVector.z, 1.0};
+        glFogi(GL_FOG_MODE, this->fogMode);
+        glFogfv(GL_FOG_COLOR, fogColor);
+        glFogf(GL_FOG_DENSITY, this->fogDensity);
+        glHint(GL_FOG_HINT, GL_DONT_CARE);
+        glFogf(GL_FOG_START, this->fogStart);
+        glFogf(GL_FOG_END, this->fogEnd);
+        
         glEnable(GL_FOG);
-        {
-                GLfloat fogColor[4] = { colorVector.x, colorVector.y, colorVector.z, 1.0};
-
-                glFogi(GL_FOG_MODE, this->fogMode);
-                glFogfv(GL_FOG_COLOR, fogColor);
-                glFogf(GL_FOG_DENSITY, this->fogDensity);
-                glHint(GL_FOG_HINT, GL_DONT_CARE);
-                glFogf(GL_FOG_START, this->fogStart);
-                glFogf(GL_FOG_END, this->fogEnd);
-        }
-        glClearColor(0.5, 0.5, 0.5, 1.0);
+        // glClearColor(0.5, 0.5, 0.5, 1.0);
 }
 
@@ -93 +104 @@
 {
         PRINTF(0)("Deactivating FogEffect\n");
+
+        this->fogActivate = false;
+        
         glDisable(GL_FOG);
+}
+
+void FogEffect::draw() const {
+
+        if (this->fogFadeDuration != 0 && this->localTimer < this->fogFadeDuration)
+                glFogf(GL_FOG_DENSITY, this->fogFadeDensity);
+        //else
+        //      glFogf(GL_FOG_DENSITY, this->fogDensity);
+
+}
+void FogEffect::tick(float dt)
+{
+        if (!this->fogActivate)
+                return;
+                
+
+        if (this->fogFadeDuration != 0 && this->localTimer < this->fogFadeDuration) {
+                this->localTimer += dt;
+                float progress = this->localTimer / this->fogFadeDuration;
+                this->fogFadeDensity = progress * this->fogDensity;
+        }
+}
+
+void FogEffect::startFogging() {
+
+        if (this->fogActivate)
+                this->deactivate();
+
+        this->fogFadeDuration = 10;
+        this->localTimer = 0;
+        this->activate();
+
 }
 

trunk/src/lib/graphics/effects/fog_effect.h

@@ -23 +23 @@
                 virtual bool deactivate();
 
+                void activateFog() { this->activate(); }
+                void deactivateFog() { this->deactivate(); }
+
+                virtual void draw() const;
+                virtual void tick(float dt);
+
                 inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
                 inline void setFogDensity(float density) { this->fogDensity = density; }
                 inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
                 inline void setFogColor(float r, float g, float b) { this->colorVector = Vector(r, g, b); }
+                inline void setFogOption(const std::string& option) { if (option == "activate") this->fogActivate = true; }
+
+                void startFogging();
 
         private:
                 GLint stringToFogMode(const std::string& mode);
 
-        private:
-                GLint                   fogMode;
-                GLfloat                 fogDensity;
-                GLfloat                 fogStart;
-                GLfloat                 fogEnd;
-                Vector                  colorVector;
+                bool                            fogActivate;
+                GLfloat                         fogFadeDuration;
+                float                           localTimer;
+                
+                GLint                           fogMode;
+                GLfloat                         fogDensity;
+                GLfloat                         fogFadeDensity;
+
+                GLfloat                         fogStart;
+                GLfloat                         fogEnd;
+                Vector                          colorVector;
 };
 

trunk/src/lib/graphics/effects/lightening_effect.cc

@@ -18 +18 @@
 #include "util/loading/load_param.h"
 #include "util/loading/factory.h"
-#include "render2D/image_plane.h"
+#include "effects/billboard.h"
 
 #include "glincl.h"
 #include "parser/tinyxml/tinyxml.h"
 
+#include "shell_command.h"
+#include "light.h"
+
+SHELL_COMMAND(activate, LighteningEffect, activateLightening);
+SHELL_COMMAND(deactivate, LighteningEffect, deactivateLightening);
+
 using namespace std;
 
@@ -30 +36 @@
 {
         this->setClassID(CL_LIGHTENING_EFFECT, "LighteningEffect");
-  
-  
-  lightening = new ImagePlane(NULL);
-  lightening->setTexture("maps/lightning_bolt.png");
-  lightening->setSize(50, 50);
-  lightening->setAbsCoor2D(10,10);
-  lightening->setVisibility(true);
-  
   
         this->init();
@@ -44 +42 @@
                 this->loadParams(root);
 
-        this->activate();
+  if(this->lighteningActivate)
+         this->activate();
 }
 
@@ -50 +49 @@
 {
         this->deactivate();
-  delete lightening;
 }
 
@@ -56 +54 @@
 {
         WeatherEffect::loadParams(root);
+  
+  LoadParam(root, "coord", this, LighteningEffect, coord);
+  LoadParam(root, "option", this, LighteningEffect, setLighteningOption);
+  LoadParam(root, "frequency", this, LighteningEffect, setFlashFrequency);
+  LoadParam(root, "const-time", this, LighteningEffect, setFlashConstTime);
+  LoadParam(root, "rising-time", this, LighteningEffect, setFlashRisingTime);
+  LoadParam(root, "size", this, LighteningEffect, setFlashSize);
+  LoadParam(root, "seed", this, LighteningEffect, setFlashSeed);
 }
 
@@ -61 +67 @@
 bool LighteningEffect::init()
 {
-        //Default values
+  lighteningActivate = false;
+  
+  this->time = 0.0;
+  this->flashFrequency = 1.4f;
+  this->flashConstTime = 0.5f;
+  this->flashRisingTime = 0.1f;
+
+  this->width = 400.0f;
+  this->height = 100.0f;
+  this->seedWidth = 50;
+  this->seedHeight = 50;
+  this->bNewCoordinate = false;
+
+  this->seedX = 500.f;
+  this->seedZ = 1000.0f;
+  this->seedTime = 4.0f;
+
+  this->billboard[0] = new Billboard(NULL);
+  this->billboard[0]->setTexture("maps/lightning_bolt1.png");
+  this->billboard[0]->setSize(this->width, this->height);
+  this->billboard[0]->setAbsCoor(3000,850,0);
+  this->billboard[0]->setVisibiliy(false);
+
+  this->billboard[1] = new Billboard(NULL);
+  this->billboard[1]->setTexture("maps/lightning_bolt2.png");
+  this->billboard[1]->setSize(this->width, this->height);
+  this->billboard[1]->setAbsCoor(3000,850,0);
+  this->billboard[1]->setVisibiliy(false);
+
+  this->billboard[2] = new Billboard(NULL);
+  this->billboard[2]->setTexture("maps/lightning_bolt3.png");
+  this->billboard[2]->setSize(this->width, this->height);
+  this->billboard[2]->setAbsCoor(3000,850,0);
+  this->billboard[2]->setVisibiliy(false);
+
+  this->billboard[3] = new Billboard(NULL);
+  this->billboard[3]->setTexture("maps/lightning_bolt4.png");
+  this->billboard[3]->setSize(this->width, this->height);
+  this->billboard[3]->setAbsCoor(0.0f, 50.0f, 0.0f);
+  this->billboard[3]->setVisibiliy(false);
+/*
+  this->soundSource = NULL;
+  this->thunderBuffer = NULL;
+
+  this->soundSource.setSourceNode(this);
+
+  //load sound
+  if (this->thunderBuffer != NULL)
+    ResourceManager::getInstance()->unload(this->thunderBuffer);
+  this->thunderBuffer = (OrxSound::SoundBuffer*)ResourceManager::getInstance()->load("sound/thunder.wav", WAV);*/
+}
+
+void LighteningEffect::coord(float x, float y, float z)
+{
+  this->billboard[0]->setAbsCoor(x, y, z);
+  this->billboard[1]->setAbsCoor(x, y, z);
+  this->billboard[2]->setAbsCoor(x, y, z);
+  this->billboard[3]->setAbsCoor(x, y, z);
+  this->mainPosX = x;
+  this->mainPosY = y;
+  this->mainPosZ = z;
+}
+
+
+void LighteningEffect::setFlashSize(float width, float height, float seedWidth, float seedHeight)
+{
+  this->width = width;
+  this->height = height;
+  this->seedWidth = seedWidth;
+  this->seedHeight = seedHeight;
+  this->billboard[0]->setSize(this->width, this->height);
+  this->billboard[1]->setSize(this->width, this->height);
+  this->billboard[2]->setSize(this->width, this->height);
+  this->billboard[3]->setSize(this->width, this->height);
 }
 
@@ -68 +147 @@
 {
         PRINTF(0)( "Activating LighteningEffect\n" );
-
+  this->time = 0;
+  lighteningActivate = true;
 }
 
@@ -75 +155 @@
 {
         PRINTF(0)("Deactivating LighteningEffect\n");
+  this->billboard[0]->setVisibiliy(false);
+  this->billboard[1]->setVisibiliy(false);
+  this->billboard[2]->setVisibiliy(false);
+  this->billboard[3]->setVisibiliy(false);
+  lighteningActivate = false;
 }
 
 void LighteningEffect::tick (float dt)
 {
-
-}
+  if(!lighteningActivate)
+    return;
+  
+  this->time += dt;
+
+  /*if( flashLight != NULL)
+  {
+    if((int)(100*time)%2)
+      this->flashLight->setDiffuseColor(0,0,0);
+    else
+      this->flashLight->setDiffuseColor(100,100,100);
+    
+    //PRINTF(0)("100*time: %f %i\n", 100*time, (int)(100*time));
+}*/
+  
+  if( this->time > this->flashFrequency)
+  {
+    this->billboard[0]->setVisibiliy(true);
+    this->time = 0.0f;
+    
+    this->flashLight = new Light();
+    this->flashLight->setAbsCoor(this->billboard[0]->getAbsCoor().x, this->billboard[0]->getAbsCoor().y, this->billboard[0]->getAbsCoor().z);
+    this->flashLight->setDiffuseColor(100,100,100);
+    
+    //this->soundSource.play(this->thunderBuffer);
+  }
+  else if( this->billboard[3]->isVisible() && this->time > this->flashConstTime)
+  {
+    this->billboard[3]->setVisibiliy(false);
+    this->time = 0.0f;
+    this->bNewCoordinate = true;
+    
+    if(flashLight != NULL)
+    {
+      delete this->flashLight;
+      flashLight = NULL;
+    }
+  }
+
+  if( this->billboard[2]->isVisible() && this->time > this->flashRisingTime)
+  {
+    this->billboard[2]->setVisibiliy(false);
+    this->billboard[3]->setVisibiliy(true);
+    this->flashLight->setDiffuseColor(100,100,100);
+  }
+  else if( this->billboard[1]->isVisible() && this->time > this->flashRisingTime*2/3 )
+  {
+    this->billboard[1]->setVisibiliy(false);
+    this->billboard[2]->setVisibiliy(true);
+    this->flashLight->setDiffuseColor(0,0,0);
+  }
+  else if( this->billboard[0]->isVisible() && this->time > this->flashRisingTime*1/3 )
+  {
+    this->billboard[0]->setVisibiliy(false);
+    this->billboard[1]->setVisibiliy(true);
+    this->flashLight->setDiffuseColor(100,100,100);
+  }
+
+  if( this->bNewCoordinate)
+  {
+    float posX = this->mainPosX - this->seedX * (float)rand()/(float)RAND_MAX;
+    float posZ = this->mainPosZ + this->seedZ * (float)rand()/(float)RAND_MAX;
+    this->billboard[0]->setAbsCoor(posX, this->mainPosY, posZ);
+    this->billboard[1]->setAbsCoor(posX, this->mainPosY, posZ);
+    this->billboard[2]->setAbsCoor(posX, this->mainPosY, posZ);
+    this->billboard[3]->setAbsCoor(posX, this->mainPosY, posZ);
+    this->bNewCoordinate = false;
+  }
+}
+
+void LighteningEffect::draw() const
+{
+}

trunk/src/lib/graphics/effects/lightening_effect.h

@@ -15 +15 @@
 
 
-class ImagePlane;
+class Billboard;
+class Light;
 
 class LighteningEffect : public WeatherEffect
@@ -30 +31 @@
                 virtual bool deactivate();
 
-                virtual void tick(float dt);
+    virtual void draw() const;
+    virtual void tick(float dt);
+    
+    void coord(float x, float y, float z);
+    void setFlashSize(float width, float height, float seedWidth, float seedHeight);
+    
+    inline void setLighteningOption(const std::string& option) { if (option == "activate") this->lighteningActivate = true;}
+    inline void setFlashFrequency(float flashFrequency) { this->flashFrequency = flashFrequency; }
+    inline void setFlashConstTime(float flashConstTime) { this->flashConstTime = flashConstTime; }
+    inline void setFlashRisingTime(float flashRisingTime) { if(flashRisingTime > this->flashConstTime)
+                                                                                        this->flashRisingTime = this->flashConstTime/2;
+                                                                                      else
+                                                                                        this->flashRisingTime = flashRisingTime; }
+    inline void setFlashSeed(float seedX, float seedZ, float seedTime) { this->seedX = seedX;
+                                                                                                         this->seedZ = seedZ;
+                                                                                                         this->seedTime = seedTime; }
 
+    void activateLightening() { this->activate(); }
+    void deactivateLightening() { this->deactivate(); }
+    
         private:
-    ImagePlane* lightening;
+    Billboard* billboard[4];
+    bool lighteningActivate;
+
+    float flashFrequency;
+    float flashConstTime;
+    float flashRisingTime;
+
+    float time;
+
+    bool  bNewCoordinate;
+    float width;
+    float height;
+    float seedWidth;
+    float seedHeight;
+
+    float seedX;
+    float seedZ;
+    float seedTime;
+    
+    float mainPosX;
+    float mainPosY;
+    float mainPosZ;
+
+    Light* flashLight;
+    
+    //OrxSound::SoundSource    soundSource;
+    //OrxSound::SoundBuffer*   thunderBuffer;
 
 };

trunk/src/lib/graphics/effects/rain_effect.cc

@@ -1 +1 @@
 /*
-   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.
+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
+main-programmer: hdavid, amaechler
 */
 
@@ -25 +25 @@
 #include "plane_emitter.h"
 #include "shell_command.h"
+#include "light.h"
 
 #include "parser/tinyxml/tinyxml.h"
@@ -31 +32 @@
 SHELL_COMMAND(deactivate, RainEffect, deactivateRain);
 
+SHELL_COMMAND(startRaining, RainEffect, startRaining);
+
 using namespace std;
 
 CREATE_FACTORY(RainEffect, CL_RAIN_EFFECT);
+
+// TODO: Dim Light with Rain, Finish preCaching, check out if multiple rain emitters work,  Think about what happens with building poss. to hang movewithcam off, benchmark, possible to activate lightening, turn off visibility when in a building, variable emitter size depending on playable, also rain velocity
 
 RainEffect::RainEffect(const TiXmlElement* root)
@@ -50 +55 @@
 
         //load wind sound
-        if (this->rainWindForce > 0) {
+        if (this->rainWindForce != 0) {
                 if (this->windBuffer != NULL)
                         ResourceManager::getInstance()->unload(this->windBuffer);
@@ -56 +61 @@
         }
 
-        this->activate();
+        if(rainActivate)
+                this->activate();
 }
 
@@ -80 +86 @@
         LoadParam(root, "life", this, RainEffect, setRainLife);
         LoadParam(root, "wind", this, RainEffect, setRainWind);
-        LoadParam(root, "option", this, RainEffect, setRainOption);
+        LoadParam(root, "startraining", this, RainEffect, setRainStart);
+
+        LOAD_PARAM_START_CYCLE(root, element);
+        {
+                LoadParam_CYCLE(element, "option", this, RainEffect, setRainOption);
+        }
+        LOAD_PARAM_END_CYCLE(element);
+
 }
 
@@ -87 +100 @@
 {
         //Default values
+        this->rainActivate = false;
+        this->rainMove = false;
         this->rainCoord = Vector(500, 500, 500);
         this->rainSize = Vector2D(1000, 1000);
@@ -94 +109 @@
         this->rainMaxParticles = this->rainRate * this->rainLife;
         this->rainWindForce  = 0;
+        this->rainStartDuration = 0;
+        this->localTimer = 0;
+        this->soundRainVolume = 0.8f;
 
         this->emitter = new PlaneEmitter(this->rainSize);
+
+        lightMan = LightManager::getInstance();
+        this->rainAmbient = lightMan->getAmbientColor();
 }
 
@@ -104 +125 @@
 {
         PRINTF(0)( "Activating RainEffect, coord: %f, %f, %f, size: %f, %f, rate: %f, velocity: %f, moveRain: %s\n", this->rainCoord.x, this->rainCoord.y, this->rainCoord.z, this->rainSize.x, this-> rainSize.y, this->rainRate, this->rainVelocity, this->rainMove ? "true" : "false" );
+
+        this->rainActivate = true;
 
         if (unlikely(RainEffect::rainParticles == NULL))
@@ -114 +137 @@
                 RainEffect::rainParticles->setRadius(0.2, 0.02);
                 RainEffect::rainParticles->setRadius(1, 0.01);
-                RainEffect::rainParticles->setColor(0, 0.3, 0.3, 0.5, 0.2); // grey blue 1
-                RainEffect::rainParticles->setColor(0.5, 0.4, 0.4, 0.5, 0.2); // grey blue 2
-                RainEffect::rainParticles->setColor(1, 0.7, 0.7, 0.7, 0.2); // light grey
+                RainEffect::rainParticles->setColor(0, 0.3, 0.3, 0.5, 0.2);     // grey blue 1
+                RainEffect::rainParticles->setColor(0.5, 0.4, 0.4, 0.5, 0.2);   // grey blue 2
+                RainEffect::rainParticles->setColor(1, 0.7, 0.7, 0.7, 0.2);     // light grey
         }
 
@@ -128 +151 @@
         this->emitter->setSpread(this->rainWindForce / 50, 0.2);
         
-        this->soundSource.loop(this->rainBuffer);
-        if (this->rainWindForce > 0)
-                this->soundSource.loop(this->windBuffer);
+        this->soundSource.loop(this->rainBuffer, this->soundRainVolume);
+        if (this->rainWindForce != 0) this->soundSource.loop(this->windBuffer, 0.1f * this->rainWindForce);
+
+        lightMan->setAmbientColor(.1,.1,.1);
 }
 
@@ -137 +161 @@
 {
         PRINTF(0)("Deactivating RainEffect\n");
+        
+        this->rainActivate = false;
         this->emitter->setSystem(NULL);
 
+        // Stop Sound
         this->soundSource.stop();
-}
-
-void RainEffect::activateRain()
-{
-        this->activate();
-}
-
-void RainEffect::deactivateRain()
-{
-        this->deactivate();
-}
-
+
+        // Restore Light Ambient
+        lightMan->setAmbientColor(this->rainAmbient, this->rainAmbient, this->rainAmbient);
+}
 
 void RainEffect::tick (float dt)
 {
+        if (!this->rainActivate)
+                return;
+                
         if (this->rainMove) {
                 this->rainCoord = State::getCameraNode()->getAbsCoor();
                 this->emitter->setRelCoor(this->rainCoord.x , this->rainCoord.y+800, this->rainCoord.z);
         }
-}
+
+        if (this->rainStartDuration != 0 && this->localTimer < this->rainStartDuration) {
+                this->localTimer += dt;
+                float progress = this->localTimer / this->rainStartDuration;
+
+                // Dim Light
+                lightMan->setAmbientColor(1.1 - progress, 1.1 - progress, 1.1 - progress);
+
+                // use alpha in color to fade in
+                RainEffect::rainParticles->setColor(0,   0.3, 0.3, 0.5, 0.2 * progress); // grey blue 1
+                RainEffect::rainParticles->setColor(0.5, 0.4, 0.4, 0.5, 0.2 * progress); // grey blue 2
+                RainEffect::rainParticles->setColor(1,   0.7, 0.7, 0.7, 0.2 * progress); // light grey
+
+                // increase radius for more "heavy" rain
+                RainEffect::rainParticles->setRadius(0, 0.03 * progress);
+                RainEffect::rainParticles->setRadius(0.2, 0.02 * progress);
+                RainEffect::rainParticles->setRadius(1, 0.01 * progress);
+
+                // increase sound volume
+                // this->soundSource.fadein(this->rainBuffer, 10);
+        }
+        
+}
+
+void RainEffect::startRaining() {
+
+        if (this->rainActivate)
+                this->deactivate();
+
+        this->rainStartDuration = 10;
+        this->localTimer = 0;
+        this->activate();
+
+}

trunk/src/lib/graphics/effects/rain_effect.h

@@ -14 +14 @@
 class SparkParticles;
 class PlainEmitter;
+class LightManager;
 
 #include "weather_effect.h"
@@ -34 +35 @@
                 virtual bool deactivate();
 
-                void activateRain();
-                void deactivateRain();
+                virtual void tick(float dt);
 
-                virtual void tick(float dt);
+                inline void activateRain() { this->activate(); }
+                inline void deactivateRain() { this->deactivate(); }
+                void startRaining();
 
                 inline void setRainCoord(float x, float y, float z) { this->rainCoord = Vector(x, y, z); }
@@ -45 +47 @@
                 inline void setRainLife(float life) { this->rainLife = life; }
                 inline void setRainWind(int force) { this->rainWindForce = force; }
-                inline void setRainOption(const std::string& option) { if (option == "moverain") this->rainMove = true; }
+                inline void setRainStart(float duration) { this->rainStartDuration = duration; }
+
+                inline void setRainOption(const std::string& option) {
+                        if (option == "moverain") this->rainMove = true;
+                        if (option == "activate") this->rainActivate = true;
+                }
 
 
         private:
-                static SparkParticles*                                          rainParticles;
-                ParticleEmitter*                                                                        emitter;
+                static SparkParticles*                  rainParticles;
+                ParticleEmitter*                        emitter;
 
-                Vector                                                                                                          rainCoord;
-                Vector2D                                                                                                        rainSize;
-                GLfloat                                                                                                         rainRate;
-                GLfloat                                                                                                         rainVelocity;
-                GLfloat                                                                                                         rainLife;
-                GLfloat                                                                                                         rainMaxParticles;
-                int                                                                                                                             rainWindForce;
-                bool                                                                                                                    rainMove;
+                float                                   localTimer;
+
+                Vector                                  rainCoord;
+                Vector2D                                rainSize;
+                GLfloat                                 rainRate;
+                GLfloat                                 rainVelocity;
+                GLfloat                                 rainLife;
+                GLfloat                                 rainMaxParticles;
+                int                                     rainWindForce;
+                GLfloat                                 rainStartDuration;
+                bool                                    rainMove;
+                bool                                    rainActivate;
 
                 OrxSound::SoundSource                   soundSource;
                 OrxSound::SoundBuffer*                  rainBuffer;
                 OrxSound::SoundBuffer*                  windBuffer;
+
+                float                                   soundRainVolume;
+
+                LightManager*                           lightMan;
+                GLfloat                                 rainAmbient;
+
 };
 
-
 #endif  /* _RAIN_EFFECT */

trunk/src/lib/graphics/effects/snow_effect.cc

@@ -53 +53 @@
         }
 
-        this->activate();
+        if(snowActivate)
+                this->activate();
 }
 
@@ -75 +76 @@
         LoadParam(root, "emissionRate", this, SnowEffect, emissionRate);
         LoadParam(root, "emissionVelocity", this, SnowEffect, emissionVelocity);
-  LoadParam(root, "wind", this, SnowEffect, wind);
+        LoadParam(root, "wind", this, SnowEffect, wind);
         LoadParam(root, "size", this, SnowEffect, size);
         LoadParam(root, "coord", this, SnowEffect, coord);
+  
+        LOAD_PARAM_START_CYCLE(root, element);
+        {
+                LoadParam_CYCLE(element, "option", this, SnowEffect, setSnowOption);
+        }
+        LOAD_PARAM_END_CYCLE(element);
 }
 
@@ -85 +92 @@
 
         // Default values
+        this->snowActivate = false;
+        this->snowMove = false;
         this->particles = 12000;
         this->texture = "maps/snow_flake_01_32x32.png";
@@ -100 +109 @@
         this->alpha = 0.5;
         this->snowSize = Vector2D(2500, 2500);
-  this->snowCoord = Vector(100,450,400);
+        this->snowCoord = Vector(100,450,400);
         this->snowWindForce = 1;
-
-        this->activated = false;
 }
 
@@ -109 +116 @@
 {
         PRINTF(0)("Activating SnowEffect\n");
-        activated = true;
+
+        this->snowActivate = true;
 
         SnowEffect::snowParticles = new SpriteParticles(particles);
@@ -131 +139 @@
         this->emitter->setSize(snowSize);
 
-  //SnowEffect::snowParticles->precache(8);
+        // SnowEffect::snowParticles->precache(8);
 
         if (this->snowWindForce > 1)
@@ -141 +149 @@
 {
         PRINTF(0)("Deactivating SnowEffect\n");
-        activated = false;
-
+
+        this->snowActivate = false;
         this->emitter->setSystem(NULL);
 
@@ -150 +158 @@
 }
 
-void SnowEffect::activateSnow()
-{
+void SnowEffect::draw() const
+{
+        if (!this->snowActivate)
+                return;
+}
+
+void SnowEffect::tick(float dt)
+{
+        if (!this->snowActivate)
+                return;
+
+        /*
+        float distance = (State::getCameraNode()->getAbsCoor() - Vector(snowCoord.x, State::getCameraNode()->getAbsCoor().y, snowCoord.z)).len();
+        
+        if(activated)
+        {
+        if(distance > 0.3*snowSize.x || distance > 0.3*snowSize.y)
+                        this->deactivate();
+        else if(distance > 0.25*snowSize.x || distance > 0.25*snowSize.y)
+        this->alpha = 0.15;
+        else if(distance > 0.2*snowSize.x || distance > 0.2*snowSize.y)
+        this->alpha = 0.25;
+        else if(distance > 0.1*snowSize.x || distance > 0.1*snowSize.y)
+        this->alpha = 0.4;
+        
+        SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
+        SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
+        SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
+        }
+        else
+        {
+        if(distance < 0.3*snowSize.x || distance < 0.3*snowSize.y )
         this->activate();
-}
-
-void SnowEffect::deactivateSnow()
-{
-        this->deactivate();
-}
-
-void SnowEffect::draw() const
-{
-}
-
-void SnowEffect::tick(float dt)
-{
-  float distance = (State::getCameraNode()->getAbsCoor() - Vector(snowCoord.x, State::getCameraNode()->getAbsCoor().y, snowCoord.z)).len();
-  
-  if(activated)
-  {
-    if(distance > 0.3*snowSize.x || distance > 0.3*snowSize.y)
-                  this->deactivate();
-    else if(distance > 0.25*snowSize.x || distance > 0.25*snowSize.y) 
-      this->alpha = 0.15;
-    else if(distance > 0.2*snowSize.x || distance > 0.2*snowSize.y) 
-      this->alpha = 0.25;
-    else if(distance > 0.1*snowSize.x || distance > 0.1*snowSize.y) 
-      this->alpha = 0.4;
-
-    SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
-    SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
-    SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
-  }
-  else
-  {
-  if(distance < 0.3*snowSize.x || distance < 0.3*snowSize.y )
-    this->activate();
-  if( distance < 0.25*snowSize.x || distance < 0.25*snowSize.y )
-    this->alpha = 0.25;
-  else if( distance < 0.2*snowSize.x || distance < 0.2*snowSize.y )
-    this->alpha = 0.4;
-  else if( distance < 0.1*snowSize.x || distance < 0.1*snowSize.y )
-    this->alpha = 0.5;
-
-    SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
-    SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
-    SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
-  }
-}
-
+        if( distance < 0.25*snowSize.x || distance < 0.25*snowSize.y )
+        this->alpha = 0.25;
+        else if( distance < 0.2*snowSize.x || distance < 0.2*snowSize.y )
+        this->alpha = 0.4;
+        else if( distance < 0.1*snowSize.x || distance < 0.1*snowSize.y )
+        this->alpha = 0.5;
+        
+        SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
+        SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
+        SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
+        }*/
+
+        if (this->snowMove) {
+                this->snowCoord = State::getCameraNode()->getAbsCoor();
+                this->emitter->setRelCoor(this->snowCoord.x , this->snowCoord.y+300, this->snowCoord.z);
+        }
+}

trunk/src/lib/graphics/effects/snow_effect.h

@@ -33 +33 @@
                 virtual bool deactivate();
 
+                inline void activateSnow() { this->activate(); }
+                inline void deactivateSnow() { this->deactivate(); }
+                
                 virtual void draw() const;
                 virtual void tick(float dt);
 
-                void activateSnow();
-                void deactivateSnow();
 
                 inline void numParticles(int n) { this->particles = n; }
@@ -48 +49 @@
                 inline void size(float sizeX, float sizeY) { this->snowSize = Vector2D(sizeX, sizeY); }
                 inline void coord(float x, float y, float z) { this->snowCoord = Vector(x, y, z); }
-    inline void wind(int force) { this->snowWindForce = force; }
+                inline void wind(int force) { this->snowWindForce = force; }
+
+                inline void setSnowOption(const std::string& option) {
+                        /*if (option == "fade") this->snowFade = true;*/
+                        if (option == "movesnow") this->snowMove = true;
+                        if (option == "activate") this->snowActivate = true;
+                }
 
 
         private:
-                int                                                                                                                             particles;
-                std::string                                                                                             texture;
-                float                                                                                                                   life, randomLife;
-                float                                                                                                                           snowRadius, randomRadius;
-                float                                                                                                                           snowMass, randomMass;
-                float                                                                                                                   rate;
-                float                                                                                                                   velocity, randomVelocity;
-                float                                                                                                                   angle, randomAngle;
-                float                                                                                                                   alpha;
-                Vector                                                                                                                  snowCoord;
-                Vector2D                                                                                                                snowSize;
-                int                                                                                                                                     snowWindForce;
+                int                             particles;
+                std::string                     texture;
+                float                           life, randomLife;
+                float                           snowRadius, randomRadius;
+                float                           snowMass, randomMass;
+                float                           rate;
+                float                           velocity, randomVelocity;
+                float                           angle, randomAngle;
+                float                           alpha;
+                Vector                          snowCoord;
+                Vector2D                        snowSize;
+                int                             snowWindForce;
 
-                bool                                                                                                                            activated;
+                bool                            snowMove;
+                bool                            snowActivate;
 
-                PlaneEmitter*                                                                                           emitter;
+                PlaneEmitter*                   emitter;
 
-                static SpriteParticles*                                                 snowParticles;
-                OrxSound::SoundSource              soundSource;
-                OrxSound::SoundBuffer*             windBuffer;
+                static SpriteParticles*         snowParticles;
+                OrxSound::SoundSource           soundSource;
+                OrxSound::SoundBuffer*          windBuffer;
 
 };

trunk/src/lib/graphics/effects/weather_effect.cc

@@ -15 +15 @@
 */
 
+// TODO: descriptions to loadparams, movealong unified, start activation
 
 #include "weather_effect.h"