src/client/graph/ParticleRenderer.cpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 //    Scorched3D (c) 2000-2009
   3 //
   4 //    This file is part of Scorched3D.
   5 //
   6 //    Scorched3D 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 of the License, or
   9 //    (at your option) any later version.
  10 //
  11 //    Scorched3D is distributed in the hope that it will be useful,
  12 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //    GNU General Public License for more details.
  15 //
  16 //    You should have received a copy of the GNU General Public License
  17 //    along with Scorched3D; if not, write to the Free Software
  18 //    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 ////////////////////////////////////////////////////////////////////////////////
  20
  21 #include <graph/ParticleRenderer.h>
  22 #include <graph/Particle.h>
  23 #include <sprites/ExplosionTextures.h>
  24 #include <sprites/DebrisActionRenderer.h>
  25 #include <sprites/SmokeActionRenderer.h>
  26 #include <sprites/NapalmRenderer.h>
  27 #include <sprites/ExplosionNukeRenderer.h>
  28 #include <sprites/WallActionRenderer.h>
  29 #include <landscape/Landscape.h>
  30 #include <landscapemap/LandscapeMaps.h>
  31 #include <landscape/ShadowMap.h>
  32 #include <client/ScorchedClient.h>
  33 #include <GLEXT/GLState.h>
  34 #include <GLEXT/GLCamera.h>
  35 #include <GLEXT/GLCameraFrustum.h>
  36 #include <GLEXT/GLInfo.h>
  37 #include <common/Defines.h>
  38 #include <math.h>
  39
  40 ParticleRendererPoints *ParticleRendererPoints::getInstance()
  41 {
  42         static ParticleRendererPoints instance_;
  43         return &instance_;
  44 }
  45
  46 void ParticleRendererPoints::simulateParticle(Particle &particle, float time)
  47 {
  48 }
  49
  50 void ParticleRendererPoints::renderParticle(Particle &particle)
  51 {
  52         GLState state(GLState::TEXTURE_OFF);
  53         glPointSize(4.0f);
  54         glColor4f(
  55                 particle.color_[0],
  56                 particle.color_[1],
  57                 particle.color_[2],
  58                 particle.alpha_);
  59         glBegin(GL_POINTS);
  60                 glVertex3fv(particle.position_);
  61         glEnd();
  62         glPointSize(1.0f);
  63 }
  64
  65 ParticleRendererQuads *ParticleRendererQuads::getInstance()
  66 {
  67         static ParticleRendererQuads instance_;
  68         return &instance_;
  69 }
  70
  71 void ParticleRendererQuads::simulateParticle(Particle &particle, float time)
  72 {
  73 }
  74
  75 void ParticleRendererQuads::renderParticle(Particle &particle)
  76 {
  77         if (!particle.texture_ && !particle.textureSet_) return;
  78
  79         if (particle.textureSet_)
  80         {
  81                 int tex = int((particle.textureSet_->getNoTextures() - 1) * particle.percent_);
  82                 tex = MIN(MAX(tex, 0), particle.textureSet_->getNoTextures() - 1);
  83                 GLTexture *texture = particle.textureSet_->getTexture(tex);
  84                 texture->draw();
  85         }
  86         else
  87         {
  88                 particle.texture_->draw();
  89         }
  90
  91         GLCameraFrustum::instance()->drawBilboard(
  92                 particle.position_, particle.color_, particle.alpha_,
  93                 particle.size_[0], particle.size_[1], particle.additiveTexture_,
  94                 particle.textureCoord_);
  95
  96         // Add a shadow of the smoke on the ground
  97         float posX = particle.position_[0];
  98         float posY = particle.position_[1];
  99         float posZ = particle.position_[2];
 100         if (particle.shadow_)
 101         {
 102                 float aboveGround =
 103                         posZ - ScorchedClient::instance()->getLandscapeMaps().
 104                         getGroundMaps().getHeight(
 105                         int(posX), int(posY)).asFloat();
 106                 float smokeAlpha = particle.alpha_ + .2f;
 107                 if (smokeAlpha > 1.0f) smokeAlpha = 1.0f;
 108                 Landscape::instance()->getShadowMap().
 109                         addCircle(posX, posY,
 110                         (particle.size_[0] * aboveGround) / 10.0f, smokeAlpha);
 111         }
 112
 113         GLInfo::addNoTriangles(2);
 114 }
 115
 116 ParticleRendererDebris *ParticleRendererDebris::getInstance()
 117 {
 118         static ParticleRendererDebris instance_;
 119         return &instance_;
 120 }
 121
 122 void ParticleRendererDebris::renderParticle(Particle &particle)
 123 {
 124         DebrisActionRenderer *renderer = (DebrisActionRenderer *)
 125                 particle.userData_;
 126         renderer->draw(particle.position_);
 127 }
 128
 129 void ParticleRendererDebris::simulateParticle(Particle &particle, float time)
 130 {
 131         DebrisActionRenderer *renderer = (DebrisActionRenderer *)
 132                 particle.userData_;
 133         renderer->simulate(time);
 134 }
 135
 136 ParticleRendererSmoke *ParticleRendererSmoke::getInstance()
 137 {
 138         static ParticleRendererSmoke instance_;
 139         return &instance_;
 140 }
 141
 142 void ParticleRendererSmoke::renderParticle(Particle &particle)
 143 {
 144 }
 145
 146 void ParticleRendererSmoke::simulateParticle(Particle &particle, float time)
 147 {
 148         SmokeActionRenderer *renderer = (SmokeActionRenderer *)
 149                 particle.userData_;
 150 }
 151
 152 ParticleRendererNapalm *ParticleRendererNapalm::getInstance()
 153 {
 154         static ParticleRendererNapalm instance_;
 155         return &instance_;
 156 }
 157
 158 void ParticleRendererNapalm::renderParticle(Particle &particle)
 159 {
 160         NapalmRenderer *renderer = (NapalmRenderer *)
 161                 particle.userData_;
 162         renderer->draw(&particle);
 163         ParticleRendererQuads::getInstance()->renderParticle(particle);
 164 }
 165
 166 void ParticleRendererNapalm::simulateParticle(Particle &particle, float time)
 167 {
 168         NapalmRenderer *renderer = (NapalmRenderer *)
 169                 particle.userData_;
 170         renderer->simulate(&particle, time);
 171 }
 172
 173 ParticleRendererMushroom *ParticleRendererMushroom::getInstance()
 174 {
 175         static ParticleRendererMushroom instance_;
 176         return &instance_;
 177 }
 178
 179 void ParticleRendererMushroom::renderParticle(Particle &particle)
 180 {
 181         ExplosionNukeRendererEntry *renderer = (ExplosionNukeRendererEntry *)
 182                 particle.userData_;
 183
 184         Vector oldPosition = particle.position_;
 185         bool shadow = particle.shadow_;
 186
 187         particle.shadow_ = false;
 188         particle.position_[0] = oldPosition[0];
 189         particle.position_[1] = oldPosition[1] +
 190                 getFastSin(renderer->getCloudRotation() + 2.0f) * 2.0f;
 191         particle.position_[2] = oldPosition[2] +
 192                 getFastCos(renderer->getCloudRotation() + 2.0f) * 2.0f;
 193         ParticleRendererQuads::getInstance()->renderParticle(particle);
 194
 195         particle.shadow_ = false;
 196         particle.position_[0] = oldPosition[0];
 197         particle.position_[1] = oldPosition[1] +
 198                 getFastSin(renderer->getCloudRotation() + 4.0f) * 2.0f;
 199         particle.position_[2] = oldPosition[2] +
 200                 getFastCos(renderer->getCloudRotation() + 4.0f) * 2.0f;
 201         ParticleRendererQuads::getInstance()->renderParticle(particle);
 202
 203         particle.shadow_ = shadow;
 204         particle.position_[0] = oldPosition[0];
 205         particle.position_[1] = oldPosition[1] +
 206                 getFastSin(renderer->getCloudRotation()) * 2.0f;
 207         particle.position_[2] = oldPosition[2] +
 208                 getFastCos(renderer->getCloudRotation()) * 2.0f;
 209         ParticleRendererQuads::getInstance()->renderParticle(particle);
 210
 211         particle.position_ = oldPosition;
 212         particle.shadow_ = shadow;
 213 }
 214
 215 void ParticleRendererMushroom::simulateParticle(Particle &particle, float time)
 216 {
 217         ExplosionNukeRendererEntry *renderer = (ExplosionNukeRendererEntry *)
 218                 particle.userData_;
 219         renderer->simulate(&particle, time);
 220 }
 221
 222 ParticleRendererRain *ParticleRendererRain::getInstance()
 223 {
 224         static ParticleRendererRain instance_;
 225         return &instance_;
 226 }
 227
 228 void ParticleRendererRain::renderParticle(Particle &particle)
 229 {
 230         ParticleRendererQuads::getInstance()->renderParticle(particle);
 231 }
 232
 233 void ParticleRendererRain::simulateParticle(Particle &particle, float time)
 234 {
 235         if (particle.position_[2] < 0.0f)
 236         {
 237                 particle.life_ = 0.0f;
 238                 return;
 239         }
 240
 241         Vector &cameraPos = particle.engine_->getCamera()->getCurrentPos();
 242         Vector &cameraTarget = particle.engine_->getCamera()->getLookAt();
 243         Vector cameraDirection = (cameraTarget - cameraPos).Normalize();
 244
 245         // Size
 246         particle.size_[0] = 0.1f;
 247         particle.size_[1] = 1.0f - fabsf(cameraDirection[2]) + 0.1f;
 248
 249         // Alpha
 250         const float MaxDist = 200.0f * 200.0f;
 251         float alpha = 0.0f;
 252         if (particle.distance_ < MaxDist)
 253         {
 254                 alpha = 0.7f * (1.0f - (particle.distance_ / MaxDist));
 255         }
 256         particle.alpha_ = alpha;
 257
 258         // Distance
 259         float distanceX = cameraPos[0] - particle.position_[0];
 260         float distanceY = cameraPos[1] - particle.position_[1];
 261         /*if (distanceX > 100.0f)
 262         {
 263                 particle.position_[0] = -100.0f + distanceX - 100.0f;
 264         }
 265         else if (distanceX < -100.0f)
 266         {
 267                 particle.position_[0] = 100.0f + distanceX + 100.0f;
 268         }
 269
 270         if (distanceY > 100.0f)
 271         {
 272                 particle.position_[1] = -100.0f + distanceY - 100.0f;
 273         }
 274         else if (distanceY < -100.0f)
 275         {
 276                 particle.position_[1] = 100.0f + distanceY + 100.0f;
 277         }*/
 278 }
 279
 280 ParticleRendererSnow *ParticleRendererSnow::getInstance()
 281 {
 282         static ParticleRendererSnow instance_;
 283         return &instance_;
 284 }
 285
 286 void ParticleRendererSnow::renderParticle(Particle &particle)
 287 {
 288         ParticleRendererQuads::getInstance()->renderParticle(particle);
 289 }
 290
 291 void ParticleRendererSnow::simulateParticle(Particle &particle, float time)
 292 {
 293         if (particle.position_[2] < 0.0f)
 294         {
 295                 particle.life_ = 0.0f;
 296                 return;
 297         }
 298
 299         // Alpha
 300         const float MaxDist = 200.0f * 200.0f;
 301         float alpha = 0.0f;
 302         if (particle.distance_ < MaxDist)
 303         {
 304                 alpha = 0.7f * (1.0f - (particle.distance_ / MaxDist));
 305         }
 306         particle.alpha_ = alpha;
 307 }
 308
 309 ParticleRendererWall *ParticleRendererWall::getInstance()
 310 {
 311         static ParticleRendererWall instance_;
 312         return &instance_;
 313 }
 314
 315 void ParticleRendererWall::renderParticle(Particle &particle)
 316 {
 317         WallActionRenderer *renderer = (WallActionRenderer *)
 318                 particle.userData_;
 319         renderer->draw();
 320 }
 321
 322 void ParticleRendererWall::simulateParticle(Particle &particle, float time)
 323 {
 324         WallActionRenderer *renderer = (WallActionRenderer *)
 325                 particle.userData_;
 326         renderer->simulate(time);
 327 }