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 "noise_3d.h"
00028 #include "3d/driver.h"
00029 
00030 using namespace NLMISC;
00031 
00032 namespace NL3D
00033 {
00034 
00035 // ------------------------------------------------------------------------------------------------
00036 CNoise3d::CNoise3d (IDriver *pDriver)
00037 {
00038         _Mat = NULL;
00039         _Driver = pDriver;
00040         _NbVertices = 0;
00041         _IsDriverSupportEnvCombine4 = true;
00042 }
00043 
00044 // ------------------------------------------------------------------------------------------------
00045 CNoise3d::~CNoise3d ()
00046 {
00047         //      delete _Mem; // done by CTertureMem destructor
00048         delete _Mat;
00049         delete [] _OffS;
00050 }
00051 
00052 // ------------------------------------------------------------------------------------------------
00053 void CNoise3d::init (uint32 w, uint32 h, uint32 d)
00054 {
00055         uint32 i;
00056 
00057         w = raiseToNextPowerOf2 (w);
00058         h = raiseToNextPowerOf2 (h);
00059         d = raiseToNextPowerOf2 (d);
00060         if (w > 64) w = 64;
00061         if (h > 64) h = 64;
00062         if (d > 64) d = 64;
00063         if (w < 4) w = 4;
00064         if (h < 4) h = 4;
00065         if (d < 4) d = 4;
00066         _Width = w;
00067         _Height = h;
00068         _Depth = d;
00069         uint32 vdpo2 = getPowerOf2(_Depth);
00070 
00071         _NbSliceW = 1 << (vdpo2 / 2);
00072         if ((vdpo2 & 1) != 0)
00073                 _NbSliceH = 2 << (vdpo2 / 2);
00074         else
00075                 _NbSliceH = 1 << (vdpo2 / 2);
00076 
00077         _ScaleW = 1.0f / _NbSliceW;
00078         _ScaleH = 1.0f / _NbSliceH;
00079 
00080         _Mem = new uint8[w*h*d];
00081 
00082         // Create initial noise
00083         for (i = 0; i < (w*h*d); i++)
00084                 _Mem[i] = (uint8)(256.0f*rand()/RAND_MAX);
00085 
00086         _OffS = new CUV [_Depth];
00087         for (i = 0; i < _Depth; i++)
00088         {
00089                 _OffS[i].U = ((float)rand())/RAND_MAX;
00090                 _OffS[i].V = ((float)rand())/RAND_MAX;
00091         }
00092 
00093         _Tex = new CTextureMem (_Mem, _Width*_NbSliceW*_Height*_NbSliceH, true, false, _Width*_NbSliceW, _Height*_NbSliceH,
00094                                                         CBitmap::Alpha);
00095         _Tex->setWrapS(ITexture::Repeat);
00096         _Tex->setWrapT(ITexture::Repeat);
00097         _Tex->setFilterMode(ITexture::Linear, ITexture::LinearMipMapOff);
00098         _Tex->touch();
00099         _Tex->generate();
00100 
00101         if (_IsDriverSupportEnvCombine4)
00102         {
00103                 _Mat = new CMaterial();
00104                 _Mat->initUnlit();
00105                 _Mat->setShader (CMaterial::Cloud);
00106                 _Mat->setTexture (0, _Tex);
00107                 _Mat->setTexture (1, _Tex);
00108                 _Mat->setColor (CRGBA(255,255,255,255));
00109                 _Mat->setBlend (true);
00110                 _Mat->setBlendFunc(CMaterial::one, CMaterial::one);
00111                 _Mat->setZFunc (CMaterial::always);
00112                 _Mat->setZWrite (false);
00113                 _VertexBuffer.setVertexFormat (CVertexBuffer::PositionFlag | CVertexBuffer::PrimaryColorFlag |
00114                                                                                 CVertexBuffer::TexCoord0Flag | CVertexBuffer::TexCoord1Flag);
00115         }
00116         else
00117         {
00118                 _Mat = new CMaterial();
00119                 _Mat->initUnlit();
00120                 _Mat->setShader (CMaterial::Normal);
00121                 _Mat->setTexture (0, _Tex);
00122                 _Mat->setColor (CRGBA(255,255,255,255));
00123                 _Mat->setBlend (true);
00124                 _Mat->setBlendFunc(CMaterial::one, CMaterial::one);
00125                 _Mat->setZFunc (CMaterial::always);
00126                 _Mat->setZWrite (false);
00127                 _VertexBuffer.setVertexFormat (CVertexBuffer::PositionFlag | CVertexBuffer::PrimaryColorFlag |
00128                                                                                 CVertexBuffer::TexCoord0Flag);
00129         }
00130 }
00131 
00132 // ------------------------------------------------------------------------------------------------
00133 void CNoise3d::render2passes (CQuadUV &qc, float wpos, float alpha)
00134 {
00135         // For the moment we do it in 2 passes : because wpos is a position between slice we have to do :
00136         // [ At0*wpos+At1*(1-wpos) ] * alpha
00137         // this is done like that :
00138         // At0*[wpos*alpha] + At1*[(1-wpos)*alpha] 
00139 
00140         wpos = fmodf (wpos, 1.0f);
00141         uint32 nSlice1 = (uint32)(wpos * _Depth), nSlice2;
00142         if (nSlice1 == (_Depth-1))
00143                 nSlice2 = 0;
00144         else
00145                 nSlice2 = 1 + nSlice1;
00146         // If wpos is just on slice1 alpha must be one
00147         float alphaPos = 1.0f - _Depth*(wpos - (((float)nSlice1) / _Depth));
00148 
00149         if (_NbVertices == _VertexBuffer.getNumVertices())
00150         {
00151                 _VertexBuffer.setNumVertices(_NbVertices+8);
00152         }
00153 
00154         uint32 nVSize = _VertexBuffer.getVertexSize ();
00155         CVector *pVertices = (CVector*)_VertexBuffer.getVertexCoordPointer(_NbVertices);
00156         *pVertices = qc.V0; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00157         *pVertices = qc.V1; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00158         *pVertices = qc.V2; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00159         *pVertices = qc.V3; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00160         *pVertices = qc.V0; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00161         *pVertices = qc.V1; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00162         *pVertices = qc.V2; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00163         *pVertices = qc.V3;
00164 
00165         CUV *pUV = (CUV*)_VertexBuffer.getTexCoordPointer (_NbVertices, 0);
00166         *pUV = CUV(qc.Uv0.U*_ScaleW+_OffS[nSlice1].U, qc.Uv0.V*_ScaleH+_OffS[nSlice1].V); 
00167         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00168         *pUV = CUV(qc.Uv1.U*_ScaleW+_OffS[nSlice1].U, qc.Uv1.V*_ScaleH+_OffS[nSlice1].V); 
00169         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00170         *pUV = CUV(qc.Uv2.U*_ScaleW+_OffS[nSlice1].U, qc.Uv2.V*_ScaleH+_OffS[nSlice1].V); 
00171         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00172         *pUV = CUV(qc.Uv3.U*_ScaleW+_OffS[nSlice1].U, qc.Uv3.V*_ScaleH+_OffS[nSlice1].V); 
00173         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00174 
00175         *pUV = CUV(qc.Uv0.U*_ScaleW+_OffS[nSlice2].U, qc.Uv0.V*_ScaleH+_OffS[nSlice2].V); 
00176         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00177         *pUV = CUV(qc.Uv1.U*_ScaleW+_OffS[nSlice2].U, qc.Uv1.V*_ScaleH+_OffS[nSlice2].V); 
00178         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00179         *pUV = CUV(qc.Uv2.U*_ScaleW+_OffS[nSlice2].U, qc.Uv2.V*_ScaleH+_OffS[nSlice2].V); 
00180         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00181         *pUV = CUV(qc.Uv3.U*_ScaleW+_OffS[nSlice2].U, qc.Uv3.V*_ScaleH+_OffS[nSlice2].V); 
00182 
00183         uint8 finalAlpha = (uint8)(255*alphaPos*alpha);
00184 
00185         uint8 *pColA = (uint8*)_VertexBuffer.getColorPointer(_NbVertices) + 3;
00186         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00187         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00188         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00189         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00190 
00191         finalAlpha = (uint8)(255*(1.0f-alphaPos)*alpha);
00192 
00193         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00194         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00195         *pColA = finalAlpha; pColA = ((uint8*)pColA) + nVSize;
00196         *pColA = finalAlpha;
00197 
00198         _NbVertices += 8;
00199 }
00200 
00201 // ------------------------------------------------------------------------------------------------
00202 void CNoise3d::render (CQuadUV &qc, float wpos, float intensity)
00203 {
00204         // [ At0*wpos+At1*(1-wpos) ] * alpha
00205 
00206         if (!_IsDriverSupportEnvCombine4)
00207         {
00208                 render2passes (qc, wpos, intensity);
00209                 return;
00210         }
00211 
00212         _Intensity = intensity;
00213 
00214         wpos = wpos - floorf (wpos);
00215         uint32 nSlice1 = (uint32)(wpos * _Depth), nSlice2;
00216         if (nSlice1 == (_Depth-1))
00217                 nSlice2 = 0;
00218         else
00219                 nSlice2 = 1 + nSlice1;
00220         // If wpos is just on slice1 alpha must be one
00221         float alphaPos = 1.0f - _Depth*(wpos - (((float)nSlice1) / _Depth));
00222 
00223         uint8 nAlphaPos = (uint8)(255*alphaPos);
00224 
00225         uint32 nVSize = _VertexBuffer.getVertexSize ();
00226 
00227         if (_NbVertices == _VertexBuffer.getNumVertices())
00228         {
00229                 _VertexBuffer.setNumVertices (_NbVertices+4);
00230         }
00231 
00232         CVector *pVertices = (CVector*)_VertexBuffer.getVertexCoordPointer(_NbVertices);
00233         *pVertices = qc.V0; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00234         *pVertices = qc.V1; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00235         *pVertices = qc.V2; pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00236         *pVertices = qc.V3;
00237 
00238         CUV *pUV = (CUV*)_VertexBuffer.getTexCoordPointer (_NbVertices, 0);
00239         *pUV = CUV(qc.Uv0.U/_NbSliceW+_OffS[nSlice1].U, qc.Uv0.V*_ScaleH+_OffS[nSlice1].V); 
00240         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00241         *pUV = CUV(qc.Uv1.U/_NbSliceW+_OffS[nSlice1].U, qc.Uv1.V*_ScaleH+_OffS[nSlice1].V); 
00242         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00243         *pUV = CUV(qc.Uv2.U/_NbSliceW+_OffS[nSlice1].U, qc.Uv2.V*_ScaleH+_OffS[nSlice1].V); 
00244         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00245         *pUV = CUV(qc.Uv3.U/_NbSliceW+_OffS[nSlice1].U, qc.Uv3.V*_ScaleH+_OffS[nSlice1].V); 
00246 
00247         pUV = (CUV*)_VertexBuffer.getTexCoordPointer (_NbVertices, 1);
00248         *pUV = CUV(qc.Uv0.U*_ScaleW+_OffS[nSlice2].U, qc.Uv0.V*_ScaleH+_OffS[nSlice2].V); 
00249         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00250         *pUV = CUV(qc.Uv1.U*_ScaleW+_OffS[nSlice2].U, qc.Uv1.V*_ScaleH+_OffS[nSlice2].V); 
00251         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00252         *pUV = CUV(qc.Uv2.U*_ScaleW+_OffS[nSlice2].U, qc.Uv2.V*_ScaleH+_OffS[nSlice2].V); 
00253         pUV = (CUV*)( ((uint8*)pUV) + nVSize );
00254         *pUV = CUV(qc.Uv3.U*_ScaleW+_OffS[nSlice2].U, qc.Uv3.V*_ScaleH+_OffS[nSlice2].V); 
00255 
00256         uint8 *pColA = (uint8*)_VertexBuffer.getColorPointer(_NbVertices) + 3;
00257         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00258         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00259         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00260         *pColA = nAlphaPos;
00261 
00262         _NbVertices += 4;
00263 }
00264 
00265 // ------------------------------------------------------------------------------------------------
00266 void CNoise3d::renderGrid (uint32 nbw, uint32 nbh, uint32 w, uint32 h, 
00267                                         float UStart, float VStart, float WStart, float dU, float dV, float dW, float intensity)
00268 {
00269 
00270         if (!_IsDriverSupportEnvCombine4)
00271         {
00272                 renderGrid2passes (nbw, nbh, w, h, UStart, VStart, WStart, dU, dV, dW, intensity);
00273                 return;
00274         }
00275 
00276         _Intensity = intensity;
00277 
00278         uint32 i, j, nSlice1, nSlice2;
00279         float wpos, oneOverNbWNbH = 1.0f / (nbw*nbh);
00280         CVector *pVertices;
00281         CUV *pUV0, *pUV1;
00282         uint8 *pColA, nAlphaPos;
00283         uint32 nVSize = _VertexBuffer.getVertexSize ();
00284 
00285         if (_VertexBuffer.getNumVertices() < nbw*nbh*4)
00286         {
00287                 _VertexBuffer.setNumVertices (nbw*nbh*4);
00288         }
00289 
00290         dU = (UStart+dU) /_NbSliceW;
00291         dV = (VStart+dV) /_NbSliceH;
00292         UStart = UStart / _NbSliceW;
00293         VStart = VStart / _NbSliceH;
00294 
00295         pVertices = (CVector*)_VertexBuffer.getVertexCoordPointer(0);
00296         pUV0 = (CUV*)_VertexBuffer.getTexCoordPointer (0, 0);
00297         pUV1 = (CUV*)_VertexBuffer.getTexCoordPointer (0, 1);
00298         pColA = (uint8*)_VertexBuffer.getColorPointer(0) + 3;
00299 
00300         for (j = 0; j < nbh; ++j)
00301         {
00302                 for (i = 0; i < nbw; ++i)
00303                 {
00304                         wpos = (float)WStart+dW*(i+(float)j*nbw)*oneOverNbWNbH;
00305                         wpos = wpos - floorf (wpos);
00306                         nSlice1 = (uint32)(wpos * _Depth);
00307                         if (nSlice1 == (_Depth-1))
00308                                 nSlice2 = 0;
00309                         else
00310                                 nSlice2 = 1 + nSlice1;
00311                         // If wpos is just on slice1 alpha must be one
00312                         nAlphaPos = (uint8)( 255*(1.0f - _Depth*(wpos - (((float)nSlice1) / _Depth))) );
00313 
00314                         *pVertices = CVector((float)i*w,         (float)j*h,     0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00315                         *pVertices = CVector((float)(i+1)*w, (float)j*h,         0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00316                         *pVertices = CVector((float)(i+1)*w, (float)(j+1)*h, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00317                         *pVertices = CVector((float)i*w,         (float)(j+1)*h, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00318 
00319                         pUV0->U = UStart+_OffS[nSlice1].U;      pUV0->V = VStart+_OffS[nSlice1].V;      pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00320                         pUV0->U = dU+_OffS[nSlice1].U;          pUV0->V = VStart+_OffS[nSlice1].V;      pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00321                         pUV0->U = dU+_OffS[nSlice1].U;          pUV0->V = dV+_OffS[nSlice1].V;          pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00322                         pUV0->U = UStart+_OffS[nSlice1].U;      pUV0->V = dV+_OffS[nSlice1].V;          pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00323 
00324                         pUV1->U = UStart+_OffS[nSlice2].U;      pUV1->V = VStart+_OffS[nSlice2].V;      pUV1 = (CUV*)( ((uint8*)pUV1) + nVSize );
00325                         pUV1->U = dU+_OffS[nSlice2].U;          pUV1->V = VStart+_OffS[nSlice2].V;      pUV1 = (CUV*)( ((uint8*)pUV1) + nVSize );
00326                         pUV1->U = dU+_OffS[nSlice2].U;          pUV1->V = dV+_OffS[nSlice2].V;          pUV1 = (CUV*)( ((uint8*)pUV1) + nVSize );
00327                         pUV1->U = UStart+_OffS[nSlice2].U;      pUV1->V = dV+_OffS[nSlice2].V;          pUV1 = (CUV*)( ((uint8*)pUV1) + nVSize );
00328 
00329                         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00330                         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00331                         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00332                         *pColA = nAlphaPos; pColA = ((uint8*)pColA) + nVSize;
00333                 }
00334         }
00335 
00336         _NbVertices = nbw*nbh*4;
00337 }
00338 
00339 // ------------------------------------------------------------------------------------------------
00340 void CNoise3d::renderGrid2passes (uint32 nbw, uint32 nbh, uint32 w, uint32 h, 
00341                                         float UStart, float VStart, float WStart, float dU, float dV, float dW, float intensity)
00342 {
00343         uint32 i, j, nSlice1, nSlice2;
00344         float wpos, oneOverNbWNbH = 1.0f / (nbw*nbh);
00345         CVector *pVertices;
00346         CUV *pUV0;
00347         uint8 *pColA, nFinalAlpha;
00348         uint32 nVSize = _VertexBuffer.getVertexSize ();
00349         
00350         if (_VertexBuffer.getNumVertices() < 2*nbw*nbh*4)
00351         {
00352                 _VertexBuffer.setNumVertices (2*nbw*nbh*4);
00353         }
00354 
00355         dU = (UStart+dU) /_NbSliceW;
00356         dV = (VStart+dV) /_NbSliceH;
00357         UStart = UStart / _NbSliceW;
00358         VStart = VStart / _NbSliceH;
00359 
00360         pVertices = (CVector*)_VertexBuffer.getVertexCoordPointer(0);
00361         pUV0 = (CUV*)_VertexBuffer.getTexCoordPointer (0, 0);
00362         pColA = (uint8*)_VertexBuffer.getColorPointer(0) + 3;
00363 
00364         for (j = 0; j < nbh; ++j)
00365         {
00366                 for (i = 0; i < nbw; ++i)
00367                 {
00368                         wpos = (float)WStart+dW*(i+(float)j*nbw)*oneOverNbWNbH;
00369                         wpos = fmodf (wpos, 1.0f);
00370                         nSlice1 = (uint32)(wpos * _Depth);
00371                         if (nSlice1 == (_Depth-1))
00372                                 nSlice2 = 0;
00373                         else
00374                                 nSlice2 = 1 + nSlice1;
00375                         // If wpos is just on slice1 alpha must be one
00376                         float alphaPos = 1.0f - _Depth*(wpos - (((float)nSlice1) / _Depth));
00377 
00378                         *pVertices = CVector((float)i*w,         (float)j*h,     0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00379                         *pVertices = CVector((float)(i+1)*w, (float)j*h,         0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00380                         *pVertices = CVector((float)(i+1)*w, (float)(j+1)*h, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00381                         *pVertices = CVector((float)i*w,         (float)(j+1)*h, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00382                         *pVertices = CVector((float)i*w,         (float)j*h,     0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00383                         *pVertices = CVector((float)(i+1)*w, (float)j*h,         0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00384                         *pVertices = CVector((float)(i+1)*w, (float)(j+1)*h, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00385                         *pVertices = CVector((float)i*w,         (float)(j+1)*h, 0.0f); pVertices = (CVector*)( ((uint8*)pVertices) + nVSize );
00386 
00387                         pUV0->U = UStart+_OffS[nSlice1].U;      pUV0->V = VStart+_OffS[nSlice1].V;      pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00388                         pUV0->U = dU+_OffS[nSlice1].U;          pUV0->V = VStart+_OffS[nSlice1].V;      pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00389                         pUV0->U = dU+_OffS[nSlice1].U;          pUV0->V = dV+_OffS[nSlice1].V;          pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00390                         pUV0->U = UStart+_OffS[nSlice1].U;      pUV0->V = dV+_OffS[nSlice1].V;          pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00391 
00392                         pUV0->U = UStart+_OffS[nSlice2].U;      pUV0->V = VStart+_OffS[nSlice2].V;      pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00393                         pUV0->U = dU+_OffS[nSlice2].U;          pUV0->V = VStart+_OffS[nSlice2].V;      pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00394                         pUV0->U = dU+_OffS[nSlice2].U;          pUV0->V = dV+_OffS[nSlice2].V;          pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00395                         pUV0->U = UStart+_OffS[nSlice2].U;      pUV0->V = dV+_OffS[nSlice2].V;          pUV0 = (CUV*)( ((uint8*)pUV0) + nVSize );
00396 
00397                         nFinalAlpha = (uint8)(255*alphaPos*intensity);
00398 
00399                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00400                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00401                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00402                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00403 
00404                         nFinalAlpha = (uint8)(255*(1.0f-alphaPos)*intensity);
00405 
00406                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00407                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00408                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00409                         *pColA = nFinalAlpha; pColA = ((uint8*)pColA) + nVSize;
00410                 }
00411         }
00412         _NbVertices = 2*4*nbw*nbh;
00413 }
00414 
00415 // ------------------------------------------------------------------------------------------------
00416 void CNoise3d::flush ()
00417 {
00418         if (!_IsDriverSupportEnvCombine4)
00419         {
00420                 flush2passes ();
00421                 return;
00422         }
00423         
00424         _Mat->setColor(CRGBA(0,0,0,(uint8)(255*_Intensity)));
00425         _Driver->activeVertexBuffer (_VertexBuffer);
00426         _Driver->renderQuads (*_Mat, 0, _NbVertices/4);
00427         _NbVertices = 0;
00428 }
00429 
00430 // ------------------------------------------------------------------------------------------------
00431 void CNoise3d::flush2passes ()
00432 {
00433         _Driver->activeVertexBuffer (_VertexBuffer);
00434         _Driver->renderQuads (*_Mat, 0, _NbVertices/4);
00435         _NbVertices = 0;
00436 }
00437 
00438 // Accessors
00439 // ------------------------------------------------------------------------------------------------
00440 uint32 CNoise3d::getWidth ()
00441 {
00442         return _Width;
00443 }
00444 
00445 // ------------------------------------------------------------------------------------------------
00446 uint32 CNoise3d::getHeight ()
00447 {
00448         return _Height;
00449 }
00450 
00451 // ------------------------------------------------------------------------------------------------
00452 uint32 CNoise3d::getDepth ()
00453 {
00454         return _Depth;
00455 }
00456 
00457 } // namespace NL3D
00458
noise_3d.cpp
