nevrax.org : docs

00001 
+00007 /* Copyright, 2002 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "std3d.h"
+00027 #include "3d/material.h"
+00028 #include "cloud.h"
+00029 #include "cloud_scape.h"
+00030 #include "noise_3d.h"
+00031 #include "nel/3d/scissor.h"
+00032 #include "nel/3d/viewport.h"
+00033 #include "3d/driver.h"
+00034 
+00035 using namespace NLMISC;
+00036 
+00037 namespace NL3D
+00038 {
+00039 
+00040 // ------------------------------------------------------------------------------------------------
+00041 CCloud::CCloud (CCloudScape *pCloudScape)
+00042 {
+00043         _CloudScape = pCloudScape;
+00044         _Driver = _CloudScape->_Driver;
+00045         CloudPower = 255; // Max Power
+00046         LastCloudPower = 255;
+00047         CloudDistAtt = 0;
+00048         CloudDiffuse = CRGBA(255,255,255,255);
+00049         CloudAmbient = CRGBA(120,140,160,255);
+00050         _WaitState = 0;
+00051         _BillSize = 0;
+00052         _OldBillSize = 0;
+00053         _UStart = _VStart = _WStart = NULL;
+00054 }
+00055 
+00056 // ------------------------------------------------------------------------------------------------
+00057 CCloud::~CCloud()
+00058 {
+00059         delete _UStart;
+00060         delete _VStart;
+00061         delete _WStart;
+00062 }
+00063 
+00064 // ------------------------------------------------------------------------------------------------
+00065 void CCloud::init (uint32 nVoxelW, uint32 nVoxelH, uint32 nVoxelD, float rBaseFreq, uint32 nNbOctave)
+00066 {
+00067         if (_UStart != NULL)
+00068                 return;
+00069         
+00070         _BaseFreq = rBaseFreq;
+00071         _BillSize = 0;
+00072         _OldBillSize = 0;
+00073 
+00074         _NbOctave = nNbOctave;
+00075         _UStart = new double[_NbOctave];
+00076         _VStart = new double[_NbOctave];
+00077         _WStart = new double[_NbOctave];
+00078 
+00079         uint32 i;
+00080         for (i = 0; i < _NbOctave; ++i)
+00081         {
+00082                 _UStart[i] = ((double)rand())/RAND_MAX;
+00083                 _VStart[i] = ((double)rand())/RAND_MAX;
+00084                 _WStart[i] = ((double)rand())/RAND_MAX;
+00085         }
+00086 
+00087         _Width = raiseToNextPowerOf2 (nVoxelW);
+00088         _Height = raiseToNextPowerOf2 (nVoxelH);
+00089         _Depth = raiseToNextPowerOf2 (nVoxelD);
+00090         uint32 vdpo2 = getPowerOf2(_Depth);
+00091         _NbW = 1 << (vdpo2 / 2);
+00092         if ((vdpo2 & 1) != 0)
+00093                 _NbH = 2 << (vdpo2 / 2);
+00094         else
+00095                 _NbH = 1 << (vdpo2 / 2);
+00096 
+00097         _MemBill = NULL;
+00098         _MemOldBill = NULL;
+00099 
+00100         float scale = 20.0f + 10.0f*((float)rand())/RAND_MAX;;
+00101         _Size.x = scale * _Width/_Depth;
+00102         scale = 20.0f + 10.0f*((float)rand())/RAND_MAX;;
+00103         _Size.y = scale * _Height/_Depth;
+00104         scale = 20.0f + 10.0f*((float)rand())/RAND_MAX;;
+00105         _Size.z = scale * _Depth/_Depth;
+00106 
+00107 }
+00108 
+00109 // ------------------------------------------------------------------------------------------------
+00110 void CCloud::generate (CNoise3d &noise)
+00111 {
+00112         float dU, dV, dW;
+00113         uint32 nOct;
+00114         CQuadUV qc;
+00115 
+00116         // Setup the matrices view&model, viewport and frustum
+00117         setMode2D ();
+00118 
+00119         // Clear background
+00120         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00121         uint32 nVSize = rVB.getVertexSize ();
+00122         CVector *pVertices = (CVector*)rVB.getVertexCoordPointer (0);
+00123         *pVertices = CVector(0.0f,                              0.0f,                           0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00124         *pVertices = CVector((float)_NbW*_Width,0.0f,                           0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00125         *pVertices = CVector((float)_NbW*_Width,(float)_NbH*_Height,0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00126         *pVertices = CVector(0.0f,                              (float)_NbH*_Height,0.0f);
+00127         _CloudScape->_MatClear.setColor (CRGBA(0,0,0,0));
+00128         _Driver->activeVertexBuffer (rVB);
+00129         _Driver->renderQuads (_CloudScape->_MatClear, 0, 1);
+00130 
+00131         // Create cloud from noise
+00132         for (nOct = 0; nOct < _NbOctave; ++nOct)
+00133         {
+00134                 dU = (_BaseFreq*((float)_Width)/noise.getWidth())*(1<<nOct);
+00135                 dV = (_BaseFreq*((float)_Height)/noise.getHeight())*(1<<nOct);
+00136                 dW = (_BaseFreq*((float)_Depth)/noise.getDepth())*(1<<nOct);
+00137 
+00138 
+00139                 noise.renderGrid (_NbW, _NbH, _Width, _Height, 
+00140                                                 (float)_UStart[nOct], (float)_VStart[nOct], (float)_WStart[nOct], dU, dV, dW, 
+00141                                                 1.0f/(2<<nOct));
+00142 
+00143                 /* This is the same thing as a renderGrid which is optimized to do that 
+00144                 qc.Uv0 = CUV((float)_UStart[nOct],              (float)_VStart[nOct]);
+00145                 qc.Uv1 = CUV((float)_UStart[nOct]+dU,   (float)_VStart[nOct]);
+00146                 qc.Uv2 = CUV((float)_UStart[nOct]+dU,   (float)_VStart[nOct]+dV);
+00147                 qc.Uv3 = CUV((float)_UStart[nOct],              (float)_VStart[nOct]+dV);
+00148                 uint32 i,j;
+00149                 for (j = 0; j < _NbH; ++j)
+00150                 {
+00151                         for (i = 0; i < _NbW; ++i)
+00152                         {
+00153                                 qc.V0 = CVector((float)i*_Width,                (float)j*_Height,               0.0f);
+00154                                 qc.V1 = CVector((float)(i+1)*_Width,    (float)j*_Height,               0.0f);
+00155                                 qc.V2 = CVector((float)(i+1)*_Width,    (float)(j+1)*_Height,   0.0f);
+00156                                 qc.V3 = CVector((float)i*_Width,                (float)(j+1)*_Height,   0.0f);
+00157                                 noise.render (qc, (float)_WStart[nOct]+dW*(i+(float)j*_NbW)/(((float)_NbW)*_NbH), 1.0f/(2<<nOct));
+00158                         }
+00159                 }*/
+00160                 noise.flush ();
+00161         }
+00162 
+00163         // Apply attenuation texture (not needed to resetup position again (done when clearing to black))
+00164         CUV *pUV = (CUV*)rVB.getTexCoordPointer (0, 0);
+00165         pUV->U = 0.0f;          pUV->V = 0.0f;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00166         pUV->U = 1.0f;          pUV->V = 0.0f;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00167         pUV->U = 1.0f;          pUV->V = 1.0f;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00168         pUV->U = 0.0f;          pUV->V = 1.0f;
+00169         uint8 colpow = (uint8)(255-(((uint32)CloudPower*(255-(uint32)CloudDistAtt)) / 255));
+00170         _CloudTexClamp->ToClamp.setColor (CRGBA(255, 255, 255, colpow));
+00171         _Driver->activeVertexBuffer (rVB);
+00172         _Driver->renderQuads (_CloudTexClamp->ToClamp, 0, 1);
+00173 
+00174         // We have generated to the screen the texture cloud so now copy from screen to the texture
+00175         _Driver->copyFrameBufferToTexture (_CloudTexTmp->Tex, 0, 0, 0, 0, 0, _Width*_NbW, _Height*_NbH);
+00176 
+00177         _CloudTexTmp->Tex->setFilterMode (ITexture::Nearest, ITexture::NearestMipMapOff);
+00178 }
+00179 
+00180 
+00181 // ------------------------------------------------------------------------------------------------
+00182 void CCloud::light ()
+00183 {
+00184         uint32 i, j;
+00185 
+00186         // Setup the matrices view&model, viewport and frustum
+00187         setMode2D ();
+00188 
+00189         // Destination position for lighting accumulation buffer from (0, 0) size (_Width, _Height)
+00190         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00191         uint32 nVSize = rVB.getVertexSize ();
+00192         CVector *pVertices = (CVector*)rVB.getVertexCoordPointer (0);
+00193         *pVertices = CVector((float)0.0f,       (float)0.0f,    0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00194         *pVertices = CVector((float)_Width,     (float)0.0f,    0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00195         *pVertices = CVector((float)_Width,     (float)_Height, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00196         *pVertices = CVector((float)0.0f,       (float)_Height, 0.0f);
+00197 
+00198         // Clear the screen accumulatorfor lighting
+00199         CloudDiffuse.A = 255;
+00200         _CloudScape->_MatClear.setColor (CloudDiffuse);
+00201         _Driver->activeVertexBuffer (rVB);
+00202         _Driver->renderQuads (_CloudScape->_MatClear, 0, 1);
+00203 
+00204         CUV *pUV;
+00205         // Lighting : render the alpha of one layer into rgb of the screen
+00206         float oneOverNbW = 1.0f/_NbW;
+00207         float oneOverNbH = 1.0f/_NbH;
+00208         uint32 previ, prevj;
+00209         _Driver->activeVertexBuffer (rVB);
+00210         for (j = 0; j < _NbH; ++j)
+00211         {
+00212                 for (i = 0; i < _NbW; ++i)
+00213                 {
+00214                         // Add the alpha of the previous layer into the RGB of the destination
+00215                         if ((i+j) > 0)
+00216                         {
+00217                                 _Driver->setColorMask (true, true, true, false);
+00218                                 pUV = (CUV*)rVB.getTexCoordPointer (0, 0);
+00219                                 pUV->U = previ*oneOverNbW;              pUV->V = prevj*oneOverNbH;              pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00220                                 pUV->U = (previ+1)*oneOverNbW;  pUV->V = prevj*oneOverNbH;              pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00221                                 pUV->U = (previ+1)*oneOverNbW;  pUV->V = (prevj+1)*oneOverNbH;  pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00222                                 pUV->U = previ*oneOverNbW;              pUV->V = (prevj+1)*oneOverNbH;
+00223 
+00224                                 _CloudTexTmp->ToLight.setBlend (true);
+00225                                 _Driver->renderQuads (_CloudTexTmp->ToLight, 0, 1);
+00226                         }
+00227                         // Replace the alpha of the destination by the alpha of the current layer
+00228                         _Driver->setColorMask (false, false, false, true);
+00229 
+00230                         pUV = (CUV*)rVB.getTexCoordPointer (0, 0);
+00231                         pUV->U = i*oneOverNbW;          pUV->V = j*oneOverNbH;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00232                         pUV->U = (i+1)*oneOverNbW;      pUV->V = j*oneOverNbH;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00233                         pUV->U = (i+1)*oneOverNbW;      pUV->V = (j+1)*oneOverNbH;      pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00234                         pUV->U = i*oneOverNbW;          pUV->V = (j+1)*oneOverNbH;
+00235 
+00236                         _CloudTexTmp->ToLight.setBlend (false);
+00237                         _Driver->renderQuads (_CloudTexTmp->ToLight, 0, 1);
+00238 
+00239                         // Copy from accumulator to the texture
+00240                         _Driver->copyFrameBufferToTexture(_CloudTexTmp->Tex, 0, i*_Width, j*_Height, 0, 0, _Width, _Height);
+00241                         previ = i;
+00242                         prevj = j;
+00243                 }
+00244         }
+00245         _Driver->setColorMask (true, true, true, true);
+00246 
+00247         _CloudTexTmp->Tex->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
+00248 }
+00249 
+00250 // ------------------------------------------------------------------------------------------------
+00251 void CCloud::reset (NL3D::CCamera *pViewer)
+00252 {
+00253         if (_BillSize != 4)
+00254         {
+00255                 _BillSize = 4;
+00256                 _MemBill = new uint8[4*_BillSize*_BillSize];
+00257                 _TexBill = new CTextureMem (_MemBill, 4*_BillSize*_BillSize, true, false, _BillSize, _BillSize);
+00258                 _TexBill->setWrapS (ITexture::Clamp);
+00259                 _TexBill->setWrapT (ITexture::Clamp);
+00260                 _TexBill->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
+00261                 _TexBill->generate();
+00262                 _TexBill->setReleasable (false);
+00263         }
+00264         if (_OldBillSize != 4)
+00265         {
+00266                 _OldBillSize = 4;
+00267                 _MemOldBill = new uint8[4*_OldBillSize*_OldBillSize];
+00268                 _TexOldBill = new CTextureMem (_MemOldBill, 4*_OldBillSize*_OldBillSize, true, false, _OldBillSize, _OldBillSize);
+00269                 _TexOldBill->setWrapS (ITexture::Clamp);
+00270                 _TexOldBill->setWrapT (ITexture::Clamp);
+00271                 _TexOldBill->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
+00272                 _TexOldBill->generate();
+00273                 _TexOldBill->setReleasable (false);
+00274         }
+00275         setMode2D ();
+00276 
+00277         // Clear background
+00278         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00279         uint32 nVSize = rVB.getVertexSize ();
+00280         CVector *pVertices = (CVector*)rVB.getVertexCoordPointer (0);
+00281         *pVertices = CVector(0.0f, 0.0f, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00282         *pVertices = CVector(5.0f, 0.0f, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00283         *pVertices = CVector(5.0f, 5.0f, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00284         *pVertices = CVector(0.0f, 5.0f, 0.0f);
+00285         _CloudScape->_MatClear.setColor (CRGBA(0,0,0,0));
+00286         _Driver->activeVertexBuffer (rVB);
+00287         _Driver->renderQuads (_CloudScape->_MatClear, 0, 1);
+00288 
+00289         _Driver->copyFrameBufferToTexture (_TexBill, 0, 0, 0, 0, 0, 4, 4);
+00290         _Driver->copyFrameBufferToTexture (_TexOldBill, 0, 0, 0, 0, 0, 4, 4);
+00291 
+00292 //      CMatrix CamMat = pViewer->getMatrix();
+00293 //      CVector Viewer = CamMat.getPos();
+00294         CVector Viewer = CVector(0,0,0);
+00295         CVector Center = CVector (_Pos.x+_Size.x/2, _Pos.y+_Size.y/2, _Pos.z+_Size.z/2);
+00296         CVector Size = _Size;
+00297         CVector I, J, K;
+00298         float Left, Right, Top, Bottom, Near, Far;
+00299 
+00300         calcBill (Viewer, Center, Size, I, J, K, Left, Right, Top, Bottom, Near, Far);
+00301 
+00302         _BillOldCenter = _BillCenter;
+00303         _BillViewer = Viewer;
+00304         _BillCenter = Center;
+00305 
+00306         calcBill (Viewer, Center, Size, I, J, K, Left, Right, Top, Bottom, Near, Far);
+00307 
+00308         _BillOldCenter = _BillCenter;
+00309         _BillViewer = Viewer;
+00310         _BillCenter = Center;
+00311 
+00312 }
+00313 
+00314 // ------------------------------------------------------------------------------------------------
+00315 void CCloud::anim (double dt, double dt2)
+00316 {
+00317         for (uint32 nOct = 0; nOct < _NbOctave; ++nOct)
+00318         {
+00319                 _UStart[nOct] += dt*(1<<nOct) / 5000.0;
+00320                 _VStart[nOct] += dt*(1<<nOct) / 5000.0;
+00321                 _WStart[nOct] += dt*(1<<nOct) / 5000.0;
+00322         }
+00323         //_Pos.x += dt2;
+00324         //Time += dt2;
+00325 }
+00326 
+00327 // ------------------------------------------------------------------------------------------------
+00328 void CCloud::disp ()
+00329 {
+00330         CQuadUV qc;
+00331         qc.Uv0 = CUV(0.0f, 0.0f);
+00332         qc.Uv1 = CUV(1.0f, 0.0f);
+00333         qc.Uv2 = CUV(1.0f, 1.0f);
+00334         qc.Uv3 = CUV(0.0f, 1.0f);
+00335 
+00337         CScissor s;
+00338         s.initFullScreen();
+00339         _Driver->setupScissor (s);
+00340         _Driver->setupViewport (CViewport());
+00341         _Driver->setFrustum (0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, false);
+00342         CVector         I(1,0,0);
+00343         CVector         J(0,0,1);
+00344         CVector         K(0,-1,0);
+00345         CMatrix ViewMatrix;
+00346         ViewMatrix.identity();
+00347         ViewMatrix.setRot(I,J,K, true);
+00348         _Driver->setupViewMatrix(ViewMatrix);
+00349         _Driver->setupModelMatrix(CMatrix::Identity);
+00351 
+00352         uint32 w = _NbW*_Width;
+00353         uint32 h = _NbH*_Height;
+00354         uint32 i = 0;
+00355         qc.V0 = CVector(0.0f/800.0f,    0.0f/600.0f,    0.0f);
+00356         qc.V1 = CVector(w/800.0f,               0.0f/600.0f,    0.0f);
+00357         qc.V2 = CVector(w/800.0f,               h/600.0f,               0.0f);
+00358         qc.V3 = CVector(0.0f/800.0f,    h/600.0f,               0.0f);
+00359         static CMaterial *dispMat = NULL;
+00360         if (dispMat == NULL)
+00361         {
+00362                 dispMat = new CMaterial;
+00363                 dispMat->initUnlit();
+00364                 dispMat->setTexture(0, _CloudTexTmp->Tex);
+00365                 dispMat->texEnvOpRGB(0, CMaterial::Replace);
+00366                 //dispMat->texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcAlpha);
+00367                 dispMat->texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
+00368                 dispMat->setZFunc(CMaterial::always);
+00369                 dispMat->setZWrite(false);
+00370                 dispMat->setDoubleSided(true);
+00371                 dispMat->setBlend (false);
+00372         }
+00373 
+00374         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00375         rVB.setVertexCoord (0, qc.V0);
+00376         rVB.setVertexCoord (1, qc.V1);
+00377         rVB.setVertexCoord (2, qc.V2);
+00378         rVB.setVertexCoord (3, qc.V3);
+00379         rVB.setTexCoord (0, 0, qc.Uv0);
+00380         rVB.setTexCoord (1, 0, qc.Uv1);
+00381         rVB.setTexCoord (2, 0, qc.Uv2);
+00382         rVB.setTexCoord (3, 0, qc.Uv3);
+00383         _Driver->activeVertexBuffer (rVB);
+00384         _Driver->renderQuads (*dispMat, 0, 1);
+00385 }
+00386 
+00387 // ------------------------------------------------------------------------------------------------
+00388 void CCloud::dispXYZ (CMaterial *pMat)
+00389 {
+00390         CQuadUV qc;
+00391         uint32 i,j;
+00392 
+00393         float oneOverNbW = 1.0f / _NbW;
+00394         float oneOverNbH = 1.0f / _NbH;
+00395         float oneOverNbWNbH = 1.0f / (_NbW*_NbH);
+00396         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00397         uint32 nVSize = rVB.getVertexSize ();
+00398         CVector *pVertices;
+00399         CUV *pUV;
+00400         _Driver->activeVertexBuffer (rVB);
+00401 
+00402         if (pMat == NULL)
+00403                 return;
+00404 
+00405         for (j = 0; j < _NbH; ++j)
+00406         {
+00407                 for (i = 0; i < _NbW; ++i)
+00408                 {
+00409                         uint32 d = i+j*_NbW;
+00410 
+00411                         pVertices = (CVector*)rVB.getVertexCoordPointer (0);
+00412                         *pVertices = CVector(_Pos.x,                    _Pos.y,                 _Pos.z+_Size.z*(_NbW*_NbH-d)*oneOverNbWNbH); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00413                         *pVertices = CVector(_Pos.x+_Size.x,    _Pos.y,                 _Pos.z+_Size.z*(_NbW*_NbH-d)*oneOverNbWNbH); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00414                         *pVertices = CVector(_Pos.x+_Size.x,    _Pos.y+_Size.y, _Pos.z+_Size.z*(_NbW*_NbH-d)*oneOverNbWNbH); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00415                         *pVertices = CVector(_Pos.x,                    _Pos.y+_Size.y, _Pos.z+_Size.z*(_NbW*_NbH-d)*oneOverNbWNbH);
+00416 
+00417                         pUV = (CUV*)rVB.getTexCoordPointer (0, 0);
+00418                         pUV->U = i*oneOverNbW;          pUV->V = j*oneOverNbH;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00419                         pUV->U = (i+1)*oneOverNbW;      pUV->V = j*oneOverNbH;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00420                         pUV->U = (i+1)*oneOverNbW;      pUV->V = (j+1)*oneOverNbH;      pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00421                         pUV->U = i*oneOverNbW;          pUV->V = (j+1)*oneOverNbH;
+00422 
+00423                         pUV = (CUV*)rVB.getTexCoordPointer (0, 1);
+00424                         pUV->U = i*oneOverNbW;          pUV->V = j*oneOverNbH;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00425                         pUV->U = (i+1)*oneOverNbW;      pUV->V = j*oneOverNbH;          pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00426                         pUV->U = (i+1)*oneOverNbW;      pUV->V = (j+1)*oneOverNbH;      pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00427                         pUV->U = i*oneOverNbW;          pUV->V = (j+1)*oneOverNbH;
+00428 
+00429                         _Driver->renderQuads (*pMat, 0, 1);
+00430                 }
+00431         }
+00432 }
+00433 
+00434 // ------------------------------------------------------------------------------------------------
+00435 // in ; viewer, center
+00436 // out I,J,K, left,right,top,bottom,near,far
+00437 void CCloud::calcBill (const CVector &Viewer, const CVector &Center, const CVector &Size, CVector &I, CVector &J, CVector &K,
+00438                                 float &Left, float &Right, float &Top, float &Bottom, float &Near, float &Far)
+00439 {
+00440         CVector ViewDir = Center - Viewer;
+00441         float ViewDist = ViewDir.norm();
+00442         ViewDir.normalize();
+00443 
+00444         Left = 1000.0f;
+00445         Right = -1000.0f;
+00446         Top = -1000.0f;
+00447         Bottom = 1000.0f;
+00448         Near = 1000.0f;
+00449         Far = -1000.0f;
+00450 
+00451         if (fabsf(Center.y-Viewer.y) > fabsf(Center.z-Viewer.z))
+00452         {
+00453                 K.set(0, 0, 1);
+00454                 J= ViewDir;
+00455                 I= J^K;
+00456                 K= I^J;
+00457         }
+00458         else
+00459         {
+00460                 K.set(0, 1, 0);
+00461                 J= ViewDir;
+00462                 I= J^K;
+00463                 K= I^J;
+00464         }
+00465         I.normalize();
+00466         J.normalize();
+00467         K.normalize();
+00468         
+00469         CMatrix mat;
+00470         mat.identity();
+00471         mat.setRot(I,J,K, true);
+00472         mat.setPos(CVector(Viewer.x, Viewer.y, Viewer.z));
+00473         mat.invert();
+00474 
+00475         uint32 i, j, k;
+00476         for (i = 0; i < 2; ++i)
+00477         for (j = 0; j < 2; ++j)
+00478         for (k = 0; k < 2; ++k)
+00479         {
+00480                 CVector v;
+00481                 if (i == 0) v.x = Center.x-Size.x/2; else v.x = Center.x+Size.x/2;
+00482                 if (j == 0) v.y = Center.y-Size.y/2; else v.y = Center.y+Size.y/2;
+00483                 if (k == 0) v.z = Center.z-Size.z/2; else v.z = Center.z+Size.z/2;
+00484                 v = mat.mulPoint(v);
+00485                 if (v.y < Near)         Near = v.y;
+00486                 if (v.y > Far)          Far = v.y;
+00487         }
+00488 
+00489         for (i = 0; i < 2; ++i)
+00490         for (j = 0; j < 2; ++j)
+00491         for (k = 0; k < 2; ++k)
+00492         {
+00493                 CVector v;
+00494                 if (i == 0) v.x = Center.x-Size.x/2; else v.x = Center.x+Size.x/2;
+00495                 if (j == 0) v.y = Center.y-Size.y/2; else v.y = Center.y+Size.y/2;
+00496                 if (k == 0) v.z = Center.z-Size.z/2; else v.z = Center.z+Size.z/2;
+00497                 v = mat.mulPoint(v);
+00498                 v.x = v.x / (v.y/Near);
+00499                 v.z = v.z / (v.y/Near);
+00500                 if (v.x < Left)         Left = v.x;
+00501                 if (v.x > Right)        Right = v.x;
+00502                 if (v.z < Bottom)       Bottom = v.z;
+00503                 if (v.z > Top)          Top = v.z;
+00504         }
+00505 }
+00506 
+00507 // ------------------------------------------------------------------------------------------------
+00508 // Create the billboard (in the screen at pos (NbW*Width, 0)
+00509 void CCloud::genBill (CCamera *pCam, uint32 nBillSize)
+00510 {
+00511         uint32 sizeTMP = _OldBillSize;
+00512         uint8 *MemTMP = _MemOldBill;
+00513         CSmartPtr<CTextureMem>  TexTMP = _TexOldBill;
+00514 
+00515         _OldBillSize = _BillSize;
+00516         _MemOldBill = _MemBill;
+00517         _TexOldBill = _TexBill;
+00518         _BillSize = sizeTMP;
+00519         _MemBill = MemTMP;
+00520         _TexBill = TexTMP;
+00521 
+00522         // Check the new size of the billboard
+00523         if (nBillSize != _BillSize)
+00524         {
+00525                 _BillSize = nBillSize;
+00526                 _MemBill = new uint8[4*_BillSize*_BillSize];
+00527                 _TexBill = new CTextureMem (_MemBill, 4*_BillSize*_BillSize, true, false, _BillSize, _BillSize);
+00528                 //for (i = 0; i < 4*_BillSize*_BillSize; ++i) _MemBill[i] = (uint8)i;
+00529                 _TexBill->setWrapS (ITexture::Clamp);
+00530                 _TexBill->setWrapT (ITexture::Clamp);
+00531                 _TexBill->setFilterMode (ITexture::Linear, ITexture::LinearMipMapOff);
+00532                 _TexBill->setReleasable (false);
+00533                 _TexBill->generate();
+00534         }
+00535 
+00536         CViewport viewport, viewportOLD;
+00537         viewportOLD.initFullScreen();
+00538         uint32 nScreenW, nScreenH;
+00539         _Driver->getWindowSize (nScreenW, nScreenH);
+00540         viewport.init(0.0f, 0.0f, ((float)_BillSize+1)/((float)nScreenW), ((float)_BillSize+1)/((float)nScreenH));
+00541         _Driver->setupViewport (viewport);
+00542 
+00543         //CMatrix CamMat = pCam->getMatrix();
+00544         //CVector Viewer = CamMat.getPos();
+00545         CVector Viewer = CVector (0,0,0);
+00546         CVector Center = CVector (_Pos.x+_Size.x/2, _Pos.y+_Size.y/2, _Pos.z+_Size.z/2);
+00547         CVector Size = _Size;
+00548         CVector I, J, K;
+00549         float Left, Right, Top, Bottom, Near, Far;
+00550 
+00551         calcBill (Viewer, Center, Size, I, J, K, Left, Right, Top, Bottom, Near, Far);
+00552 
+00553         CMatrix mat;
+00554         mat.identity();
+00555         mat.setRot(I,J,K, true);
+00556         mat.setPos(CVector(Viewer.x, Viewer.y, Viewer.z));
+00557         mat.invert();
+00558 
+00559         // Clear background for cloud creation
+00560         _Driver->setFrustum(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, false);
+00561         _Driver->setupViewMatrix (CMatrix::Identity);
+00562         _Driver->setupModelMatrix (CMatrix::Identity);
+00563 
+00564         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00565         uint32 nVSize = rVB.getVertexSize ();
+00566         CVector *pVertices = (CVector*)rVB.getVertexCoordPointer (0);
+00567         *pVertices = CVector(0.0f,      0.0f,   0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00568         *pVertices = CVector(1.0f,      0.0f,   0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00569         *pVertices = CVector(1.0f,      0.0f,   1.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00570         *pVertices = CVector(0.0f,      0.0f,   1.0f);
+00571 
+00572         _CloudScape->_MatClear.setColor (CRGBA(0,0,0,0));
+00573         _Driver->activeVertexBuffer (rVB);
+00574         _Driver->renderQuads (_CloudScape->_MatClear, 0, 1);
+00575 
+00576         // Render 
+00577         _Driver->setFrustum(Left, Right, Bottom, Top, Near, Far);
+00578         _Driver->setupViewMatrix(mat);
+00579         _Driver->setupModelMatrix (CMatrix::Identity);
+00580 
+00581         _CloudTexTmp->ToBill.setColor (CloudAmbient);
+00582         dispXYZ (&_CloudTexTmp->ToBill);
+00583 
+00584         _Driver->copyFrameBufferToTexture (_TexBill, 0, 0, 0, 0, 0, _BillSize, _BillSize);
+00585 
+00586         // This is the end of render to texture like so reset all stuff
+00587         _Driver->setupViewport (viewportOLD);
+00588 
+00589         _BillOldCenter = _BillCenter;
+00590         _BillViewer = Viewer;
+00591         _BillCenter = Center;
+00592 
+00593         if (_WaitState > 0)
+00594                 _WaitState = _WaitState - 1;
+00595 
+00596         _LastX = _Pos.x;
+00597 }
+00598 
+00599 // ------------------------------------------------------------------------------------------------
+00600 void CCloud::dispBill (CCamera *pCam)
+00601 {
+00602 //      CMatrix CamMat = pCam->getMatrix();
+00603 //      CVector Viewer = CamMat.getPos();
+00604         CVector Viewer = CVector (0,0,0);
+00605         CVector Center = CVector (_Pos.x+_Size.x/2, _Pos.y+_Size.y/2, _Pos.z+_Size.z/2);
+00606         CVector Size = _Size;
+00607 
+00608         // Prepare vertices.
+00609         CQuadUV qc;
+00610         
+00611         CVector I, J, K;
+00612         float Left, Right, Top, Bottom, Near, Far;
+00613 
+00614         if ((_MemBill == NULL) || (_MemOldBill == NULL))
+00615                 return;
+00616 
+00617         if (_WaitState > 0)
+00618                 return;
+00619 
+00620         if (Time > FuturTime)
+00621                 Time = FuturTime;
+00622 
+00623         // take old computed bill.
+00624         Viewer= _BillViewer;
+00625 /*              Center= _BillCenter*((float)(Trans)/(float)TransTotal) +
+00626                         _BillOldCenter*((float)(TransTotal-Trans)/(float)TransTotal);
+00627 
+00628         calcBill (Viewer, Center, Size, I, J, K, Left, Right, Top, Bottom, Near, Far);
+00629 
+00630 
+00631         CVector lct = Viewer + J*Near;
+00632         qc.V0 = lct + I*Left    + K*Bottom;
+00633         qc.V1 = lct + I*Right   + K*Bottom;
+00634         qc.V2 = lct + I*Right   + K*Top;
+00635         qc.V3 = lct + I*Left    + K*Top;*/
+00636 
+00637         Center= _BillCenter;
+00638         calcBill (Viewer, Center, Size, I, J, K, Left, Right, Top, Bottom, Near, Far);
+00639         CVector lct = Viewer + J*Near;
+00640         CQuadUV qc0;
+00641         qc0.V0 = lct + I*Left   + K*Bottom;
+00642         qc0.V1 = lct + I*Right  + K*Bottom;
+00643         qc0.V2 = lct + I*Right  + K*Top;
+00644         qc0.V3 = lct + I*Left   + K*Top;
+00645 
+00646         Center= _BillOldCenter;
+00647         calcBill (Viewer, Center, Size, I, J, K, Left, Right, Top, Bottom, Near, Far);
+00648         lct = Viewer + J*Near;
+00649         CQuadUV qc1;
+00650         qc1.V0 = lct + I*Left   + K*Bottom;
+00651         qc1.V1 = lct + I*Right  + K*Bottom;
+00652         qc1.V2 = lct + I*Right  + K*Top;
+00653         qc1.V3 = lct + I*Left   + K*Top;
+00654 
+00655         float   a0= ((float)(Time)/(float)FuturTime);
+00656         float   a1= (float)(FuturTime-Time)/(float)FuturTime;
+00657         qc.V0= qc0.V0*a0 + qc1.V0*a1;
+00658         qc.V1= qc0.V1*a0 + qc1.V1*a1;
+00659         qc.V2= qc0.V2*a0 + qc1.V2*a1;
+00660         qc.V3= qc0.V3*a0 + qc1.V3*a1;
+00661 
+00662         qc.Uv0 = CUV(0, 0);
+00663         qc.Uv1 = CUV(1, 0);
+00664         qc.Uv2 = CUV(1, 1);
+00665         qc.Uv3 = CUV(0, 1);
+00666 
+00667         // Display TexBill with intensity : Trans / TransTotal
+00668         // and TexOldBill  with intensity : (TransTotal-Trans) / TransTotal
+00669 
+00670         _CloudScape->_MatBill.setTexture (0, _TexOldBill);
+00671         _CloudScape->_MatBill.setTexture (1, _TexBill);
+00672         _CloudScape->_MatBill.setColor (CRGBA(255, 255, 255, (uint8)(255*((float)Time/(float)FuturTime))));
+00673         CVertexBuffer &rVB = _CloudScape->_VertexBuffer;
+00674         uint32 nVSize = rVB.getVertexSize ();
+00675         CVector *pVertices = (CVector*)rVB.getVertexCoordPointer (0);
+00676         *pVertices = qc.V0; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00677         *pVertices = qc.V1; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00678         *pVertices = qc.V2; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
+00679         *pVertices = qc.V3;
+00680 
+00681         CUV *pUV = (CUV*)rVB.getTexCoordPointer (0, 0);
+00682         pUV->U = 0;     pUV->V = 0;     pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00683         pUV->U = 1;     pUV->V = 0;     pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00684         pUV->U = 1;     pUV->V = 1;     pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00685         pUV->U = 0;     pUV->V = 1;
+00686 
+00687         pUV = (CUV*)rVB.getTexCoordPointer (0, 1);
+00688         pUV->U = 0;     pUV->V = 0;     pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00689         pUV->U = 1;     pUV->V = 0;     pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00690         pUV->U = 1;     pUV->V = 1;     pUV = (CUV*)( ((uint8*)pUV) + nVSize );
+00691         pUV->U = 0;     pUV->V = 1;
+00692 
+00693         _Driver->activeVertexBuffer (rVB);
+00694         _Driver->renderQuads (_CloudScape->_MatBill, 0, 1);
+00695 
+00696         //nlinfo ("ok");
+00697         
+00698 
+00699         // Debug
+00700         if (_CloudScape->isDebugQuadEnabled())
+00701         {
+00702                 static CMaterial *mTmp = NULL;
+00703                 if (mTmp == NULL)
+00704                 {
+00705                         mTmp = new CMaterial();
+00706                         mTmp->setBlend(false);
+00707                         mTmp->setDoubleSided(true);
+00708                 }
+00709                 /*if (_BillSize <= 4)
+00710                         mTmp->setColor(CRGBA(0,127,0,255));
+00711                 else if (_BillSize == 8)
+00712                         mTmp->setColor(CRGBA(0,255,0,255));
+00713                 else if (_BillSize == 16)
+00714                         mTmp->setColor(CRGBA(127,255,0,255));
+00715                 else if (_BillSize == 32)
+00716                         mTmp->setColor(CRGBA(255,255,0,255));
+00717                 else if (_BillSize == 64)
+00718                         mTmp->setColor(CRGBA(255,127,0,255));
+00719                 else if (_BillSize == 128)
+00720                         mTmp->setColor(CRGBA(255,0,0,255));
+00721                 else if (_BillSize == 256)
+00722                         mTmp->setColor(CRGBA(127,0,0,255));*/
+00723 
+00724                         if (FuturTime <= 4)
+00725                         mTmp->setColor(CRGBA(0,127,0,255));
+00726                 else if (FuturTime <= 8)
+00727                         mTmp->setColor(CRGBA(0,255,0,255));
+00728                 else if (FuturTime <= 12)
+00729                         mTmp->setColor(CRGBA(127,255,0,255));
+00730                 else if (FuturTime <= 16)
+00731                         mTmp->setColor(CRGBA(255,255,0,255));
+00732                 else if (FuturTime <= 20)
+00733                         mTmp->setColor(CRGBA(255,127,0,255));
+00734                 else
+00735                         mTmp->setColor(CRGBA(255,0,0,255));
+00736 
+00737                 _Driver->setPolygonMode(IDriver::Line);
+00738                 _Driver->renderQuads (*mTmp, 0, 1);
+00739                 _Driver->setPolygonMode(IDriver::Filled);
+00740         }
+00741 
+00742 }
+00743 
+00744 // ------------------------------------------------------------------------------------------------
+00745 void CCloud::setMode2D ()
+00746 {
+00747         CVector I(1,0,0), J(0,0,1), K(0,-1,0);
+00748         CMatrix ViewMatrix;
+00749         ViewMatrix.identity ();
+00750         ViewMatrix.setRot (I,J,K, true);
+00751         CScissor Scissor;
+00752         Scissor.initFullScreen();
+00753         _Driver->setupScissor (Scissor);
+00754         _Driver->setupViewport (CViewport());
+00755         uint32 nScreenW, nScreenH;
+00756         _Driver->getWindowSize (nScreenW, nScreenH);
+00757         _Driver->setFrustum (0, (float)nScreenW, 0, (float)nScreenH, -1, 1, false);
+00758         _Driver->setupViewMatrix (ViewMatrix);
+00759         _Driver->setupModelMatrix (CMatrix::Identity);
+00760 }
+00761 
+00762 } // namespace NL3D
+00763 
+
cloud.cpp
