Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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


Ignore:
Timestamp:
Jun 8, 2006, 3:44:12 PM (19 years ago)
Author:
bensch
Message:

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

Location:
trunk/src/lib/graphics
Files:
14 edited
2 copied

Legend:

Unmodified
Added
Removed

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

    r7810 r8255  
    1111### File Specific:
    1212        main-programmer: hdavid, amaechler
     13
     14        INSPIRED BY http://www.codesampler.com/usersrc/usersrc_6.htm#oglu_sky_dome_shader
    1315*/
    1416
    … …  
    1719#include "util/loading/load_param.h"
    1820#include "util/loading/factory.h"
     21#include "util/loading/resource_manager.h"
    1922
    2023#include "glincl.h"
    21 //#include "graphics_engine.h"
     24#include "material.h"
    2225#include <math.h>
     26#include "state.h"
     27#include "p_node.h"
     28#include "shader.h"
     29#include "shell_command.h"
    2330
    2431#include "parser/tinyxml/tinyxml.h"
    2532
     33#include "sglmodel.h"
     34
    2635using namespace std;
     36
     37SHELL_COMMAND(activate, CloudEffect, activateCloud);
     38SHELL_COMMAND(deactivate, CloudEffect, deactivateCloud);
    2739
    2840CREATE_FACTORY(CloudEffect, CL_CLOUD_EFFECT);
    … …  
    3749                this->loadParams(root);
    3850
    39         this->activate();
     51        if(cloudActivate)
     52                this->activate();
    4053}
    4154
    … …  
    4356{
    4457        this->deactivate();
    45 }
     58
     59        delete this->cloudMaterial;
     60
     61        cloudModel.Delete();
     62        Shader::unload(this->cloudShader);
     63
     64}
     65
     66
     67bool CloudEffect::init()
     68{
     69        PRINTF(1)("Initializing CloudEffect\n");
     70
     71        // Default values
     72        this->cloudActivate = false;
     73        this->cloudTint[4] = ( 0.9f, 0.7f, 0.7f, 1.0f );
     74        this->cloudScroll = 1.0f;
     75        this->time = 0.0f;
     76        //g_cloud_texture = 0;
     77
     78        this->cloudTexture = "pictures/sky/cloud1.jpg";
     79
     80        cloudModel.Load("sky.sgl");
     81        cloudModel.Unitize();
     82
     83        // Get the bounding box of the sky dome
     84        float bbox[3] = {0};
     85        cloudModel.GetDimensions(bbox[0], bbox[1], bbox[2]);
     86       
     87        // Load Shaders
     88        this->cloudShader = new Shader( ResourceManager::getInstance()->getDataDir() + "/shaders/sky.vert", ResourceManager::getInstance()->getDataDir() +"/shaders/sky.frag");
     89
     90        // Tell the shader the bounding box of the sky dome
     91        this->cloudShader->bindShader("bbox", bbox, 4);
     92
     93        // Initialze Cloud Material
     94        this->cloudMaterial = new Material("Sky");
     95        this->cloudMaterial->setIllum(3);
     96        this->cloudMaterial->setAmbient(1.0, 1.0, 1.0);
     97        this->cloudMaterial->setDiffuseMap(this->cloudTexture);
     98
     99}
     100
    46101
    47102void CloudEffect::loadParams(const TiXmlElement* root)
    … …  
    49104        WeatherEffect::loadParams(root);
    50105
    51         LoadParam(root, "animSpeed", this, CloudEffect, setCloudAnimation);
    52 
    53 }
    54 
    55 
    56 bool CloudEffect::init()
    57 {
    58         // default values
    59         this->cloudAnimTimeStep = 0;
    60 
    61         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    62         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    63         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    64         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    65 
    66         // Generate noise map a
    67         CloudEffect::genNoiseMap(cloudMap32_a);
    68        
    69         if (this->cloudAnimTimeStep > 0) {
    70                 // Generate noise map b
    71                 CloudEffect::genNoiseMap(cloudMap32_b);
     106        // LoadParam(root, "speed", this, CloudEffect, setCloudAnimation);
     107        // LoadParam(root, "texture", this, CloudEffect, setCloudTexture);
     108
     109        LOAD_PARAM_START_CYCLE(root, element);
     110        {
     111                LoadParam_CYCLE(element, "option", this, CloudEffect, setCloudOption);
    72112        }
    73 }
     113        LOAD_PARAM_END_CYCLE(element);
     114}
     115
    74116
    75117bool CloudEffect::activate()
    76118{
    77         PRINTF(0)( "Activating CloudEffect\n");
    78         if (this->cloudAnimTimeStep == 0) {
    79                 for (int i = 0; i < 32*32; i++)
    80                         cloudMap32_c[i] = cloudMap32_a[i];
    81 
    82                 CloudEffect::overlapOctaves();
    83                 CloudEffect::expFilter();
    84                 CloudEffect::genCloudTexture();
    85         }
     119        PRINTF(0)( "Activating CloudEffect with Material %s\n", this->cloudTexture.c_str());
     120
     121        this->cloudActivate = true;
     122       
    86123}
    87124
    … …  
    89126{
    90127        PRINTF(0)("Deactivating CloudEffect\n");
    91 }
    92 
    93 void CloudEffect::genCloudTexture() {
    94         for(int i=0; i<256; i++)
    95                 for(int j=0; j<256; j++)
    96                 {
    97                         float color = cloudMap256[i*256+j];
    98                         cloudTexture[i][j][0] = (char) color;
    99                         cloudTexture[i][j][1] = (char) color;
    100                         cloudTexture[i][j][2] = (char) color;
    101                 }
    102 
    103         glGenTextures(2, &texID[0]);
    104         glBindTexture(GL_TEXTURE_2D, texID[0]);
    105         gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, cloudTexture);
    106 }
    107 
    108 void CloudEffect::calcAnimMap(float timer) {
    109 
    110         for (int x=0; x<32*32; x++)
    111                 cloudMap32_c[x] = (cloudMap32_a[x] * ((this->cloudAnimTimeStep - timer) / this->cloudAnimTimeStep)) + (cloudMap32_b[x] * (timer / this->cloudAnimTimeStep));
    112 
     128
     129        this->cloudActivate = false;
    113130}
    114131
    115132void CloudEffect::draw() const
    116133{
    117         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    118 
     134        if (!this->cloudActivate)
     135                return;
     136               
     137        //      glMatrixMode(GL_MODELVIEW);
     138        //      glPushMatrix();
     139        //
     140        //      // Move sphere along with the camera
     141        //      Vector r = State::getCameraNode()->getAbsCoor();
     142        //      glTranslatef(r.x, r.y, r.z);
     143        //
     144        //      // Sky movement
     145        //      glRotatef(mover, 0, 0, 1);
     146        //
     147        //      cloudMaterial->select();
     148        //      gluSphere(this->sphereObj, this->sphereRadius, 20, 20);
     149        //      glPopMatrix();
     150
     151        // ******
     152
     153        glMatrixMode(GL_MODELVIEW);
    119154        glPushMatrix();
    120         glEnable(GL_TEXTURE_2D);
    121 
    122         glBindTexture(GL_TEXTURE_2D, texID[0]);
    123 
    124         // FIXME : Bind this to the sky - how do I do this?
    125         glBegin(GL_QUADS);
    126                 glTexCoord2f(0.0f, 0.0f); glVertex3f(20, 20,  60);      // Bottom Left Of The Texture and Quad
    127                 glTexCoord2f(1.0f, 0.0f); glVertex3f(60, 20,  60);      // Bottom Right Of The Texture and Quad
    128                 glTexCoord2f(1.0f, 1.0f); glVertex3f(60, 60,  60);      // Top Right Of The Texture and Quad
    129                 glTexCoord2f(0.0f, 1.0f); glVertex3f(20, 60,  60);      // Top Left Of The Texture and Quad
    130         glEnd();
     155
     156        // glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     157        // glShadeModel(GL_SMOOTH);
     158        // glEnable(GL_DEPTH_TEST);
     159        // glEnable(GL_CULL_FACE);
     160        // glCullFace(GL_BACK);
     161        // glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
     162       
     163        // glLineWidth(3.0f);
     164
     165        static float time = 0.0f;
     166        // static vector3f eye = {0.0f, 0.0f, 0.0f}, look = {0.0f, 0.0f, 1.0f}, up = {0.0f, 1.0f, 0.0f};
     167
     168        // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     169        // glLoadIdentity();
     170        // gluLookAt(eye[x], eye[y], eye[z], look[x], look[y], look[z], up[x], up[y], up[z]);
     171
     172        // Turn off the depth buffer when rendering the background
     173        // glDisable(GL_DEPTH_TEST);
     174
     175        this->cloudShader->activateShader();
     176
     177        /* Select the shader program and update parameters. */
     178        /* The "time" parameter controls the cloud scrolling. */
     179        this->cloudShader->bindShader("time", &time, 1);
     180        /* The "horizon" parameter controls the sky tinting. */
     181        this->cloudShader->bindShader("horizon", cloudTint, 4);
     182
     183        glActiveTexture(GL_TEXTURE0 + 0);
     184        glActiveTexture(GL_TEXTURE0 + 1);
     185
     186        // Load the cloud texture
     187        //glBindTexture(GL_TEXTURE_2D, g_cloud_texture);
     188        this->cloudMaterial->select();
     189
     190        // Render the sky dome
     191        cloudModel.Render();
     192
     193        // Unselect the shader
     194        Shader::deactivateShader();
     195
     196        /* Turn on the depth buffer when rendering the foreground. */
     197        // glEnable(GL_DEPTH_TEST);
     198
     199        /* Render the forground, for example, a teapot or bunny. */
     200        //    glEnable(GL_LIGHTING);
     201        //    glColor3f(0.0f, 1.0f, 0.0f);
     202        //    glBegin(GL_QUADS);
     203        //    glNormal3f( 0.0f,  1.0f,  0.0f);
     204        //    glVertex3f( 20.0f, -1.0f,  20.0f);
     205        //    glVertex3f( 20.0f, -1.0f, -20.0f);
     206        //    glVertex3f(-20.0f, -1.0f, -20.0f);
     207        //    glVertex3f(-20.0f, -1.0f,  20.0f);
     208        //    glEnd();
     209        //    glDisable(GL_LIGHTING);
    131210
    132211        glPopMatrix();
     212       
    133213}
    134214
    135215void CloudEffect::tick (float dt)
    136216{
    137         if (this->cloudAnimTimeStep > 0) {
    138                 if (timer >= this->cloudAnimTimeStep) {
    139                         timer -= this->cloudAnimTimeStep;
    140                         for (int i = 0; i < 32*32; i++)
    141                                 cloudMap32_a[i] = cloudMap32_b[i];
    142                         CloudEffect::genNoiseMap(cloudMap32_b);
    143                 }
    144 
    145                 //map32anim = (map32a * (10 - timer)) + (map32b * timer);
    146                 CloudEffect::calcAnimMap(timer);
    147 
    148                 CloudEffect::overlapOctaves();
    149                 CloudEffect::expFilter();
    150                 CloudEffect::genCloudTexture();
    151 
    152                 timer += dt;
    153         }
    154 }
    155 
    156 /*
    157         Random noise generator
    158 */
    159 float CloudEffect::noise(int x, int y, int random)
    160 {
    161                 int n = x + y * 57 + random * 131;
    162                 n = (n<<13) ^ n;
    163                 return (1.0f - ( (n * (n * n * 15731 + 789221) +
    164                                                 1376312589)&0x7fffffff)* 0.000000000931322574615478515625f);
    165 }
    166 
    167 /*
    168         Set noise for the 32*32 noise map:
    169 */
    170 void CloudEffect::genNoiseMap(float  *map)
    171 {
    172         float temp[34][34];
    173 
    174         int random = rand() % 5000;
    175 
    176         for (int y = 1; y < 33; y++)
    177                 for (int x = 1; x < 33; x++)
    178                         temp[x][y] = 128.0f + CloudEffect::noise(x,  y,  random) * 128.0f;
    179 
    180         // Seamless cloud
    181         for (int x=1; x<33; x++)
    182         {
    183                 temp[0][x] = temp[32][x];
    184                 temp[33][x] = temp[1][x];
    185                 temp[x][0] = temp[x][32];
    186                 temp[x][33] = temp[x][1];
    187         }
    188         temp[0][0] = temp[32][32];
    189         temp[33][33] = temp[1][1];
    190         temp[0][33] = temp[32][1];
    191         temp[33][0] = temp[1][32];
    192 
    193         // We mirror the side and corner elements so our final cloud will be seamless without any ugly borders showing.
    194         for (int y=1; y<33; y++)
    195                 for (int x=1; x<33; x++)
    196                 {
    197                         float center = temp[x][y]/4.0f;
    198                         float sides = (temp[x+1][y] + temp[x-1][y] + temp[x][y+1] + temp[x][y-1])/8.0f;
    199                         float corners = (temp[x+1][y+1] + temp[x+1][y-1] + temp[x-1][y+1] + temp[x-1][y-1])/16.0f;
    200 
    201                         map[((x-1)*32) + (y-1)] = center + sides + corners;
    202                 }
    203 }
    204 
    205 /*
    206         Interpolation - average the value of each pixel value with that of its neighbors' values.
    207 */
    208 float CloudEffect::interpolate(float x, float y, float  *map)
    209 {
    210         int Xint = (int)x;
    211         int Yint = (int)y;
    212 
    213         float Xfrac = x - Xint;
    214         float Yfrac = y - Yint;
    215 
    216         int X0 = Xint % 32;
    217         int Y0 = Yint % 32;
    218         int X1 = (Xint + 1) % 32;
    219         int Y1 = (Yint + 1) % 32;
    220 
    221         float bot = map[X0*32 + Y0] + Xfrac * (map[X1*32 + Y0] - map[X0*32 + Y0]);
    222         float top = map[X0*32 + Y1] + Xfrac * (map[X1*32 +  Y1] - map[X0*32 + Y1]);
    223 
    224         return (bot + Yfrac * (top - bot));
    225 }
    226 
    227 
    228 /*
    229         Octaves are overlapped together to give cloud more turbulence. We will use four octaves for our cloud.
    230 */
    231 void CloudEffect::overlapOctaves()
    232 {
    233         for (int x=0; x<256*256; x++)
    234         {
    235                 cloudMap256[x] = 0;
    236         }
    237 
    238         for (int octave=0; octave<4; octave++)
    239                 for (int x=0; x<256; x++)
    240                         for (int y=0; y<256; y++)
    241                         {
    242                                 float scale = 1 / pow(2.0f, (float) 3-octave);
    243                                 float noise = CloudEffect::interpolate(x*scale, y*scale , cloudMap32_c);
    244 
    245                                 //The octaves are added together with the proper weight factors.
    246                                 //You could replace pow(2, i) with 1<<i for faster computation
    247                                 cloudMap256[(y*256) + x] += noise / pow(2.0f, (float) octave);
    248                         }
    249 }
    250 
    251 
    252 /*
    253         Filter the noise with exponential function
    254 */
    255 void CloudEffect::expFilter()
    256 {
    257         float cover = 20.0f;
    258         float sharpness = 0.95f;
    259 
    260         for (int x=0; x<256*256; x++)
    261         {
    262                 float c = cloudMap256[x] - (255.0f-cover);
    263                 if (c<0)     c = 0;
    264                 cloudMap256[x] = 255.0f - ((float)(pow(sharpness, c))*255.0f);
    265         }
    266 }
    267 
    268 
     217        if (!this->cloudActivate)
     218                return;
     219
     220        // Update the timer for scrolling the clouds
     221        time = time + ((1.0f / 2000.0f) * cloudScroll);
     222}
     223

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

    r7810 r8255  
    66#define _CLOUD_EFFECT
    77
    8 #include "vector.h"
    9 #include "vector2D.h"
    10 
    118#include "weather_effect.h"
    129
    1310#include "sound_buffer.h"
    1411#include "sound_source.h"
     12
     13#include "world_entity.h"
     14#include "glincl.h"
     15
     16#include "sglmodel.h"
     17
     18class Shader;
     19class Material;
     20class Vector;
    1521
    1622class CloudEffect : public WeatherEffect
    … …  
    2733                virtual bool deactivate();
    2834
     35                inline void activateCloud() { this->activate(); }
     36                inline void deactivateCloud() { this->deactivate(); }
     37               
    2938                virtual void draw() const;
    3039                virtual void tick(float dt);
    3140
    32                 inline void setCloudAnimation(float timestep) { this->cloudAnimTimeStep = timestep; }
     41                inline void setCloudOption(const std::string& option) {
     42                        if (option == "activate") this->cloudActivate = true;
     43                }
     44
    3345
    3446        private:
    35                 // Basic noise maps 32x32
    36                 float                                                                                                           cloudMap32_a[32 * 32];
    37                 float                                                                                                           cloudMap32_b[32 * 32];
    38                 float                                                                                                           cloudMap32_c[32 * 32];
     47                void initialize(char* fileName);
    3948
    40                 // The cloud map 256x256
    41                 float                                                                                                           cloudMap256[256 * 256];
     49                bool                            cloudActivate;
    4250
    43                 // Temporary array to hold texture RGB values
    44                 char                                                                                                                    cloudTexture[256][256][3];
     51                Material*                       cloudMaterial;          // A Material for the Sphere.
    4552
    46                 GLuint                                                                                                          texID[2];
    47                 float                                                                                                           timer;
     53                std::string                     cloudTexture;
    4854
    49                 bool                                                                                                                    cloudAnimTimeStep;
     55                Sglmodel_sgl                    cloudModel;
     56                Shader*                         cloudShader;
    5057
    51                 float                                                                                                           noise(int x, int y, int random);
    52                 float                                                                                                           interpolate(float x, float y, float  *map);
    53                 void                                                                                                            overlapOctaves();
    54                 void                                                                                                            expFilter();
     58                GLfloat                         cloudTint[4];
     59                GLfloat                         cloudScroll;
    5560
    56                 void                                                                                                            genNoiseMap(float  *map);
    57                 void                                                                                                            genCloudTexture();
    58                 void                                                                                                            calcAnimMap(float timer);
     61                float                           time;
    5962
    6063};

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

    r7810 r8255  
    2020#include "glincl.h"
    2121
    22 /*#include "shell_command.h"
    23 SHELL_COMMAND(activateFog, FogEffect, FogEffect::activate)
    24         ->setAlias("aFog");
    25 SHELL_COMMAND(deactivateFog, FogEffect, FogEffect::deactivate)
    26         ->setAlias("dFog");*/
     22#include "shell_command.h"
     23
     24SHELL_COMMAND(activate, FogEffect, activateFog);
     25SHELL_COMMAND(deactivate, FogEffect, deactivateFog);
     26SHELL_COMMAND(startfogging, FogEffect, startFogging);
    2727
    2828using namespace std;
    … …  
    3939                this->loadParams(root);
    4040
    41         this->activate();
     41        if (this->fogActivate)
     42                this->activate();
    4243}
    4344
    … …  
    5758        LoadParam(root, "range", this, FogEffect, setFogRange);
    5859        LoadParam(root, "color", this, FogEffect, setFogColor);
     60
     61        LOAD_PARAM_START_CYCLE(root, element);
     62        {
     63                LoadParam_CYCLE(element, "option", this, FogEffect, setFogOption);
     64        }
     65        LOAD_PARAM_END_CYCLE(element);
    5966}
    6067
    … …  
    6269{
    6370        //default values
     71        this->fogActivate = false;
     72        this->fogFadeDuration = 0;
     73        this->localTimer = 0;
     74       
    6475        this->fogMode = GL_EXP2;
    6576        this->fogDensity = 0.001;
    6677        this->fogStart = 0;
    6778        this->fogEnd = 5000;
    68   this->colorVector = Vector(0.7, 0.7, 0.7);
     79        this->colorVector = Vector(0.7, 0.7, 0.7);
     80
    6981}
    70 
    7182
    7283
    … …  
    7586        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);
    7687
     88        this->fogActivate = true;
     89       
     90        GLfloat fogColor[4] = { colorVector.x, colorVector.y, colorVector.z, 1.0};
     91        glFogi(GL_FOG_MODE, this->fogMode);
     92        glFogfv(GL_FOG_COLOR, fogColor);
     93        glFogf(GL_FOG_DENSITY, this->fogDensity);
     94        glHint(GL_FOG_HINT, GL_DONT_CARE);
     95        glFogf(GL_FOG_START, this->fogStart);
     96        glFogf(GL_FOG_END, this->fogEnd);
     97       
    7798        glEnable(GL_FOG);
    78         {
    79                 GLfloat fogColor[4] = { colorVector.x, colorVector.y, colorVector.z, 1.0};
    80 
    81                 glFogi(GL_FOG_MODE, this->fogMode);
    82                 glFogfv(GL_FOG_COLOR, fogColor);
    83                 glFogf(GL_FOG_DENSITY, this->fogDensity);
    84                 glHint(GL_FOG_HINT, GL_DONT_CARE);
    85                 glFogf(GL_FOG_START, this->fogStart);
    86                 glFogf(GL_FOG_END, this->fogEnd);
    87         }
    88         glClearColor(0.5, 0.5, 0.5, 1.0);
     99        // glClearColor(0.5, 0.5, 0.5, 1.0);
    89100}
    90101
    … …  
    93104{
    94105        PRINTF(0)("Deactivating FogEffect\n");
     106
     107        this->fogActivate = false;
     108       
    95109        glDisable(GL_FOG);
     110}
     111
     112void FogEffect::draw() const {
     113
     114        if (this->fogFadeDuration != 0 && this->localTimer < this->fogFadeDuration)
     115                glFogf(GL_FOG_DENSITY, this->fogFadeDensity);
     116        //else
     117        //      glFogf(GL_FOG_DENSITY, this->fogDensity);
     118
     119}
     120void FogEffect::tick(float dt)
     121{
     122        if (!this->fogActivate)
     123                return;
     124               
     125
     126        if (this->fogFadeDuration != 0 && this->localTimer < this->fogFadeDuration) {
     127                this->localTimer += dt;
     128                float progress = this->localTimer / this->fogFadeDuration;
     129                this->fogFadeDensity = progress * this->fogDensity;
     130        }
     131}
     132
     133void FogEffect::startFogging() {
     134
     135        if (this->fogActivate)
     136                this->deactivate();
     137
     138        this->fogFadeDuration = 10;
     139        this->localTimer = 0;
     140        this->activate();
     141
    96142}
    97143

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

    r7810 r8255  
    2323                virtual bool deactivate();
    2424
     25                void activateFog() { this->activate(); }
     26                void deactivateFog() { this->deactivate(); }
     27
     28                virtual void draw() const;
     29                virtual void tick(float dt);
     30
    2531                inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
    2632                inline void setFogDensity(float density) { this->fogDensity = density; }
    2733                inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
    2834                inline void setFogColor(float r, float g, float b) { this->colorVector = Vector(r, g, b); }
     35                inline void setFogOption(const std::string& option) { if (option == "activate") this->fogActivate = true; }
     36
     37                void startFogging();
    2938
    3039        private:
    3140                GLint stringToFogMode(const std::string& mode);
    3241
    33         private:
    34                 GLint                   fogMode;
    35                 GLfloat                 fogDensity;
    36                 GLfloat                 fogStart;
    37                 GLfloat                 fogEnd;
    38                 Vector                  colorVector;
     42                bool                            fogActivate;
     43                GLfloat                         fogFadeDuration;
     44                float                           localTimer;
     45               
     46                GLint                           fogMode;
     47                GLfloat                         fogDensity;
     48                GLfloat                         fogFadeDensity;
     49
     50                GLfloat                         fogStart;
     51                GLfloat                         fogEnd;
     52                Vector                          colorVector;
    3953};
    4054

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

    r7810 r8255  
    1818#include "util/loading/load_param.h"
    1919#include "util/loading/factory.h"
    20 #include "render2D/image_plane.h"
     20#include "effects/billboard.h"
    2121
    2222#include "glincl.h"
    2323#include "parser/tinyxml/tinyxml.h"
    2424
     25#include "shell_command.h"
     26#include "light.h"
     27
     28SHELL_COMMAND(activate, LighteningEffect, activateLightening);
     29SHELL_COMMAND(deactivate, LighteningEffect, deactivateLightening);
     30
    2531using namespace std;
    2632
    … …  
    3036{
    3137        this->setClassID(CL_LIGHTENING_EFFECT, "LighteningEffect");
    32  
    33  
    34   lightening = new ImagePlane(NULL);
    35   lightening->setTexture("maps/lightning_bolt.png");
    36   lightening->setSize(50, 50);
    37   lightening->setAbsCoor2D(10,10);
    38   lightening->setVisibility(true);
    39  
    4038 
    4139        this->init();
    … …  
    4442                this->loadParams(root);
    4543
    46         this->activate();
     44  if(this->lighteningActivate)
     45         this->activate();
    4746}
    4847
    … …  
    5049{
    5150        this->deactivate();
    52   delete lightening;
    5351}
    5452
    … …  
    5654{
    5755        WeatherEffect::loadParams(root);
     56 
     57  LoadParam(root, "coord", this, LighteningEffect, coord);
     58  LoadParam(root, "option", this, LighteningEffect, setLighteningOption);
     59  LoadParam(root, "frequency", this, LighteningEffect, setFlashFrequency);
     60  LoadParam(root, "const-time", this, LighteningEffect, setFlashConstTime);
     61  LoadParam(root, "rising-time", this, LighteningEffect, setFlashRisingTime);
     62  LoadParam(root, "size", this, LighteningEffect, setFlashSize);
     63  LoadParam(root, "seed", this, LighteningEffect, setFlashSeed);
    5864}
    5965
    … …  
    6167bool LighteningEffect::init()
    6268{
    63         //Default values
     69  lighteningActivate = false;
     70 
     71  this->time = 0.0;
     72  this->flashFrequency = 1.4f;
     73  this->flashConstTime = 0.5f;
     74  this->flashRisingTime = 0.1f;
     75
     76  this->width = 400.0f;
     77  this->height = 100.0f;
     78  this->seedWidth = 50;
     79  this->seedHeight = 50;
     80  this->bNewCoordinate = false;
     81
     82  this->seedX = 500.f;
     83  this->seedZ = 1000.0f;
     84  this->seedTime = 4.0f;
     85
     86  this->billboard[0] = new Billboard(NULL);
     87  this->billboard[0]->setTexture("maps/lightning_bolt1.png");
     88  this->billboard[0]->setSize(this->width, this->height);
     89  this->billboard[0]->setAbsCoor(3000,850,0);
     90  this->billboard[0]->setVisibiliy(false);
     91
     92  this->billboard[1] = new Billboard(NULL);
     93  this->billboard[1]->setTexture("maps/lightning_bolt2.png");
     94  this->billboard[1]->setSize(this->width, this->height);
     95  this->billboard[1]->setAbsCoor(3000,850,0);
     96  this->billboard[1]->setVisibiliy(false);
     97
     98  this->billboard[2] = new Billboard(NULL);
     99  this->billboard[2]->setTexture("maps/lightning_bolt3.png");
     100  this->billboard[2]->setSize(this->width, this->height);
     101  this->billboard[2]->setAbsCoor(3000,850,0);
     102  this->billboard[2]->setVisibiliy(false);
     103
     104  this->billboard[3] = new Billboard(NULL);
     105  this->billboard[3]->setTexture("maps/lightning_bolt4.png");
     106  this->billboard[3]->setSize(this->width, this->height);
     107  this->billboard[3]->setAbsCoor(0.0f, 50.0f, 0.0f);
     108  this->billboard[3]->setVisibiliy(false);
     109/*
     110  this->soundSource = NULL;
     111  this->thunderBuffer = NULL;
     112
     113  this->soundSource.setSourceNode(this);
     114
     115  //load sound
     116  if (this->thunderBuffer != NULL)
     117    ResourceManager::getInstance()->unload(this->thunderBuffer);
     118  this->thunderBuffer = (OrxSound::SoundBuffer*)ResourceManager::getInstance()->load("sound/thunder.wav", WAV);*/
     119}
     120
     121void LighteningEffect::coord(float x, float y, float z)
     122{
     123  this->billboard[0]->setAbsCoor(x, y, z);
     124  this->billboard[1]->setAbsCoor(x, y, z);
     125  this->billboard[2]->setAbsCoor(x, y, z);
     126  this->billboard[3]->setAbsCoor(x, y, z);
     127  this->mainPosX = x;
     128  this->mainPosY = y;
     129  this->mainPosZ = z;
     130}
     131
     132
     133void LighteningEffect::setFlashSize(float width, float height, float seedWidth, float seedHeight)
     134{
     135  this->width = width;
     136  this->height = height;
     137  this->seedWidth = seedWidth;
     138  this->seedHeight = seedHeight;
     139  this->billboard[0]->setSize(this->width, this->height);
     140  this->billboard[1]->setSize(this->width, this->height);
     141  this->billboard[2]->setSize(this->width, this->height);
     142  this->billboard[3]->setSize(this->width, this->height);
    64143}
    65144
    … …  
    68147{
    69148        PRINTF(0)( "Activating LighteningEffect\n" );
    70 
     149  this->time = 0;
     150  lighteningActivate = true;
    71151}
    72152
    … …  
    75155{
    76156        PRINTF(0)("Deactivating LighteningEffect\n");
     157  this->billboard[0]->setVisibiliy(false);
     158  this->billboard[1]->setVisibiliy(false);
     159  this->billboard[2]->setVisibiliy(false);
     160  this->billboard[3]->setVisibiliy(false);
     161  lighteningActivate = false;
    77162}
    78163
    79164void LighteningEffect::tick (float dt)
    80165{
    81 
    82 }
     166  if(!lighteningActivate)
     167    return;
     168 
     169  this->time += dt;
     170
     171  /*if( flashLight != NULL)
     172  {
     173    if((int)(100*time)%2)
     174      this->flashLight->setDiffuseColor(0,0,0);
     175    else
     176      this->flashLight->setDiffuseColor(100,100,100);
     177   
     178    //PRINTF(0)("100*time: %f %i\n", 100*time, (int)(100*time));
     179}*/
     180 
     181  if( this->time > this->flashFrequency)
     182  {
     183    this->billboard[0]->setVisibiliy(true);
     184    this->time = 0.0f;
     185   
     186    this->flashLight = new Light();
     187    this->flashLight->setAbsCoor(this->billboard[0]->getAbsCoor().x, this->billboard[0]->getAbsCoor().y, this->billboard[0]->getAbsCoor().z);
     188    this->flashLight->setDiffuseColor(100,100,100);
     189   
     190    //this->soundSource.play(this->thunderBuffer);
     191  }
     192  else if( this->billboard[3]->isVisible() && this->time > this->flashConstTime)
     193  {
     194    this->billboard[3]->setVisibiliy(false);
     195    this->time = 0.0f;
     196    this->bNewCoordinate = true;
     197   
     198    if(flashLight != NULL)
     199    {
     200      delete this->flashLight;
     201      flashLight = NULL;
     202    }
     203  }
     204
     205  if( this->billboard[2]->isVisible() && this->time > this->flashRisingTime)
     206  {
     207    this->billboard[2]->setVisibiliy(false);
     208    this->billboard[3]->setVisibiliy(true);
     209    this->flashLight->setDiffuseColor(100,100,100);
     210  }
     211  else if( this->billboard[1]->isVisible() && this->time > this->flashRisingTime*2/3 )
     212  {
     213    this->billboard[1]->setVisibiliy(false);
     214    this->billboard[2]->setVisibiliy(true);
     215    this->flashLight->setDiffuseColor(0,0,0);
     216  }
     217  else if( this->billboard[0]->isVisible() && this->time > this->flashRisingTime*1/3 )
     218  {
     219    this->billboard[0]->setVisibiliy(false);
     220    this->billboard[1]->setVisibiliy(true);
     221    this->flashLight->setDiffuseColor(100,100,100);
     222  }
     223
     224  if( this->bNewCoordinate)
     225  {
     226    float posX = this->mainPosX - this->seedX * (float)rand()/(float)RAND_MAX;
     227    float posZ = this->mainPosZ + this->seedZ * (float)rand()/(float)RAND_MAX;
     228    this->billboard[0]->setAbsCoor(posX, this->mainPosY, posZ);
     229    this->billboard[1]->setAbsCoor(posX, this->mainPosY, posZ);
     230    this->billboard[2]->setAbsCoor(posX, this->mainPosY, posZ);
     231    this->billboard[3]->setAbsCoor(posX, this->mainPosY, posZ);
     232    this->bNewCoordinate = false;
     233  }
     234}
     235
     236void LighteningEffect::draw() const
     237{
     238}

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

    r7810 r8255  
    1515
    1616
    17 class ImagePlane;
     17class Billboard;
     18class Light;
    1819
    1920class LighteningEffect : public WeatherEffect
    … …  
    3031                virtual bool deactivate();
    3132
    32                 virtual void tick(float dt);
     33    virtual void draw() const;
     34    virtual void tick(float dt);
     35   
     36    void coord(float x, float y, float z);
     37    void setFlashSize(float width, float height, float seedWidth, float seedHeight);
     38   
     39    inline void setLighteningOption(const std::string& option) { if (option == "activate") this->lighteningActivate = true;}
     40    inline void setFlashFrequency(float flashFrequency) { this->flashFrequency = flashFrequency; }
     41    inline void setFlashConstTime(float flashConstTime) { this->flashConstTime = flashConstTime; }
     42    inline void setFlashRisingTime(float flashRisingTime) { if(flashRisingTime > this->flashConstTime)
     43                                                                                        this->flashRisingTime = this->flashConstTime/2;
     44                                                                                      else
     45                                                                                        this->flashRisingTime = flashRisingTime; }
     46    inline void setFlashSeed(float seedX, float seedZ, float seedTime) { this->seedX = seedX;
     47                                                                                                         this->seedZ = seedZ;
     48                                                                                                         this->seedTime = seedTime; }
    3349
     50    void activateLightening() { this->activate(); }
     51    void deactivateLightening() { this->deactivate(); }
     52   
    3453        private:
    35     ImagePlane* lightening;
     54    Billboard* billboard[4];
     55    bool lighteningActivate;
     56
     57    float flashFrequency;
     58    float flashConstTime;
     59    float flashRisingTime;
     60
     61    float time;
     62
     63    bool  bNewCoordinate;
     64    float width;
     65    float height;
     66    float seedWidth;
     67    float seedHeight;
     68
     69    float seedX;
     70    float seedZ;
     71    float seedTime;
     72   
     73    float mainPosX;
     74    float mainPosY;
     75    float mainPosZ;
     76
     77    Light* flashLight;
     78   
     79    //OrxSound::SoundSource    soundSource;
     80    //OrxSound::SoundBuffer*   thunderBuffer;
    3681
    3782};

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

    r7810 r8255  
    11/*
    2    orxonox - the future of 3D-vertical-scrollers
    3 
    4    Copyright (C) 2004 orx
    5 
    6    This program is free software; you can redistribute it and/or modify
    7    it under the terms of the GNU General Public License as published by
    8    the Free Software Foundation; either version 2, or (at your option)
    9    any later version.
     2orxonox - the future of 3D-vertical-scrollers
     3
     4Copyright (C) 2004 orx
     5
     6This program is free software; you can redistribute it and/or modify
     7it under the terms of the GNU General Public License as published by
     8the Free Software Foundation; either version 2, or (at your option)
     9any later version.
    1010
    1111### File Specific:
    12    main-programmer: hdavid, amaechler
     12main-programmer: hdavid, amaechler
    1313*/
    1414
    … …  
    2525#include "plane_emitter.h"
    2626#include "shell_command.h"
     27#include "light.h"
    2728
    2829#include "parser/tinyxml/tinyxml.h"
    … …  
    3132SHELL_COMMAND(deactivate, RainEffect, deactivateRain);
    3233
     34SHELL_COMMAND(startRaining, RainEffect, startRaining);
     35
    3336using namespace std;
    3437
    3538CREATE_FACTORY(RainEffect, CL_RAIN_EFFECT);
     39
     40// 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
    3641
    3742RainEffect::RainEffect(const TiXmlElement* root)
    … …  
    5055
    5156        //load wind sound
    52         if (this->rainWindForce > 0) {
     57        if (this->rainWindForce != 0) {
    5358                if (this->windBuffer != NULL)
    5459                        ResourceManager::getInstance()->unload(this->windBuffer);
    … …  
    5661        }
    5762
    58         this->activate();
     63        if(rainActivate)
     64                this->activate();
    5965}
    6066
    … …  
    8086        LoadParam(root, "life", this, RainEffect, setRainLife);
    8187        LoadParam(root, "wind", this, RainEffect, setRainWind);
    82         LoadParam(root, "option", this, RainEffect, setRainOption);
     88        LoadParam(root, "startraining", this, RainEffect, setRainStart);
     89
     90        LOAD_PARAM_START_CYCLE(root, element);
     91        {
     92                LoadParam_CYCLE(element, "option", this, RainEffect, setRainOption);
     93        }
     94        LOAD_PARAM_END_CYCLE(element);
     95
    8396}
    8497
    … …  
    87100{
    88101        //Default values
     102        this->rainActivate = false;
     103        this->rainMove = false;
    89104        this->rainCoord = Vector(500, 500, 500);
    90105        this->rainSize = Vector2D(1000, 1000);
    … …  
    94109        this->rainMaxParticles = this->rainRate * this->rainLife;
    95110        this->rainWindForce  = 0;
     111        this->rainStartDuration = 0;
     112        this->localTimer = 0;
     113        this->soundRainVolume = 0.8f;
    96114
    97115        this->emitter = new PlaneEmitter(this->rainSize);
     116
     117        lightMan = LightManager::getInstance();
     118        this->rainAmbient = lightMan->getAmbientColor();
    98119}
    99120
    … …  
    104125{
    105126        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" );
     127
     128        this->rainActivate = true;
    106129
    107130        if (unlikely(RainEffect::rainParticles == NULL))
    … …  
    114137                RainEffect::rainParticles->setRadius(0.2, 0.02);
    115138                RainEffect::rainParticles->setRadius(1, 0.01);
    116                 RainEffect::rainParticles->setColor(0, 0.3, 0.3, 0.5, 0.2); // grey blue 1
    117                 RainEffect::rainParticles->setColor(0.5, 0.4, 0.4, 0.5, 0.2); // grey blue 2
    118                 RainEffect::rainParticles->setColor(1, 0.7, 0.7, 0.7, 0.2); // light grey
     139                RainEffect::rainParticles->setColor(0, 0.3, 0.3, 0.5, 0.2);     // grey blue 1
     140                RainEffect::rainParticles->setColor(0.5, 0.4, 0.4, 0.5, 0.2);   // grey blue 2
     141                RainEffect::rainParticles->setColor(1, 0.7, 0.7, 0.7, 0.2);     // light grey
    119142        }
    120143
    … …  
    128151        this->emitter->setSpread(this->rainWindForce / 50, 0.2);
    129152       
    130         this->soundSource.loop(this->rainBuffer);
    131         if (this->rainWindForce > 0)
    132                 this->soundSource.loop(this->windBuffer);
     153        this->soundSource.loop(this->rainBuffer, this->soundRainVolume);
     154        if (this->rainWindForce != 0) this->soundSource.loop(this->windBuffer, 0.1f * this->rainWindForce);
     155
     156        lightMan->setAmbientColor(.1,.1,.1);
    133157}
    134158
    … …  
    137161{
    138162        PRINTF(0)("Deactivating RainEffect\n");
     163       
     164        this->rainActivate = false;
    139165        this->emitter->setSystem(NULL);
    140166
     167        // Stop Sound
    141168        this->soundSource.stop();
    142 }
    143 
    144 void RainEffect::activateRain()
    145 {
    146         this->activate();
    147 }
    148 
    149 void RainEffect::deactivateRain()
    150 {
    151         this->deactivate();
    152 }
    153 
     169
     170        // Restore Light Ambient
     171        lightMan->setAmbientColor(this->rainAmbient, this->rainAmbient, this->rainAmbient);
     172}
    154173
    155174void RainEffect::tick (float dt)
    156175{
     176        if (!this->rainActivate)
     177                return;
     178               
    157179        if (this->rainMove) {
    158180                this->rainCoord = State::getCameraNode()->getAbsCoor();
    159181                this->emitter->setRelCoor(this->rainCoord.x , this->rainCoord.y+800, this->rainCoord.z);
    160182        }
    161 }
     183
     184        if (this->rainStartDuration != 0 && this->localTimer < this->rainStartDuration) {
     185                this->localTimer += dt;
     186                float progress = this->localTimer / this->rainStartDuration;
     187
     188                // Dim Light
     189                lightMan->setAmbientColor(1.1 - progress, 1.1 - progress, 1.1 - progress);
     190
     191                // use alpha in color to fade in
     192                RainEffect::rainParticles->setColor(0,   0.3, 0.3, 0.5, 0.2 * progress); // grey blue 1
     193                RainEffect::rainParticles->setColor(0.5, 0.4, 0.4, 0.5, 0.2 * progress); // grey blue 2
     194                RainEffect::rainParticles->setColor(1,   0.7, 0.7, 0.7, 0.2 * progress); // light grey
     195
     196                // increase radius for more "heavy" rain
     197                RainEffect::rainParticles->setRadius(0, 0.03 * progress);
     198                RainEffect::rainParticles->setRadius(0.2, 0.02 * progress);
     199                RainEffect::rainParticles->setRadius(1, 0.01 * progress);
     200
     201                // increase sound volume
     202                // this->soundSource.fadein(this->rainBuffer, 10);
     203        }
     204       
     205}
     206
     207void RainEffect::startRaining() {
     208
     209        if (this->rainActivate)
     210                this->deactivate();
     211
     212        this->rainStartDuration = 10;
     213        this->localTimer = 0;
     214        this->activate();
     215
     216}

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

    r7810 r8255  
    1414class SparkParticles;
    1515class PlainEmitter;
     16class LightManager;
    1617
    1718#include "weather_effect.h"
    … …  
    3435                virtual bool deactivate();
    3536
    36                 void activateRain();
    37                 void deactivateRain();
     37                virtual void tick(float dt);
    3838
    39                 virtual void tick(float dt);
     39                inline void activateRain() { this->activate(); }
     40                inline void deactivateRain() { this->deactivate(); }
     41                void startRaining();
    4042
    4143                inline void setRainCoord(float x, float y, float z) { this->rainCoord = Vector(x, y, z); }
    … …  
    4547                inline void setRainLife(float life) { this->rainLife = life; }
    4648                inline void setRainWind(int force) { this->rainWindForce = force; }
    47                 inline void setRainOption(const std::string& option) { if (option == "moverain") this->rainMove = true; }
     49                inline void setRainStart(float duration) { this->rainStartDuration = duration; }
     50
     51                inline void setRainOption(const std::string& option) {
     52                        if (option == "moverain") this->rainMove = true;
     53                        if (option == "activate") this->rainActivate = true;
     54                }
    4855
    4956
    5057        private:
    51                 static SparkParticles*                                          rainParticles;
    52                 ParticleEmitter*                                                                        emitter;
     58                static SparkParticles*                  rainParticles;
     59                ParticleEmitter*                        emitter;
    5360
    54                 Vector                                                                                                          rainCoord;
    55                 Vector2D                                                                                                        rainSize;
    56                 GLfloat                                                                                                         rainRate;
    57                 GLfloat                                                                                                         rainVelocity;
    58                 GLfloat                                                                                                         rainLife;
    59                 GLfloat                                                                                                         rainMaxParticles;
    60                 int                                                                                                                             rainWindForce;
    61                 bool                                                                                                                    rainMove;
     61                float                                   localTimer;
     62
     63                Vector                                  rainCoord;
     64                Vector2D                                rainSize;
     65                GLfloat                                 rainRate;
     66                GLfloat                                 rainVelocity;
     67                GLfloat                                 rainLife;
     68                GLfloat                                 rainMaxParticles;
     69                int                                     rainWindForce;
     70                GLfloat                                 rainStartDuration;
     71                bool                                    rainMove;
     72                bool                                    rainActivate;
    6273
    6374                OrxSound::SoundSource                   soundSource;
    6475                OrxSound::SoundBuffer*                  rainBuffer;
    6576                OrxSound::SoundBuffer*                  windBuffer;
     77
     78                float                                   soundRainVolume;
     79
     80                LightManager*                           lightMan;
     81                GLfloat                                 rainAmbient;
     82
    6683};
    6784
    68 
    6985#endif  /* _RAIN_EFFECT */

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

    r7810 r8255  
    5353        }
    5454
    55         this->activate();
     55        if(snowActivate)
     56                this->activate();
    5657}
    5758
    … …  
    7576        LoadParam(root, "emissionRate", this, SnowEffect, emissionRate);
    7677        LoadParam(root, "emissionVelocity", this, SnowEffect, emissionVelocity);
    77   LoadParam(root, "wind", this, SnowEffect, wind);
     78        LoadParam(root, "wind", this, SnowEffect, wind);
    7879        LoadParam(root, "size", this, SnowEffect, size);
    7980        LoadParam(root, "coord", this, SnowEffect, coord);
     81 
     82        LOAD_PARAM_START_CYCLE(root, element);
     83        {
     84                LoadParam_CYCLE(element, "option", this, SnowEffect, setSnowOption);
     85        }
     86        LOAD_PARAM_END_CYCLE(element);
    8087}
    8188
    … …  
    8592
    8693        // Default values
     94        this->snowActivate = false;
     95        this->snowMove = false;
    8796        this->particles = 12000;
    8897        this->texture = "maps/snow_flake_01_32x32.png";
    … …  
    100109        this->alpha = 0.5;
    101110        this->snowSize = Vector2D(2500, 2500);
    102   this->snowCoord = Vector(100,450,400);
     111        this->snowCoord = Vector(100,450,400);
    103112        this->snowWindForce = 1;
    104 
    105         this->activated = false;
    106113}
    107114
    … …  
    109116{
    110117        PRINTF(0)("Activating SnowEffect\n");
    111         activated = true;
     118
     119        this->snowActivate = true;
    112120
    113121        SnowEffect::snowParticles = new SpriteParticles(particles);
    … …  
    131139        this->emitter->setSize(snowSize);
    132140
    133   //SnowEffect::snowParticles->precache(8);
     141        // SnowEffect::snowParticles->precache(8);
    134142
    135143        if (this->snowWindForce > 1)
    … …  
    141149{
    142150        PRINTF(0)("Deactivating SnowEffect\n");
    143         activated = false;
    144 
     151
     152        this->snowActivate = false;
    145153        this->emitter->setSystem(NULL);
    146154
    … …  
    150158}
    151159
    152 void SnowEffect::activateSnow()
    153 {
     160void SnowEffect::draw() const
     161{
     162        if (!this->snowActivate)
     163                return;
     164}
     165
     166void SnowEffect::tick(float dt)
     167{
     168        if (!this->snowActivate)
     169                return;
     170
     171        /*
     172        float distance = (State::getCameraNode()->getAbsCoor() - Vector(snowCoord.x, State::getCameraNode()->getAbsCoor().y, snowCoord.z)).len();
     173       
     174        if(activated)
     175        {
     176        if(distance > 0.3*snowSize.x || distance > 0.3*snowSize.y)
     177                        this->deactivate();
     178        else if(distance > 0.25*snowSize.x || distance > 0.25*snowSize.y)
     179        this->alpha = 0.15;
     180        else if(distance > 0.2*snowSize.x || distance > 0.2*snowSize.y)
     181        this->alpha = 0.25;
     182        else if(distance > 0.1*snowSize.x || distance > 0.1*snowSize.y)
     183        this->alpha = 0.4;
     184       
     185        SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
     186        SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
     187        SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
     188        }
     189        else
     190        {
     191        if(distance < 0.3*snowSize.x || distance < 0.3*snowSize.y )
    154192        this->activate();
    155 }
    156 
    157 void SnowEffect::deactivateSnow()
    158 {
    159         this->deactivate();
    160 }
    161 
    162 void SnowEffect::draw() const
    163 {
    164 }
    165 
    166 void SnowEffect::tick(float dt)
    167 {
    168   float distance = (State::getCameraNode()->getAbsCoor() - Vector(snowCoord.x, State::getCameraNode()->getAbsCoor().y, snowCoord.z)).len();
    169  
    170   if(activated)
    171   {
    172     if(distance > 0.3*snowSize.x || distance > 0.3*snowSize.y)
    173                   this->deactivate();
    174     else if(distance > 0.25*snowSize.x || distance > 0.25*snowSize.y)
    175       this->alpha = 0.15;
    176     else if(distance > 0.2*snowSize.x || distance > 0.2*snowSize.y)
    177       this->alpha = 0.25;
    178     else if(distance > 0.1*snowSize.x || distance > 0.1*snowSize.y)
    179       this->alpha = 0.4;
    180 
    181     SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
    182     SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
    183     SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
    184   }
    185   else
    186   {
    187   if(distance < 0.3*snowSize.x || distance < 0.3*snowSize.y )
    188     this->activate();
    189   if( distance < 0.25*snowSize.x || distance < 0.25*snowSize.y )
    190     this->alpha = 0.25;
    191   else if( distance < 0.2*snowSize.x || distance < 0.2*snowSize.y )
    192     this->alpha = 0.4;
    193   else if( distance < 0.1*snowSize.x || distance < 0.1*snowSize.y )
    194     this->alpha = 0.5;
    195 
    196     SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
    197     SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
    198     SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
    199   }
    200 }
    201 
     193        if( distance < 0.25*snowSize.x || distance < 0.25*snowSize.y )
     194        this->alpha = 0.25;
     195        else if( distance < 0.2*snowSize.x || distance < 0.2*snowSize.y )
     196        this->alpha = 0.4;
     197        else if( distance < 0.1*snowSize.x || distance < 0.1*snowSize.y )
     198        this->alpha = 0.5;
     199       
     200        SnowEffect::snowParticles->setColor(0,1, 1, 1, alpha);
     201        SnowEffect::snowParticles->setColor(.5, .6, .6, .6, alpha/2);
     202        SnowEffect::snowParticles->setColor(1, .0, .0, .0, .0);
     203        }*/
     204
     205        if (this->snowMove) {
     206                this->snowCoord = State::getCameraNode()->getAbsCoor();
     207                this->emitter->setRelCoor(this->snowCoord.x , this->snowCoord.y+300, this->snowCoord.z);
     208        }
     209}

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

    r7810 r8255  
    3333                virtual bool deactivate();
    3434
     35                inline void activateSnow() { this->activate(); }
     36                inline void deactivateSnow() { this->deactivate(); }
     37               
    3538                virtual void draw() const;
    3639                virtual void tick(float dt);
    3740
    38                 void activateSnow();
    39                 void deactivateSnow();
    4041
    4142                inline void numParticles(int n) { this->particles = n; }
    … …  
    4849                inline void size(float sizeX, float sizeY) { this->snowSize = Vector2D(sizeX, sizeY); }
    4950                inline void coord(float x, float y, float z) { this->snowCoord = Vector(x, y, z); }
    50     inline void wind(int force) { this->snowWindForce = force; }
     51                inline void wind(int force) { this->snowWindForce = force; }
     52
     53                inline void setSnowOption(const std::string& option) {
     54                        /*if (option == "fade") this->snowFade = true;*/
     55                        if (option == "movesnow") this->snowMove = true;
     56                        if (option == "activate") this->snowActivate = true;
     57                }
    5158
    5259
    5360        private:
    54                 int                                                                                                                             particles;
    55                 std::string                                                                                             texture;
    56                 float                                                                                                                   life, randomLife;
    57                 float                                                                                                                           snowRadius, randomRadius;
    58                 float                                                                                                                           snowMass, randomMass;
    59                 float                                                                                                                   rate;
    60                 float                                                                                                                   velocity, randomVelocity;
    61                 float                                                                                                                   angle, randomAngle;
    62                 float                                                                                                                   alpha;
    63                 Vector                                                                                                                  snowCoord;
    64                 Vector2D                                                                                                                snowSize;
    65                 int                                                                                                                                     snowWindForce;
     61                int                             particles;
     62                std::string                     texture;
     63                float                           life, randomLife;
     64                float                           snowRadius, randomRadius;
     65                float                           snowMass, randomMass;
     66                float                           rate;
     67                float                           velocity, randomVelocity;
     68                float                           angle, randomAngle;
     69                float                           alpha;
     70                Vector                          snowCoord;
     71                Vector2D                        snowSize;
     72                int                             snowWindForce;
    6673
    67                 bool                                                                                                                            activated;
     74                bool                            snowMove;
     75                bool                            snowActivate;
    6876
    69                 PlaneEmitter*                                                                                           emitter;
     77                PlaneEmitter*                   emitter;
    7078
    71                 static SpriteParticles*                                                 snowParticles;
    72                 OrxSound::SoundSource              soundSource;
    73                 OrxSound::SoundBuffer*             windBuffer;
     79                static SpriteParticles*         snowParticles;
     80                OrxSound::SoundSource           soundSource;
     81                OrxSound::SoundBuffer*          windBuffer;
    7482
    7583};

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

    r7810 r8255  
    1515*/
    1616
     17// TODO: descriptions to loadparams, movealong unified, start activation
    1718
    1819#include "weather_effect.h"

  • trunk/src/lib/graphics/light.h

    r6512 r8255  
    11/*!
    2  * @file light.h
    3   *  Handles Lights.
     2* @file light.h
     3*  Handles Lights.
    44
    5     A Light is one of the more important things in a 3D-environment,
    6     without it one sees nothing :)
    7     It is here for diffuse-, specular- and Bump-Mappings.
     5A Light is one of the more important things in a 3D-environment,
     6without it one sees nothing :)
     7It is here for diffuse-, specular- and Bump-Mappings.
    88*/
    99
    … …  
    2525class Light : public PNode
    2626{
    27  public:
    28   Light(const TiXmlElement* root = NULL);
    29   virtual ~Light();
    30 
    31   virtual void loadParams(const TiXmlElement* root);
    32 
    33   void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
    34   void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
    35   void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
    36   void setSpotDirection(const Vector& direction);
    37   void setSpotDirection(float x, float y, float z) { setSpotDirection(Vector(x,y,z)); };
    38   void setSpotCutoff(GLfloat cutoff);
    39 
    40   /** @returns the lightNumber*/
    41   int getLightNumber() const {return this->lightNumber;}
    42 
    43   virtual void draw() const;
    44 
    45   void debug() const;
    46 
    47   // attributes
    48  private:
    49   int              lightNumber;               //!< The number of this Light.
    50   GLfloat          diffuseColor[4];           //!< The Diffuse Color this Light emmits.
    51   GLfloat          specularColor[4];          //!< The specular Color of this Light.
    52   float            constantAttenuation;       //!< The Factor of the the Constant Attenuation.
    53   float            linearAttenuation;         //!< The Factor of the the Linear Attenuation.
    54   float            quadraticAttenuation;      //!< The Factor of the the Quadratic Attenuation.
    55   GLfloat          spotDirection[4];          //!< The direction of the Spot Light.
    56   GLfloat          spotCutoff;                //!< The cutoff Angle of the Light Source
     27        public:
     28                Light(const TiXmlElement* root = NULL);
     29                virtual ~Light();
     30               
     31                virtual void loadParams(const TiXmlElement* root);
     32               
     33                void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
     34                void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
     35                void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
     36                void setSpotDirection(const Vector& direction);
     37                void setSpotDirection(float x, float y, float z) { setSpotDirection(Vector(x,y,z)); };
     38                void setSpotCutoff(GLfloat cutoff);
     39               
     40                /** @returns the lightNumber*/
     41                int getLightNumber() const {return this->lightNumber;}
     42               
     43                virtual void draw() const;
     44               
     45                void debug() const;
     46       
     47        // attributes
     48        private:
     49                int              lightNumber;               //!< The number of this Light.
     50                GLfloat          diffuseColor[4];           //!< The Diffuse Color this Light emmits.
     51                GLfloat          specularColor[4];          //!< The specular Color of this Light.
     52                float            constantAttenuation;       //!< The Factor of the the Constant Attenuation.
     53                float            linearAttenuation;         //!< The Factor of the the Linear Attenuation.
     54                float            quadraticAttenuation;      //!< The Factor of the the Quadratic Attenuation.
     55                GLfloat          spotDirection[4];          //!< The direction of the Spot Light.
     56                GLfloat          spotCutoff;                //!< The cutoff Angle of the Light Source
    5757};
    58 
    59 
    60 
     58       
     59       
     60       
    6161//! A class that handles Lights
    6262/**
    63    A Light is a source that emits light rays (photons)
     63A Light is a source that emits light rays (photons)
    6464
    65    <b>Usage:</b>\n
    66    First you have to get the Light Manager up and running by using LightManager::getInstance().
    67    This automatically initiates the GL_LIGHTING, and sets some default stuff about the light.\n
    68    Then you will create a new light using:
    69    \li new Light();
     65<b>Usage:</b>\n
     66First you have to get the Light Manager up and running by using LightManager::getInstance().
     67This automatically initiates the GL_LIGHTING, and sets some default stuff about the light.\n
     68Then you will create a new light using:
     69\li new Light();
    7070
    71    if you want to operate on this Light just apply the following functions onto it.
    72        (You can also optain the Light-pointer with LightManager::getInstance()->getLight(lightNumber))
     71if you want to operate on this Light just apply the following functions onto it.
     72(You can also optain the Light-pointer with LightManager::getInstance()->getLight(lightNumber))
    7373
    74    now you can operate on the light as follows:
    75    \li void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
    76    \li void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
    77    \li void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
    78    \li void setSpotDirection(Vector direction);
    79    \li void setSpotCutoff(GLfloat cutoff);
    80    \li all PNode stuff also works
     74now you can operate on the light as follows:
     75\li void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
     76\li void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
     77\li void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
     78\li void setSpotDirection(Vector direction);
     79\li void setSpotCutoff(GLfloat cutoff);
     80\li all PNode stuff also works
    8181
    82    To redraw the light use
    83    \li void draw() const; (this is automatically done by the LightManager)
     82To redraw the light use
     83\li void draw() const; (this is automatically done by the LightManager)
    8484
    85    for some nice output just use:
    86    \li void debug() const; (either on LightManager for a resume or on any Light for single information.)
     85for some nice output just use:
     86\li void debug() const; (either on LightManager for a resume or on any Light for single information.)
    8787*/
    8888class LightManager : public BaseObject
    89 {
    90   friend class Light;
     89        {
     90        friend class Light;
    9191
    92  public:
    93   virtual ~LightManager();
    94   /** @returns a Pointer to the only object of this Class */
    95   inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
     92        public:
     93                virtual ~LightManager();
     94                /** @returns a Pointer to the only object of this Class */
     95                inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
    9696
    97   virtual void loadParams(const TiXmlElement* root);
    98   void loadLights(const TiXmlElement* root);
     97                virtual void loadParams(const TiXmlElement* root);
     98                void loadLights(const TiXmlElement* root);
    9999
    100   void setAmbientColor(GLfloat r, GLfloat g, GLfloat b);
     100                void setAmbientColor(GLfloat r, GLfloat g, GLfloat b);
     101                // HACK: Assuming r = g = b values
     102                inline GLfloat getAmbientColor() {  return this->ambientColor[0]; }
    101103
    102   Light* getLight(int lightNumber) const;
    103   inline Light* getLight() const { return this->currentLight; };
     104                Light* getLight(int lightNumber) const;
     105                inline Light* getLight() const { return this->currentLight; };
    104106
    105   void draw() const;
     107                void draw() const;
    106108
    107   void debug() const;
     109                void debug() const;
    108110
    109  private:
    110   LightManager();
     111        private:
     112                LightManager();
    111113
    112   int  registerLight(Light* light);
    113   void unregisterLight(Light* light);
     114                int  registerLight(Light* light);
     115                void unregisterLight(Light* light);
    114116
    115  private:
    116   static LightManager*    singletonRef;       //!< This is the LightHandlers Reference.
    117   GLfloat                 ambientColor[4];    //!< The ambient Color of the scene.
     117        private:
     118                static LightManager*    singletonRef;       //!< This is the LightHandlers Reference.
     119                GLfloat                 ambientColor[4];    //!< The ambient Color of the scene.
    118120
    119   Light**                 lights;             //!< An array of Lenght NUMBEROFLIGHTS, that holds pointers to all LightValues.
    120   Light*                  currentLight;       //!< The current Light, we are working with.
     121                Light**                 lights;             //!< An array of Lenght NUMBEROFLIGHTS, that holds pointers to all LightValues.
     122                Light*                  currentLight;       //!< The current Light, we are working with.
    121123
    122124};

  • trunk/src/lib/graphics/shader.cc

    r8037 r8255  
    201201}
    202202
     203void Shader::bindShader(const char* name, const float* value, size_t size)
     204{
     205        if (likely (this->shaderProgram != 0)) {
     206                glUseProgramObjectARB(this->shaderProgram);
     207
     208                unsigned int location = glGetUniformLocationARB(this->shaderProgram, name);
     209                /* This is EXPENSIVE and should be avoided. */
     210
     211                if      (size == 1)  glUniform1fvARB(location, 1, value);
     212                else if (size == 2)  glUniform2fvARB(location, 1, value);
     213                else if (size == 3)  glUniform3fvARB(location, 1, value);
     214                else if (size == 4)  glUniform4fvARB(location, 1, value);
     215                else if (size == 9)  glUniformMatrix3fvARB(location, 1, false, value);
     216                else if (size == 16) glUniformMatrix4fvARB(location, 1, false, value);
     217
     218        }
     219}
     220
    203221void Shader::deactivateShader()
    204222{

  • trunk/src/lib/graphics/shader.h

    r8037 r8255  
    9696  static bool checkShaderAbility();
    9797  void activateShader();
     98  void bindShader(const char* name, const float* value, size_t size);
    9899  static void deactivateShader();
    99100
Note: See TracChangeset for help on using the changeset viewer.