nel/src/3d/cloud_scape.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18 #include "nel/3d/cloud_scape.h"
  19 #include "nel/3d/driver.h"
  20 #include "nel/3d/scissor.h"
  21 #include "nel/3d/viewport.h"
  22
  23 // ------------------------------------------------------------------------------------------------
  24 using namespace NLMISC;
  25
  26 #ifdef DEBUG_NEW
  27 #define new DEBUG_NEW
  28 #endif
  29
  30 namespace NL3D
  31 {
  32
  33 // ------------------------------------------------------------------------------------------------
  34 #define SQR(x) (x)*(x)
  35
  36 #define MAX_DIST        400.0f
  37 #define MAX_CLOUDS      256
  38 // QUEUE_SIZE must be at least 2*MAX_CLOUDS
  39 #define QUEUE_SIZE      512
  40 static const double MAX_CLOUDS_ANIM_DELTA_TIME = 0.075;                           // maximum delta time handled by cloud animation, delta t above that are clamped
  41 static const double MIN_CLOUDS_ANIM_DELTA_TIME = 0.005;                           // minimum delta time handled by clouds animation
  42 static const double MAX_TIME_FOR_CLOUD_ANIM = 0.02;                                       // max number of second spent for cloud render before we check if too slow
  43 static const double MAX_FRAME_PERCENT_FOR_CLOUD_RENDERING = 20 / 100; // at most 20 % of the frame for cloud render
  44
  45
  46 // ------------------------------------------------------------------------------------------------
  47 // SCloudTexture3D
  48 // ------------------------------------------------------------------------------------------------
  49
  50 // ------------------------------------------------------------------------------------------------
  51 SCloudTexture3D::SCloudTexture3D ()
  52 {
  53         Mem = NULL;
  54         Mem2 = NULL;
  55         MemBuffer = NULL;
  56         ToLightRGB.initUnlit();
  57         ToLightRGB.setShader (CMaterial::Normal);
  58         ToLightRGB.setZFunc (CMaterial::always);
  59         ToLightRGB.setZWrite (false);
  60         ToLightRGB.texEnvOpRGB (0, CMaterial::Replace);
  61         ToLightRGB.texEnvArg0RGB (0, CMaterial::Diffuse, CMaterial::SrcColor);
  62         ToLightRGB.texEnvOpAlpha (0, CMaterial::Replace);
  63         ToLightRGB.texEnvArg0Alpha (0, CMaterial::Texture, CMaterial::SrcAlpha);
  64         ToLightRGB.setBlend (true);
  65         ToLightRGB.setBlendFunc (CMaterial::invsrcalpha, CMaterial::srcalpha);
  66         ToLightRGB.setColor (CRGBA(0,0,0,255));
  67         ToLightAlpha.initUnlit();
  68         ToLightAlpha.setShader (CMaterial::Normal);
  69         ToLightAlpha.setZFunc (CMaterial::always);
  70         ToLightAlpha.setZWrite (false);
  71         ToLightAlpha.texEnvOpRGB (0, CMaterial::Replace);
  72         ToLightAlpha.texEnvArg0RGB (0, CMaterial::Diffuse, CMaterial::SrcColor);
  73         ToLightAlpha.texEnvOpAlpha (0, CMaterial::Replace);
  74         ToLightAlpha.texEnvArg0Alpha (0, CMaterial::Texture, CMaterial::InvSrcAlpha);
  75         ToLightAlpha.setColor (CRGBA(0,0,0,255));
  76
  77         ToBill.initUnlit();
  78         ToBill.setZFunc (CMaterial::always);
  79         ToBill.setZWrite (false);
  80         ToBill.setDoubleSided(true);
  81
  82         ToBill.texEnvOpRGB (0, CMaterial::Add);
  83         ToBill.texEnvArg0RGB (0, CMaterial::Texture, CMaterial::SrcColor);
  84         ToBill.texEnvArg1RGB (0, CMaterial::Diffuse, CMaterial::SrcColor);
  85         ToBill.setColor (CRGBA(80,80,80,255));
  86
  87         ToBill.texEnvOpAlpha (0, CMaterial::Replace);
  88         ToBill.texEnvArg0Alpha (0, CMaterial::Texture, CMaterial::SrcAlpha);
  89
  90         ToBill.texEnvOpRGB (1, CMaterial::Modulate);
  91         ToBill.texEnvArg0RGB (1, CMaterial::Previous, CMaterial::SrcColor);
  92         ToBill.texEnvArg1RGB (1, CMaterial::Previous, CMaterial::SrcAlpha);
  93         ToBill.texEnvOpAlpha (1, CMaterial::Replace);
  94         ToBill.texEnvArg0Alpha (1, CMaterial::Previous, CMaterial::SrcAlpha);
  95
  96         ToBill.setBlendFunc (CMaterial::one, CMaterial::invsrcalpha);
  97         ToBill.setBlend (true);
  98
  99         MatCopy.initUnlit();
 100         MatCopy.setShader (CMaterial::Normal);
 101         MatCopy.setZFunc (CMaterial::always);
 102         MatCopy.setZWrite (false);
 103         MatCopy.texEnvOpRGB (0, CMaterial::Replace);
 104         MatCopy.texEnvArg0RGB (0, CMaterial::Texture, CMaterial::SrcColor);
 105         MatCopy.texEnvOpAlpha (0, CMaterial::Replace);
 106         MatCopy.texEnvArg0Alpha (0, CMaterial::Texture, CMaterial::SrcAlpha);
 107         MatCopy.setBlend (false);
 108         MatCopy.setColor (CRGBA(255,255,255,255));
 109 }
 110
 111 // ------------------------------------------------------------------------------------------------
 112 void SCloudTexture3D::init (uint32 nWidth, uint32 nHeight, uint32 nDepth)
 113 {
 114         if (Mem != NULL)
 115                 return;
 116
 117         Width = raiseToNextPowerOf2 (nWidth);
 118         Height = raiseToNextPowerOf2 (nHeight);
 119         Depth = raiseToNextPowerOf2 (nDepth);
 120         uint32 vdpo2 = getPowerOf2(Depth);
 121         NbW = 1 << (vdpo2 / 2);
 122         if ((vdpo2 & 1) != 0)
 123                 NbH = 2 << (vdpo2 / 2);
 124         else
 125                 NbH = 1 << (vdpo2 / 2);
 126
 127         Mem = new uint8[4*NbW*Width*NbH*Height];
 128         Mem2 = new uint8[4*NbW*Width*NbH*Height];
 129         MemBuffer = new uint8[4*Width*Height];
 130         Tex = new CTextureMem (Mem, 4*NbW*Width*NbH*Height, true, false, NbW*Width, NbH*Height, CBitmap::RGBA);
 131         Tex2 = new CTextureMem (Mem2, 4*NbW*Width*NbH*Height, true, false, NbW*Width, NbH*Height, CBitmap::RGBA);
 132         TexBuffer = new CTextureMem (MemBuffer, 4*Width*Height, true, false, Width, Height, CBitmap::RGBA);
 133
 134         Tex->setWrapS (ITexture::Clamp);
 135         Tex->setWrapT (ITexture::Clamp);
 136         Tex->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
 137         Tex->setReleasable (false);
 138         Tex->setRenderTarget (true);
 139         Tex->generate ();
 140         Tex2->setWrapS (ITexture::Clamp);
 141         Tex2->setWrapT (ITexture::Clamp);
 142         Tex2->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
 143         Tex2->setReleasable (false);
 144         Tex2->setRenderTarget (true);
 145         Tex2->generate ();
 146         TexBuffer->setWrapS (ITexture::Clamp);
 147         TexBuffer->setWrapT (ITexture::Clamp);
 148         TexBuffer->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
 149         TexBuffer->setReleasable (false);
 150         TexBuffer->setRenderTarget (true);
 151         TexBuffer->generate ();
 152
 153         ToLightRGB.setTexture (0, Tex);
 154         ToLightAlpha.setTexture (0, Tex);
 155         ToBill.setTexture(0, Tex2);
 156         ToBill.setTexture(1, Tex2);
 157         MatCopy.setTexture(0, TexBuffer);
 158 }
 159
 160 // ------------------------------------------------------------------------------------------------
 161 // SCloudTextureClamp
 162 // ------------------------------------------------------------------------------------------------
 163
 164 // ------------------------------------------------------------------------------------------------
 165 SCloudTextureClamp::SCloudTextureClamp ()
 166 {
 167         Mem = NULL;
 168         ToClamp.initUnlit();
 169         ToClamp.setShader (CMaterial::Normal);
 170         ToClamp.texEnvOpAlpha (0, CMaterial::Add);
 171         ToClamp.texEnvArg0Alpha (0, CMaterial::Texture, CMaterial::SrcAlpha);
 172         ToClamp.texEnvArg1Alpha (0, CMaterial::Diffuse, CMaterial::SrcAlpha);
 173         ToClamp.setColor (CRGBA(255,255,255,255));
 174         ToClamp.setBlend (true);
 175         ToClamp.setBlendFunc (CMaterial::one, CMaterial::one);
 176         ToClamp.setZFunc (CMaterial::always);
 177         ToClamp.setZWrite (false);
 178
 179 }
 180
 181 // ------------------------------------------------------------------------------------------------
 182 void SCloudTextureClamp::init (uint32 nWidth, uint32 nHeight, uint32 nDepth, const std::string &filename)
 183 {
 184         if (Mem != NULL)
 185                 return;
 186
 187         Width = raiseToNextPowerOf2 (nWidth);
 188         Height = raiseToNextPowerOf2 (nHeight);
 189         Depth = raiseToNextPowerOf2 (nDepth);
 190         uint32 vdpo2 = getPowerOf2(Depth);
 191         NbW = 1 << (vdpo2 / 2);
 192         if ((vdpo2 & 1) != 0)
 193                 NbH = 2 << (vdpo2 / 2);
 194         else
 195                 NbH = 1 << (vdpo2 / 2);
 196
 197         Mem = new uint8[NbW*Width*NbH*Height];
 198         uint32 i, j;
 199
 200         if (filename.empty())
 201         {
 202                 // No filename so init with default
 203                 for (i = 0; i < NbW; ++i)
 204                 {
 205                         for (j = 0; j < NbH; ++j)
 206                         {
 207                                 uint32 d = i+j*NbW;
 208                                 uint32 k, l;
 209                                 for (k = 0; k < Width; ++k)
 210                                 for (l = 0; l < Height; ++l)
 211                                 {
 212                                         float x = k+0.5f;
 213                                         float y = l+0.5f;
 214                                         float z = d+0.5f;
 215                                         float xc = Width/2.0f;
 216                                         float yc = Height/2.0f;
 217                                         float zc = Depth/2.0f;
 218
 219                                         float r = (x-xc)*(x-xc)/(Width*Width/4.0f) + (y-yc)*(y-yc)/(Height*Height/4.0f)
 220                                                         + (z-zc)*(z-zc)/(Depth*Depth/4.0f);
 221
 222                                         uint8 col = 255;
 223                                         if (r < 1.0f)
 224                                         {
 225                                                 col = (uint8)((r)*223+32);
 226                                         }
 227                                         Mem[i*Width+k + (j*Height+l)*NbW*Width] = col;
 228                                 }
 229                         }
 230                 }
 231         }
 232         else
 233         {
 234                 // Load file TODO !
 235         }
 236
 237         Tex = new CTextureMem (Mem, NbW*Width*NbH*Height, true, false, NbW*Width, NbH*Height, CBitmap::Alpha);
 238         Tex->setWrapS (ITexture::Repeat);
 239         Tex->setWrapT (ITexture::Repeat);
 240         Tex->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
 241
 242         Tex->touch();
 243         Tex->setReleasable (false);
 244         Tex->generate();
 245
 246         ToClamp.setTexture(0, Tex);
 247
 248 }
 249
 250
 251 // ------------------------------------------------------------------------------------------------
 252 // CCloudScape
 253 // ------------------------------------------------------------------------------------------------
 254
 255 // ------------------------------------------------------------------------------------------------
 256 CCloudScape::CCloudScape (NL3D::IDriver *pDriver) : _Noise3D (pDriver)
 257 {
 258         _Driver = pDriver;
 259         // Misc purpose VB
 260         _VertexBuffer.setVertexFormat (CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag | CVertexBuffer::TexCoord1Flag);
 261         _VertexBuffer.setNumVertices (4);
 262         _VertexBuffer.setName("CloudScape");
 263
 264         // Material used for cleaning
 265         _MatClear.initUnlit();
 266         _MatClear.setDoubleSided (true);
 267         _MatClear.setZFunc (CMaterial::always);
 268         _MatClear.setZWrite (false);
 269         _MatClear.setBlend (false);
 270
 271         _MatBill.initUnlit();
 272         _MatBill.setShader (CMaterial::Normal); // not needed
 273
 274         _MatBill.texEnvOpRGB (0, CMaterial::Replace);
 275         _MatBill.texEnvArg0RGB (0, CMaterial::Texture, CMaterial::SrcColor);
 276
 277         _MatBill.texEnvOpAlpha (0, CMaterial::Replace);
 278         _MatBill.texEnvArg0Alpha (0, CMaterial::Texture, CMaterial::SrcAlpha);
 279
 280         _MatBill.texEnvOpRGB (1, CMaterial::InterpolateDiffuse);
 281         _MatBill.texEnvArg0RGB (1, CMaterial::Texture, CMaterial::SrcColor);
 282         _MatBill.texEnvArg1RGB (1, CMaterial::Previous, CMaterial::SrcColor);
 283
 284         _MatBill.texEnvOpAlpha (1, CMaterial::InterpolateDiffuse);
 285         _MatBill.texEnvArg0Alpha (1, CMaterial::Texture, CMaterial::SrcAlpha);
 286         _MatBill.texEnvArg1Alpha (1, CMaterial::Previous, CMaterial::SrcAlpha);
 287
 288         _MatBill.setBlend (true);
 289         _MatBill.setBlendFunc(CMaterial::one, CMaterial::invsrcalpha);
 290         _MatBill.setZFunc (CMaterial::always);
 291         _MatBill.setZWrite (false);
 292         _MatBill.setDoubleSided (true);
 293         _MatBill.setAlphaTest(true);
 294         _MatBill.setAlphaTestThreshold(2.0f/256.0f);
 295
 296         _LODQualityThreshold = 160.0f;
 297         _IsIncomingCSS = false;
 298         _DebugQuad = false;
 299         _NbHalfCloudToUpdate = 1;
 300         _CurrentCloudInProcess = NULL;
 301
 302         _LastAnimRenderTime = 0;
 303         _MaxDeltaTime = 0.1; // 100 ms
 304 }
 305
 306 // ------------------------------------------------------------------------------------------------
 307 CCloudScape::~CCloudScape ()
 308 {
 309 }
 310
 311 // ------------------------------------------------------------------------------------------------
 312 void CCloudScape::init (SCloudScapeSetup *pCSS, NL3D::CCamera *pCamera)
 313 {
 314         _ResetCounter = _Driver->getResetCounter();
 315         _ViewerCam = pCamera;
 316
 317         _Noise3D.init();
 318
 319         _AllClouds.resize (MAX_CLOUDS, CCloud(this));
 320         _CloudPower.resize (MAX_CLOUDS);
 321         _ShouldProcessCloud.resize (MAX_CLOUDS);
 322
 323         // For the moment only one clamp texture (generated)
 324         Tex3DTemp.init (64, 32, 32);
 325         TexClamp.init (64, 32, 32,"");
 326
 327         if (pCSS != NULL)
 328         {
 329                 _CurrentCSS = *pCSS;
 330                 _NewCSS = *pCSS;
 331                 _OldCSS = *pCSS;
 332         }
 333         _IsIncomingCSS = false;
 334         _TimeNewCSS = 60.0*60.0;
 335
 336         uint32 i;
 337         for (i = 0; i < MAX_CLOUDS; ++i)
 338         {
 339                 float newX, newY, newZ, newSizeX, newSizeY, newSizeZ;
 340
 341                 CCloud &c = _AllClouds[i];
 342
 343                 c.setTex3DTemp (Tex3DTemp);
 344                 c.setTexClamp (TexClamp);
 345
 346                 for(;;)
 347                 {
 348                         bool bRecalc = false;
 349                         newX = MAX_DIST*(1.0f-2.0f*(((float)rand())/RAND_MAX));
 350                         newY = MAX_DIST*(1.0f-2.0f*(((float)rand())/RAND_MAX));
 351                         newZ = 85.0f+40.0f*(1.0f-2.0f*(((float)rand())/RAND_MAX));
 352
 353                         newSizeX = 60.0f+10.0f*(1.0f-2.0f*(((float)rand())/RAND_MAX));
 354                         newSizeY = 30.0f+10.0f*(1.0f-2.0f*(((float)rand())/RAND_MAX));
 355                         newSizeZ = 30.0f+10.0f*(1.0f-2.0f*(((float)rand())/RAND_MAX));
 356                         float f = 0.7f+0.3f*((float)rand())/RAND_MAX;
 357                         newSizeX *= 1.5f*f;
 358                         newSizeY *= 1.5f*f;
 359                         newSizeZ *= 1.5f*f;
 360
 361                         float d = sqrtf(SQR(newX)+SQR(newY));
 362                         if (d > MAX_DIST) bRecalc = true;
 363
 364                         for (uint32 k = 0;k < i; ++k)
 365                         {
 366                                 CCloud &c2 = _AllClouds[k];
 367
 368                                 if ((fabs(newX-c2.getX()) < (newSizeX/2+c2.getSizeX()/2)) &&
 369                                         (fabs(newY-c2.getY()) < (newSizeY/2+c2.getSizeY()/2)) &&
 370                                         (fabs(newZ-c2.getZ()) < (newSizeZ/2+c2.getSizeZ()/2)))
 371                                         bRecalc = true;
 372                         }
 373                         if (!bRecalc) break;
 374                 }
 375
 376                 c.init (64, 32, 32, 0.122f, 4);
 377                 c.setX (newX-newSizeX/2);
 378                 c.setY (newY-newSizeY/2);
 379                 c.setZ (newZ-newSizeZ/2);
 380
 381                 c.setSizeX (newSizeX);
 382                 c.setSizeY (newSizeY);
 383                 c.setSizeZ (newSizeZ);
 384
 385                 c.Time = 0;
 386                 c.FuturTime = _CurrentCSS.NbCloud * 2 * (0.04/_NbHalfCloudToUpdate);
 387                 if (i < _CurrentCSS.NbCloud)
 388                 {
 389                         _CloudPower[i] = 255;
 390                         _ShouldProcessCloud[i] = true;
 391                 }
 392                 else
 393                 {
 394                         _CloudPower[i] = 0;
 395                         _ShouldProcessCloud[i] = false;
 396                 }
 397         }
 398
 399         _SortedClouds.resize (MAX_CLOUDS);
 400
 401         _CloudSchedulerSize = _CurrentCSS.NbCloud;
 402         _CloudSchedulerLastAdded.resize (MAX_CLOUDS);
 403         _FrameCounter = 0;
 404         _CloudScheduler.clear();
 405         for (i = 0; i < MAX_CLOUDS; ++i)
 406                 _CloudSchedulerLastAdded[i].ValidPos = false;
 407
 408         if (_CurrentCSS.NbCloud == 0)
 409         {
 410                 for (i = 0; i < QUEUE_SIZE; ++i)
 411                 {
 412                         SCloudSchedulerEntry cse;
 413                         cse.CloudIndex = -1;
 414                         cse.Frame = _FrameCounter;
 415                         cse.Ambient = _CurrentCSS.Ambient;
 416                         cse.Diffuse = _CurrentCSS.Diffuse;
 417                         _CloudScheduler.insert(_CloudScheduler.end(), cse);
 418                         ++_FrameCounter;
 419                 }
 420         }
 421         else
 422         {
 423                 for (i = 0; i < QUEUE_SIZE; ++i)
 424                 {
 425                         sint32 nCloudNb;
 426                         nCloudNb = i%_CurrentCSS.NbCloud;
 427                         SCloudSchedulerEntry cse;
 428                         cse.CloudIndex = nCloudNb;
 429                         if (_CloudSchedulerLastAdded[nCloudNb].ValidPos == true)
 430                         {
 431                                 SCloudSchedulerEntry &lastCSE = *_CloudSchedulerLastAdded[nCloudNb].Pos;
 432                                 sint32 delta = _FrameCounter - lastCSE.Frame;
 433                                 lastCSE.DeltaNextCalc = delta;
 434                         }
 435                         cse.Frame = _FrameCounter;
 436                         cse.Ambient = _CurrentCSS.Ambient;
 437                         cse.Diffuse = _CurrentCSS.Diffuse;
 438                         cse.Power = _CloudPower[cse.CloudIndex];
 439                         _CloudSchedulerLastAdded[cse.CloudIndex].Pos = _CloudScheduler.insert(_CloudScheduler.end(), cse);
 440                         _CloudSchedulerLastAdded[cse.CloudIndex].ValidPos = true;
 441                         //_CloudSchedulerLastAdded[cse.CloudIndex].Pos = _CloudScheduler.end()-1;
 442                         ++_FrameCounter;
 443                 }
 444         }
 445
 446         _GlobalTime = 0.0f;
 447         _DTRest = 0.0f;
 448         _Generate = true;
 449         _AverageFrameRate.init(16);
 450         for (i = 0; i < 16; ++i)
 451                 _AverageFrameRate.addValue (40.0f/1000.0f);
 452
 453         _ExtrapolatedPriorities.resize (MAX_CLOUDS);
 454
 455         for (i = 0; i < QUEUE_SIZE; ++i)
 456                 anim (41.0/1000.0, _ViewerCam);
 457 }
 458
 459 // ------------------------------------------------------------------------------------------------
 460 void CCloudScape::set (SCloudScapeSetup &css)
 461 {
 462         _IncomingCSS = css;
 463         _IsIncomingCSS = true;
 464 }
 465
 466 // ------------------------------------------------------------------------------------------------
 467 void CCloudScape::anim (double dt, NL3D::CCamera *pCamera)
 468 {
 469         double startDate = double(CTime::getLocalTime())/1000.0;
 470         sint32 i;
 471
 472         // Disable fog
 473         bool fog = _Driver->fogEnabled();
 474         _Driver->enableFog (false);
 475
 476         _ViewerCam = pCamera;
 477
 478         // update the max delta time
 479         // If rendering was too slow and took too much time of the previous frame, we decrease the max delta time to give clouds less processing time
 480         // Otherwise a cycle occurs, and slow rendering propagate from frame to frame
 481
 482
 483
 484         if (dt != 0 && _LastAnimRenderTime > MAX_TIME_FOR_CLOUD_ANIM && (_LastAnimRenderTime / dt) > MAX_FRAME_PERCENT_FOR_CLOUD_RENDERING)
 485         {
 486                 // if cloud rendering take too much time of previous frame, allocate less time for clouds
 487                 // NB : check is only done if clouds rendering is above a given thrheshold, because if only clouds are rendered, then they may take 100% of frame without
 488                 // having slow rendering
 489                 _MaxDeltaTime = std::max(MIN_CLOUDS_ANIM_DELTA_TIME, _MaxDeltaTime / 2);
 490         }
 491         else
 492         {
 493                 // clouds didn't take too much time  -> allocate more time for them
 494                 _MaxDeltaTime = std::min(MAX_CLOUDS_ANIM_DELTA_TIME , _MaxDeltaTime + 0.002);
 495         }
 496
 497
 498
 499         // 10 fps -> 200 fps
 500         if (dt > _MaxDeltaTime) dt = _MaxDeltaTime;
 501         if (dt < MIN_CLOUDS_ANIM_DELTA_TIME) dt = MIN_CLOUDS_ANIM_DELTA_TIME;
 502
 503
 504         _DeltaTime = dt;
 505         _GlobalTime += _DeltaTime;
 506         _AverageFrameRate.addValue ((float)_DeltaTime);
 507
 508         // Animate the CSS
 509         if (_TimeNewCSS > _NewCSS.TimeToChange)
 510         {
 511                 _CurrentCSS = _NewCSS;
 512                 _OldCSS = _NewCSS;
 513                 if (_IsIncomingCSS)
 514                 {
 515                         _IsIncomingCSS = false;
 516                         _NewCSS = _IncomingCSS;
 517                         _TimeNewCSS = 0;
 518                         if (_NewCSS.NbCloud > _OldCSS.NbCloud)
 519                         for (i = 0; i < (sint32)(_NewCSS.NbCloud-_OldCSS.NbCloud); ++i)
 520                         {
 521                                 CCloud &c = _AllClouds[_OldCSS.NbCloud+i];
 522                                 c.CloudPower = 0;
 523                                 _CloudPower[_OldCSS.NbCloud+i] = 0;
 524                         }
 525                 }
 526         }
 527         else
 528         {
 529                 float inter = (float)(_TimeNewCSS / _NewCSS.TimeToChange);
 530                 _CurrentCSS.WindSpeed = (_NewCSS.WindSpeed - _OldCSS.WindSpeed)*inter + _OldCSS.WindSpeed;
 531                 _CurrentCSS.CloudSpeed = (_NewCSS.CloudSpeed - _OldCSS.CloudSpeed)*inter + _OldCSS.CloudSpeed;
 532
 533                 _CurrentCSS.Ambient.R = (uint8)((_NewCSS.Ambient.R - _OldCSS.Ambient.R)*inter + _OldCSS.Ambient.R);
 534                 _CurrentCSS.Ambient.G = (uint8)((_NewCSS.Ambient.G - _OldCSS.Ambient.G)*inter + _OldCSS.Ambient.G);
 535                 _CurrentCSS.Ambient.B = (uint8)((_NewCSS.Ambient.B - _OldCSS.Ambient.B)*inter + _OldCSS.Ambient.B);
 536                 _CurrentCSS.Ambient.A = (uint8)((_NewCSS.Ambient.A - _OldCSS.Ambient.A)*inter + _OldCSS.Ambient.A);
 537
 538                 _CurrentCSS.Diffuse.R = (uint8)((_NewCSS.Diffuse.R - _OldCSS.Diffuse.R)*inter + _OldCSS.Diffuse.R);
 539                 _CurrentCSS.Diffuse.G = (uint8)((_NewCSS.Diffuse.G - _OldCSS.Diffuse.G)*inter + _OldCSS.Diffuse.G);
 540                 _CurrentCSS.Diffuse.B = (uint8)((_NewCSS.Diffuse.B - _OldCSS.Diffuse.B)*inter + _OldCSS.Diffuse.B);
 541                 _CurrentCSS.Diffuse.A = (uint8)((_NewCSS.Diffuse.A - _OldCSS.Diffuse.A)*inter + _OldCSS.Diffuse.A);
 542
 543                 if (_NewCSS.NbCloud > _OldCSS.NbCloud)
 544                 {
 545                         // Add some clouds
 546                         float slice = (_NewCSS.TimeToChange/4) / (_NewCSS.NbCloud-_OldCSS.NbCloud);
 547                         sint32 diffCloud = _NewCSS.NbCloud-_OldCSS.NbCloud;
 548
 549                         _CurrentCSS.NbCloud = _OldCSS.NbCloud + (1+(uint32)(_TimeNewCSS/slice));
 550                         if (_CurrentCSS.NbCloud > _NewCSS.NbCloud)
 551                                 _CurrentCSS.NbCloud = _NewCSS.NbCloud;
 552
 553                         for (i = 0; i < diffCloud; ++i)
 554                         {
 555                                 _ShouldProcessCloud[_OldCSS.NbCloud+i] = true;
 556                                 if (_TimeNewCSS < i*slice)
 557                                         _CloudPower[_OldCSS.NbCloud+i] = 1;
 558                                 else if (_TimeNewCSS > (i*slice+3*_NewCSS.TimeToChange/4))
 559                                         _CloudPower[_OldCSS.NbCloud+i] = 255;
 560                                 else
 561                                         _CloudPower[_OldCSS.NbCloud+i] = (uint8)(255*(_TimeNewCSS-i*slice)/(3*_NewCSS.TimeToChange/4));
 562                         }
 563                 }
 564                 else
 565                 {
 566                         // Remove some clouds
 567                         sint32 diffCloud = _OldCSS.NbCloud-_NewCSS.NbCloud;
 568                         if (diffCloud)
 569                         {
 570                                 float slice = (_NewCSS.TimeToChange/4) / (float)diffCloud;
 571                                 _CurrentCSS.NbCloud = _OldCSS.NbCloud;
 572
 573                                 for (i = 0; i < diffCloud; ++i)
 574                                 {
 575                                         if (_TimeNewCSS < i*slice)
 576                                                 _CloudPower[_OldCSS.NbCloud-i-1] = 255;
 577                                         else if (_TimeNewCSS > (i*slice+3*_NewCSS.TimeToChange/4))
 578                                                 _CloudPower[_OldCSS.NbCloud-i-1] = 0;
 579                                         else
 580                                                 _CloudPower[_OldCSS.NbCloud-i-1] = (uint8)(255-255*(_TimeNewCSS-i*slice)/(3*_NewCSS.TimeToChange/4));
 581                                 }
 582                         }
 583                 }
 584         }
 585
 586         // Make the right number of half cloud
 587         _DTRest += dt;
 588
 589         while (_DTRest > (0.04/_NbHalfCloudToUpdate))
 590         {
 591                 makeHalfCloud ();
 592                 _DTRest -= 0.04/_NbHalfCloudToUpdate;
 593
 594                 for (i = 0; i < MAX_CLOUDS; ++i)
 595                 {
 596                         CCloud &c = _AllClouds[i];
 597                         c.Time += 0.04/_NbHalfCloudToUpdate;
 598                 }
 599
 600                 _TimeNewCSS += 0.04/_NbHalfCloudToUpdate;
 601         }
 602
 603         // Backup fog
 604         _Driver->enableFog (fog);
 605
 606         // Has the driver been reseted ?
 607         if (_ResetCounter != _Driver->getResetCounter())
 608         {
 609                 /* Yes. Force the rebuild of all the clouds not setuped in VRAM */
 610                 _ResetCounter = _Driver->getResetCounter();
 611                 i = 0;
 612                 while (i < MAX_CLOUDS)
 613                 {
 614                         while (_ShouldProcessCloud[i] &&
 615                                 (!_AllClouds[i]._TexBill->setupedIntoDriver() || !_AllClouds[i]._TexOldBill->setupedIntoDriver()))
 616                         {
 617                                 // Force a cloudscape rebuild
 618                                 anim (41.0/1000.0, _ViewerCam);
 619                         }
 620                         i++;
 621                 }
 622         }
 623         double endDate = double(CTime::getLocalTime())/1000.0;
 624         _LastAnimRenderTime = endDate - startDate;
 625 }
 626
 627 // ------------------------------------------------------------------------------------------------
 628 void CCloudScape::makeHalfCloud ()
 629 {
 630         CVector Viewer = CVector(0,0,0); //_ViewerCam->getMatrix().getPos();
 631
 632         if (_Generate)
 633         {
 634                 // Find the next cloud in the list
 635                 SCloudSchedulerEntry FrontCSE;
 636
 637                 FrontCSE = _CloudScheduler.front();
 638
 639                 // Is the cloud do not have another reference in the list add it now because it should be processed
 640                 sint32 CloudIndexToAdd = -1;
 641
 642                 if ((FrontCSE.CloudIndex != -1) &&
 643                         (_ShouldProcessCloud[FrontCSE.CloudIndex] == true) &&
 644                         (       (_CloudSchedulerLastAdded[FrontCSE.CloudIndex].ValidPos == false) ||
 645                                 ((_CloudSchedulerLastAdded[FrontCSE.CloudIndex].ValidPos == true) &&
 646                                 (_CloudSchedulerLastAdded[FrontCSE.CloudIndex].Pos == _CloudScheduler.begin()))
 647                         ))
 648                 {
 649                         // It should be added now !
 650                         CloudIndexToAdd = FrontCSE.CloudIndex;
 651                         FrontCSE.DeltaNextCalc = QUEUE_SIZE;
 652                 }
 653                 else if (_CurrentCSS.NbCloud != 0)
 654                 {
 655                         // Choose a Cloud Index To Add at the end of the list
 656                         uint32 nPeriodeMax = _CurrentCSS.NbCloud+_CurrentCSS.NbCloud/10;
 657                         sint32 Priority = -10000;
 658                         uint32 i;
 659
 660                         float sumPrior = 0.0f;
 661                         for (i = 0; i < MAX_CLOUDS; ++i)
 662                         if (_ShouldProcessCloud[i])
 663                         {
 664                                 CCloud &rC = _AllClouds[i];
 665                                 float ExtrapolatedTime = ((0.04f/_NbHalfCloudToUpdate) * QUEUE_SIZE * 2);
 666                                 float x = rC.getLastX () + ExtrapolatedTime * _CurrentCSS.WindSpeed;
 667                                 //float d = sqrtf(SQR(x+rC.getSizeX()/2-Viewer.x)+SQR(rC.getY()+rC.getSizeY()/2-Viewer.y)+
 668                                 //              SQR(rC.getZ()+rC.getSizeZ()/2-Viewer.z));
 669                                 float d = SQR(x+rC.getSizeX()/2-Viewer.x)+SQR(rC.getY()+rC.getSizeY()/2-Viewer.y)+
 670                                                 SQR(rC.getZ()+rC.getSizeZ()/2-Viewer.z);
 671                                 float d05 = sqrtf(d);
 672                                 float d025 = sqrtf(d05);
 673                                 float d075 = d05*d025;
 674
 675                                 _ExtrapolatedPriorities[i] = 1.0f / d075;
 676                                 sumPrior += _ExtrapolatedPriorities[i];
 677                         }
 678
 679                         sint32 sumJeton = 0;
 680                         for (i = 0; i < MAX_CLOUDS; ++i)
 681                         if (_ShouldProcessCloud[i])
 682                         {
 683                                 // Normalize priorities
 684                                 float factor = ((float)QUEUE_SIZE) / sumPrior;
 685                                 sint32 nbJeton = (sint32)(0.5f+(factor * _ExtrapolatedPriorities[i]));
 686
 687                                 if (nbJeton < 1)
 688                                         nbJeton = 1;
 689
 690                                 _ExtrapolatedPriorities[i] = (float)nbJeton;
 691                                 sumJeton += nbJeton;
 692                         }
 693
 694                         if (sumJeton > QUEUE_SIZE)
 695                         {
 696                                 do
 697                                 {
 698                                         for (i = 0; i < MAX_CLOUDS; ++i)
 699                                         if (_ShouldProcessCloud[i])
 700                                         {
 701                                                 if (_ExtrapolatedPriorities[i] > 1)
 702                                                 {
 703                                                         _ExtrapolatedPriorities[i] -= 1;
 704                                                         --sumJeton;
 705                                                         if (sumJeton == QUEUE_SIZE) break;
 706                                                 }
 707                                         }
 708                                 }
 709                                 while (sumJeton > QUEUE_SIZE);
 710                         }
 711
 712                         for (i = 0; i < MAX_CLOUDS; ++i)
 713                         if (_ShouldProcessCloud[i])
 714                         {
 715                                 // Cloud Period
 716                                 sint32 newPriority = nPeriodeMax;
 717                                 // Is there a last entry in array ?
 718                                 if (_CloudSchedulerLastAdded[i].ValidPos == true)
 719                                 {
 720                                         SCloudSchedulerEntry &rLastCSE = *_CloudSchedulerLastAdded[i].Pos;
 721                                         newPriority = (sint32)(QUEUE_SIZE/_ExtrapolatedPriorities[i]);
 722                                         newPriority = (_FrameCounter -  rLastCSE.Frame) - newPriority;
 723                                 }
 724                                 else
 725                                 {
 726                                         newPriority = 10000;
 727                                 }
 728                                 if (newPriority > Priority)
 729                                 {
 730                                         Priority = newPriority;
 731                                         CloudIndexToAdd = i;
 732                                 }
 733                         }
 734                         nlassert (CloudIndexToAdd != -1);
 735                 }
 736
 737                 // Ok now we have a good cloud index to add so make the new cloud entry
 738                 SCloudSchedulerEntry newCSE;
 739
 740                 newCSE.CloudIndex = CloudIndexToAdd;
 741                 newCSE.Frame = _FrameCounter;
 742                 newCSE.Ambient = _CurrentCSS.Ambient;
 743                 newCSE.Diffuse = _CurrentCSS.Diffuse;
 744                 if (CloudIndexToAdd != -1)
 745                 {
 746                         newCSE.Power = _CloudPower[CloudIndexToAdd];
 747
 748                         // If the cloud where added previously to the list
 749                         if (_CloudSchedulerLastAdded[CloudIndexToAdd].ValidPos == true)
 750                         {
 751                                 // This means that the cloud were added from a long time ago
 752                                 SCloudSchedulerEntry &lastCSE = *_CloudSchedulerLastAdded[CloudIndexToAdd].Pos;
 753                                 sint32 delta = _FrameCounter - lastCSE.Frame;
 754                                 lastCSE.DeltaNextCalc = delta;
 755
 756                                 // But the cloud can be removed (if so we have to not process it anymore)
 757                                 if (newCSE.Power == 0)
 758                                         _ShouldProcessCloud[CloudIndexToAdd] = false;
 759                         }
 760                         else
 761                         {
 762                                 // No the cloud do not appear previously in the list... So its a new one
 763                                 _AllClouds[CloudIndexToAdd].reset (_ViewerCam);
 764                         }
 765
 766                         // If the last cloud occurence of the cloud appear at beginning so no more occurence in list
 767                         if (_CloudSchedulerLastAdded[FrontCSE.CloudIndex].Pos == _CloudScheduler.begin())
 768                                 _CloudSchedulerLastAdded[FrontCSE.CloudIndex].ValidPos = false;
 769
 770                         _CloudSchedulerLastAdded[CloudIndexToAdd].Pos = _CloudScheduler.insert(_CloudScheduler.end(), newCSE);
 771                         _CloudSchedulerLastAdded[CloudIndexToAdd].ValidPos = true;
 772                         //_CloudSchedulerLastAdded[CloudIndexToAdd].Pos = _CloudScheduler.end()-1;
 773                 }
 774                 else
 775                 {
 776                         _CloudScheduler.insert(_CloudScheduler.end(), newCSE);
 777                 }
 778                 _CloudScheduler.pop_front ();
 779                 ++_FrameCounter;
 780                 // End of scheduling
 781
 782                 // Get the cloud to process (this must be the next occurence of front cloud)
 783                 std::list<SCloudSchedulerEntry>::iterator it = _CloudScheduler.begin();
 784                 while (it != _CloudScheduler.end())
 785                 {
 786                         SCloudSchedulerEntry &rCSE = *it;
 787                         if (rCSE.CloudIndex == FrontCSE.CloudIndex)
 788                                 break;
 789                         ++it;
 790                 }
 791
 792                 SCloudSchedulerEntry CSEToCalc;
 793                 // The cloud is no more present in the list
 794                 if (it == _CloudScheduler.end())
 795                 {
 796                         FrontCSE.DeltaNextCalc = 1;
 797                         CSEToCalc = FrontCSE;
 798                 }
 799                 else
 800                 {
 801                         CSEToCalc = *it;
 802                 }
 803
 804                 // Is the cloud to calc is a real cloud
 805                 if (CSEToCalc.CloudIndex == -1)
 806                 {
 807                         _CurrentCloudInProcess = NULL;
 808                 }
 809                 else
 810                 {
 811                         _CurrentCloudInProcess = &_AllClouds[CSEToCalc.CloudIndex];
 812                         CCloud &c = *_CurrentCloudInProcess;
 813
 814                         // To go from Front cloud to CSEToCalc cloud we should take the front DeltaNextCalc
 815
 816                         _CurrentCloudInProcessFuturTime = ((0.04/_NbHalfCloudToUpdate) * FrontCSE.DeltaNextCalc * 2);
 817                         c.setX ((float)(c.getLastX() +  _CurrentCloudInProcessFuturTime * _CurrentCSS.WindSpeed));
 818
 819                         float d2D = sqrtf(SQR(c.getX()+c.getSizeX()/2-Viewer.x)+SQR(c.getY()+c.getSizeY()/2-Viewer.y));
 820
 821                         if (d2D > MAX_DIST)
 822                                 c.CloudDistAtt = 255;
 823                         else if (d2D > (MAX_DIST-100.0f))
 824                                 c.CloudDistAtt = (uint8)(255*((d2D-(MAX_DIST-100.0f))/100.0f));
 825                         else
 826                                 c.CloudDistAtt = 0;
 827
 828                         c.LastCloudPower = c.CloudPower;
 829                         c.CloudPower = CSEToCalc.Power;
 830                         c.CloudDiffuse = CSEToCalc.Diffuse;
 831                         c.CloudAmbient = CSEToCalc.Ambient;
 832
 833                         c.anim (_CurrentCloudInProcessFuturTime*_CurrentCSS.CloudSpeed,
 834                                         _CurrentCloudInProcessFuturTime*_CurrentCSS.WindSpeed);
 835
 836                         c.generate (_Noise3D);
 837                 }
 838         }
 839         else
 840         {
 841                 if (_CurrentCloudInProcess != NULL)
 842                 {
 843                         CCloud &c = *_CurrentCloudInProcess;
 844
 845                         c.Time = 0;
 846                         c.FuturTime = _CurrentCloudInProcessFuturTime;
 847                         c.light();
 848
 849                         if (c.getX() > MAX_DIST)
 850                         {
 851                                 c.setX (c.getX() - (2 * MAX_DIST));
 852                                 c.setLooping ();
 853                         }
 854
 855                         float r = sqrtf(SQR(c.getSizeX()/2)+SQR(c.getSizeY()/2)+SQR(c.getSizeZ()/2));
 856                         float d = sqrtf(SQR(c.getX()+c.getSizeX()/2-Viewer.x)+SQR(c.getY()+c.getSizeY()/2-Viewer.y)+
 857                                                         SQR(c.getZ()+c.getSizeZ()/2-Viewer.z));
 858                         uint32 lookAtSize = (uint32)(_LODQualityThreshold*r/d);
 859                         lookAtSize = raiseToNextPowerOf2 (lookAtSize);
 860                         if (lookAtSize > 128) lookAtSize = 128;
 861
 862                         c.genBill (_ViewerCam, lookAtSize);
 863                 }
 864         }
 865         _Generate = !_Generate;
 866 }
 867
 868 // ------------------------------------------------------------------------------------------------
 869 void CCloudScape::render ()
 870 {
 871         uint32 i, j;
 872
 873         CVector Viewer = CVector (0,0,0);
 874
 875         // Disable fog
 876         bool fog = _Driver->fogEnabled();
 877         _Driver->enableFog (false);
 878
 879         CMatrix viewMat;
 880         viewMat = _ViewerCam->getMatrix ();
 881         viewMat.setPos(CVector(0,0,0));
 882         viewMat.invert ();
 883         CScissor s;
 884         s.initFullScreen ();
 885         _Driver->setupScissor (s);
 886         CViewport v;
 887         _Driver->setupViewport (v);
 888         CFrustum f = _ViewerCam->getFrustum();
 889         _Driver->setFrustum (f.Left, f.Right, f.Bottom, f.Top, f.Near, f.Far, f.Perspective);
 890         _Driver->setupViewMatrix (viewMat);
 891         _Driver->setupModelMatrix (CMatrix::Identity);
 892
 893         uint32 nNbCloudToRender = 0;
 894
 895         for (i = 0; i < MAX_CLOUDS; ++i)
 896         {
 897                 CCloud &c = _AllClouds[i];
 898                 SSortedCloudEntry &sce = _SortedClouds[nNbCloudToRender];
 899                 sce.Cloud = &c;
 900                 sce.Distance = sqrtf(SQR(c.getX()+c.getSizeX()/2-Viewer.x)+SQR(c.getY()+c.getSizeY()/2-Viewer.y)+
 901                                                 SQR(c.getZ()+c.getSizeZ()/2-Viewer.z));
 902                 nNbCloudToRender++;
 903         }
 904
 905         for (i = 0; i < nNbCloudToRender-1; ++i)
 906         for (j = i+1; j < nNbCloudToRender; ++j)
 907         {
 908                 if (_SortedClouds[i].Distance < _SortedClouds[j].Distance)
 909                 {
 910                         SSortedCloudEntry sceTmp = _SortedClouds[i];
 911                         _SortedClouds[i] = _SortedClouds[j];
 912                         _SortedClouds[j] = sceTmp;
 913                 }
 914         }
 915
 916         for (i = 0; i < nNbCloudToRender; ++i)
 917         {
 918                 CCloud *pC = _SortedClouds[i].Cloud;
 919                 if ((pC->CloudPower > 0) || (pC->LastCloudPower > 0))
 920                         pC->dispBill (_ViewerCam);
 921         }
 922
 923         // Backup fog
 924         _Driver->enableFog (fog);
 925 }
 926
 927 // ------------------------------------------------------------------------------------------------
 928 uint32 CCloudScape::getMemSize()
 929 {
 930         uint32 nMemSize = 0;
 931         for (uint32 i = 0; i < MAX_CLOUDS; ++i)
 932         {
 933                 CCloud &c = _AllClouds[i];
 934                 nMemSize += c.getMemSize();
 935         }
 936         return nMemSize;
 937 }
 938
 939 } // namespace NL3D
 940