NeL: NL3D::CMaterial class Reference

00161                                         { Normal=0,
00162                                                           Bump,
00163                                                           UserColor,
00164                                                           LightMap,
00165                                                           Specular,
00166                                                           Caustics,
00167                                                           PerPixelLighting,
00168                                                           PerPixelLightingNoSpec,
00169                                                           Cloud,
00170                                                           Water,
00171                                                           shaderCount};

00042 {
00043         _Touched= 0;
00044         _Flags= IDRV_MAT_ZWRITE;
00045         // Must init All the flags by default.
00046         _ShaderType= Normal;
00047         _SrcBlend= srcalpha;
00048         _DstBlend= invsrcalpha;
00049         _ZFunction= lessequal;
00050         _ZBias= 0;
00051         _Color.set(255,255,255,255);
00052         _StainedGlassWindow = false;
00053         _AlphaTestThreshold= 0.5f;      
00054         _TexCoordGenMode= 0;
00055         _LightMapsMulx2= false;
00056 }

00242 {_Touched= 0;_Flags=0; operator=(mat);}

00132 {
00133         // Must kill the drv mirror of this material.
00134         pShader.kill(); 
00135 }

00616 { _Touched&=~flag; }

00524 {
00525         nlassert(stage < IDRV_MAT_MAXTEXTURES);
00526         nlassert(isUserTexMatEnabled(stage)); // must activate animated texture matrix for this stage
00527         CMatrix convMat; // exported v are already inverted (todo: optim this...)
00528         convMat.setRot(CVector::I, -CVector::J, CVector::K);
00529         convMat.setPos(CVector::J);
00530 
00531         const NLMISC::CMatrix texMat = convMat * _TexUserMat->TexMat[stage] * convMat;  
00533         NLMISC::CVector i = texMat.getI();
00534         NLMISC::CVector j = texMat.getJ();      
00535         uScale = sqrtf(i.x * i.x + j.x * j.x);
00536         vScale = sqrtf(i.y * i.y + j.y * j.y);          
00537         //
00538         i.normalize();  
00539         //      
00540         float angle = acosf(i.x / i.norm());
00541         if (i.y < 0)
00542         {
00543                 angle = 2.f * (float) NLMISC::Pi - angle;
00544         }
00545         wRot = angle;
00546 
00547         // compute position
00548         CMatrix InvSR;
00549         InvSR.setRot(texMat.getI(), texMat.getJ(), texMat.getK());
00550         InvSR.invert();
00551         CVector half(0.5f, 0.5f, 0.f);
00552         CVector offset = half + InvSR * (texMat.getPos() -half);
00553         uTrans = - offset.x;
00554         vTrans = - offset.y;
00555 }

00480 {
00481         if (enable)
00482         {
00483                 if (!(_Flags & IDRV_MAT_TEX_ADDR))
00484                 {
00485                         _Flags |= IDRV_MAT_TEX_ADDR;
00486                         for (uint32 k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
00487                         {
00488                                 _TexAddrMode[k] = (uint8) FetchTexture;
00489                         }                       
00490                 }               
00491         }
00492         else
00493         {
00494                 _Flags &= ~IDRV_MAT_TEX_ADDR;                   
00495         }
00496 }

00338 {
00339         nlassert(stage < IDRV_MAT_MAXTEXTURES);
00340         if (enabled)
00341         {
00342                 if (!(_Flags & IDRV_MAT_USER_TEX_MAT_ALL)) // not usr tex mat setupped before?
00343                 {
00344                         nlassert(_TexUserMat.get() == NULL);
00345                         _TexUserMat.reset(new CUserTexMat);
00346                 }
00347                 _Flags |= (IDRV_MAT_USER_TEX_0_MAT << stage);
00348                 _TexUserMat->TexMat[stage].identity();
00349         }
00350         else
00351         {
00352                 if (!(_Flags & IDRV_MAT_USER_TEX_MAT_ALL)) return; // nothing to do
00353                 _Flags &= ~(IDRV_MAT_USER_TEX_0_MAT << stage);     // clear the stage flag
00354                 if (!(_Flags & IDRV_MAT_USER_TEX_MAT_ALL))                 // no more user textures used ?
00355                 {
00356                         _TexUserMat.reset();
00357                 }
00358         }
00359 }

00356 {
00357         // For each textures
00358         for (uint tex=0; tex<IDRV_MAT_MAXTEXTURES; tex++)
00359         {
00360                 // Texture exist ?
00361                 if (_Textures[tex])
00362                 {
00363                         // Select the good texture
00364                         _Textures[tex]->selectTexture (selectedTexture);
00365                         
00366                         // Force setup texture
00367                         driver.setupTexture (*_Textures[tex]);
00368                 }
00369         }
00370 
00371         // If Lightmap material
00372         if(_ShaderType==LightMap)
00373         {
00374                 // For each lightmap
00375                 for (uint lmap=0; lmap<_LightMaps.size(); lmap++)
00376                 {
00377                         // Texture exist?
00378                         if(_LightMaps[lmap].Texture)
00379                         {
00380                                 // Force setup texture
00381                                 driver.setupTexture (*_LightMaps[lmap].Texture);
00382                         }
00383                 }
00384         }
00385 
00386 }

00314 { return (_Flags&IDRV_MAT_ALPHA_TEST)!=0; }

00320 { return _AlphaTestThreshold; }

00378 { return _Ambient;}

00278 { return (_Flags&IDRV_MAT_BLEND)!=0; }

00376 { return(_Color); }

00380 { return _Diffuse;}

00308 { return (_Flags&IDRV_MAT_DOUBLE_SIDED)!=0; }

00280 { return(_DstBlend); }

00377 { return _Emissive;}

00614 {return _Flags;}

00202 {
00203         return (_Flags & IDRV_MAT_LIGHTED_VERTEX_COLOR) != 0;
00204 }

00402 {
00403         nlassert(_ShaderType==CMaterial::LightMap);
00404         if(lmapId<_LightMaps.size())
00405                 return _LightMaps[lmapId].Texture;
00406         else
00407                 return NULL;    
00408 }

00381 { return _Diffuse.A;}

00071         {
00072                 return  crefs;
00073         }

00254 {return _ShaderType;}

00383 { return _Shininess;}

00382 { return _Specular;}

00279 { return(_SrcBlend); }

00480 { return _StainedGlassWindow; }

00516 {
00517         nlassert(_Flags & IDRV_MAT_TEX_ADDR);
00518         nlassert(stage < IDRV_MAT_MAXTEXTURES);
00519         return (TTexAddressingMode) _TexAddrMode[stage];
00520 }

00292 {
00293         nlassert(_ShaderType==CMaterial::Normal);
00294         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00295         return _TexEnvs[stage].ConstantColor;
00296 }

00299 {
00300         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00301         return (_Flags&(IDRV_MAT_GEN_TEX_0<<stage))!=0;
00302 }

00278 {
00279         nlassert(_ShaderType==CMaterial::Normal);
00280         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00281         return _TexEnvs[stage].EnvPacked;
00282 }

00047 { 
00048         nlassert(n<IDRV_MAT_MAXTEXTURES);
00049         return(_Textures[n]); 
00050 }

00615 { return(_Touched); }

00330 {
00331         nlassert(_ShaderType==CMaterial::UserColor);
00332         // setup stage 0 constant color (don't use getTexConstantColor() because of assert).
00333         return _TexEnvs[0].ConstantColor;
00334 }

00378 {
00379         nlassert(isUserTexMatEnabled(stage));
00380         nlassert(_TexUserMat.get() != NULL);
00381         return _TexUserMat->TexMat[stage];
00382 }

00336 { return(_ZBias); }

00334 { return(_ZFunction); }

00335 { return (_Flags&IDRV_MAT_ZWRITE)!=0; }

00076 {
00077         initUnlit();
00078         setLighting(true);
00079 }

00060 {
00061         setShader(Normal);
00062         setLighting(false);
00063         setColor(CRGBA(255,255,255,255));
00064         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
00065                 setTexture((uint8)i ,NULL);
00066         setZBias(0);
00067         setZFunc(lessequal);
00068         setZWrite(true);
00069         setBlend(false);
00070         setAlphaTestThreshold(0.5f);
00071 }

00371 {return (_Flags&IDRV_MAT_LIGHTING)!=0;}

00363 {
00364         nlassert(stage < IDRV_MAT_MAXTEXTURES);
00365         return (_Flags & (IDRV_MAT_USER_TEX_0_MAT << stage)) != 0;
00366 }

00084 {
00085         _ShaderType= mat._ShaderType;
00086         _Flags= mat._Flags;
00087         _SrcBlend= mat._SrcBlend;
00088         _DstBlend= mat._DstBlend;
00089         _ZFunction= mat._ZFunction;
00090         _ZBias= mat._ZBias;
00091         _Color= mat._Color;
00092         _Emissive= mat._Emissive;
00093         _Ambient= mat._Ambient;
00094         _Diffuse= mat._Diffuse;
00095         _Specular= mat._Specular;
00096         _Shininess= mat._Shininess;
00097         _AlphaTestThreshold= mat._AlphaTestThreshold;
00098 
00099         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
00100         {
00101                 _Textures[i]= mat._Textures[i];
00102                 _TexEnvs[i]= mat._TexEnvs[i];
00103                 _TexAddrMode[i] = mat._TexAddrMode[i];
00104         }
00105 
00106         // copy lightmaps.
00107         _LightMaps= mat._LightMaps;
00108         _LightMapsMulx2= mat._LightMapsMulx2;
00109 
00110         // copy texture matrix if there.
00111         if (mat._TexUserMat.get())
00112         {
00113                 std::auto_ptr<CUserTexMat> texMatClone( new CUserTexMat(*(mat._TexUserMat))); // make cpy
00114                 std::swap(texMatClone, _TexUserMat); // swap with old
00115         }
00116         else
00117         {
00118                 _TexUserMat.reset();    
00119         }
00120 
00121         // Must do not copy drv info.
00122 
00123         // All states of material is modified.
00124         _Touched= IDRV_TOUCHED_ALL;
00125 
00126         return *this;
00127 }

00559 {
00560         for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
00561         {
00562                 if (_Textures[k] != NULL) _Textures[k]->selectTexture(index);
00563         }
00564 }

00140 {
00141         /*
00142         Version 7:
00143                 - Lightmap color and Mulx2
00144         Version 6:
00145                 - Texture matrix animation
00146         Version 5:
00147                 - AlphaTest threshold
00148         Version 4:
00149                 - Texture Addressing modes
00150         Version 3:
00151                 - LightMaps.
00152         Version 2:
00153                 - Shininess.
00154         Version 1:
00155                 - texture environement.
00156         Version 0:
00157                 - base version.
00158         */
00159 
00160         sint    ver= f.serialVersion(7);
00161         // For the version <=1:
00162         nlassert(IDRV_MAT_MAXTEXTURES==4);
00163 
00164         f.serialEnum(_ShaderType);
00165         f.serial(_Flags);
00166         f.serialEnum(_SrcBlend);
00167         f.serialEnum(_DstBlend);
00168         f.serialEnum(_ZFunction);
00169         f.serial(_ZBias);
00170         f.serial(_Color);
00171         f.serial(_Emissive, _Ambient, _Diffuse, _Specular);
00172         if(ver>=2)
00173         {
00174                 f.serial(_Shininess);
00175         }
00176         if(ver>=5)
00177         {
00178                 f.serial(_AlphaTestThreshold);
00179         }
00180 
00181 
00182         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
00183         {
00184                 // Serial texture descriptor.
00185                 ITexture*       text;
00186                 if(f.isReading())
00187                 {
00188                         f.serialPolyPtr(text);
00189                         _Textures[i]= text;
00190                 }
00191                 else
00192                 {
00193                         text= _Textures[i];
00194                         f.serialPolyPtr(text);
00195                 }
00196 
00197                 // Read texture environnement, or setup them.
00198                 if(ver>=1)
00199                 {
00200                         f.serial(_TexEnvs[i]);
00201                 }
00202                 else
00203                 {
00204                         // Else setup as default behavior, like before...
00205                         if(f.isReading())
00206                                 _TexEnvs[i].setDefault();
00207                 }
00208         }
00209 
00210         if(ver>=3)
00211         {
00212                 if(ver>=7)
00213                 {
00214                         uint32 n;
00215                         if (f.isReading())
00216                         {
00217                                 f.serial(n);
00218                                 _LightMaps.resize(n);
00219                         }
00220                         else
00221                         {
00222                                 n = _LightMaps.size();
00223                                 f.serial(n);
00224                         }
00225                         for (uint32 i = 0; i < n; ++i)
00226                                 _LightMaps[i].serial2(f);
00227                         f.serial(_LightMapsMulx2);
00228                 }
00229                 else
00230                 {
00231                         f.serialCont(_LightMaps);
00232                 }
00233         }
00234 
00235         if (ver >= 4)
00236         {
00237                 if (_Flags & IDRV_MAT_TEX_ADDR)
00238                 {
00239                         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
00240                         {
00241                                 f.serial(_TexAddrMode[i]);
00242                         }
00243                 }
00244         }
00245 
00246         if(f.isReading())
00247         {
00248                 // Converte Deprecated DEFMAT to std Mat.
00249                 if(_Flags & IDRV_MAT_DEFMAT)
00250                 {
00251                         setEmissive(CRGBA::Black);
00252                         setAmbient(CRGBA::White);
00253                         setDiffuse(CRGBA::White);
00254                         setSpecular(CRGBA::Black);
00255                 }
00256 
00257                 // All states of material are modified.
00258                 _Touched= IDRV_TOUCHED_ALL;
00259 
00260                 if ((_Flags & IDRV_MAT_USER_TEX_MAT_ALL)) // are there user textrue coordinates matrix ?
00261                 {
00262                         std::auto_ptr<CUserTexMat> newPtr(new CUserTexMat); // create new                       
00263                         std::swap(_TexUserMat, newPtr); // replace old
00264                 }
00265         }
00266 
00267         if (ver >= 6)
00268         {
00269                 for(uint i=0; i < IDRV_MAT_MAXTEXTURES; ++i)
00270                 {
00271                         if (isUserTexMatEnabled(i))
00272                         {                               
00273                                 f.serial(_TexUserMat->TexMat[i]);                               
00274                         }                       
00275                 }
00276         }
00277 
00278 }

00079 {
00080         if (active)     _Flags|=IDRV_MAT_ALPHA_TEST;
00081         else            _Flags&=~IDRV_MAT_ALPHA_TEST;
00082         _Touched|=IDRV_TOUCHED_ALPHA_TEST;
00083 }

00086 {
00087         _AlphaTestThreshold= thre;
00088         _Touched|=IDRV_TOUCHED_ALPHA_TEST_THRE;
00089 }

00159 {
00160         _Ambient= ambient;
00161         _Touched|=IDRV_TOUCHED_LIGHTING;
00162 }

00065 {
00066         if (active)     _Flags|=IDRV_MAT_BLEND;
00067         else            _Flags&=~IDRV_MAT_BLEND;
00068         _Touched|=IDRV_TOUCHED_BLEND;
00069 }

00092 {
00093         _SrcBlend=src;
00094         _DstBlend=dst;
00095         _Touched|=IDRV_TOUCHED_BLENDFUNC;
00096 }

00119 {
00120         if (_Color != rgba)
00121         {
00122                 _Color=rgba;
00123                 _Touched|=IDRV_TOUCHED_COLOR;
00124         }
00125 }

00165 {
00166         // Keep opacity.
00167         _Diffuse.R= diffuse.R;
00168         _Diffuse.G= diffuse.G;
00169         _Diffuse.B= diffuse.B;
00170         _Touched|=IDRV_TOUCHED_LIGHTING;
00171 }

00072 {
00073         if (active)     _Flags|=IDRV_MAT_DOUBLE_SIDED;
00074         else            _Flags&=~IDRV_MAT_DOUBLE_SIDED;
00075         _Touched|=IDRV_TOUCHED_DOUBLE_SIDED;
00076 }

00059 {
00060         _DstBlend=val;
00061         _Touched|=IDRV_TOUCHED_BLENDFUNC;
00062 }

00153 {
00154         _Emissive= emissive;
00155         _Touched|=IDRV_TOUCHED_LIGHTING;
00156 }

00192 {
00193         if (useLightedVertexColor)
00194                 _Flags |= IDRV_MAT_LIGHTED_VERTEX_COLOR;
00195         else
00196                 _Flags &= ~IDRV_MAT_LIGHTED_VERTEX_COLOR;
00197         _Touched|=IDRV_TOUCHED_LIGHTING;
00198 }

00133 {
00134         if (active)
00135         {
00136                 _Flags|=IDRV_MAT_LIGHTING;
00137         }
00138         else
00139         {
00140                 _Flags&=~IDRV_MAT_LIGHTING;
00141         }
00142         _Emissive=emissive;
00143         _Ambient=ambient;
00144         _Diffuse=diffuse;
00145         _Specular=specular;
00146         _Shininess= shininess;
00147         _Touched|=IDRV_TOUCHED_LIGHTING;
00148 }

00391 {
00392         nlassert(_ShaderType==CMaterial::LightMap);
00393         if(lmapId>=_LightMaps.size())
00394                 _LightMaps.resize(lmapId+1);
00395         _LightMaps[lmapId].Texture= lmap;
00396 
00397         _Touched|=IDRV_TOUCHED_LIGHTMAP;
00398 }

00425 {
00426         if (_ShaderType==CMaterial::LightMap)
00427         {
00428                 if(lmapId>=_LightMaps.size())
00429                         _LightMaps.resize(lmapId+1);
00430                 _LightMaps[lmapId].Color= color;
00431 
00432                 _Touched|=IDRV_TOUCHED_LIGHTMAP;
00433         }
00434 }

00412 {
00413         if (_ShaderType==CMaterial::LightMap)
00414         {
00415                 if(lmapId>=_LightMaps.size())
00416                         _LightMaps.resize(lmapId+1);
00417                 _LightMaps[lmapId].Factor= factor;
00418 
00419                 _Touched|=IDRV_TOUCHED_LIGHTMAP;
00420         }
00421 }

00461 { _LightMapsMulx2 = val; }

00174 {
00175         _Diffuse.A= opa;
00176         _Touched|=IDRV_TOUCHED_LIGHTING;
00177 }

00283 {
00284         // First, reset all textures.
00285         uint    nTexts= IDRV_MAT_MAXTEXTURES;
00286         // If user color or lightmap, set only the 1st.
00287         if(_ShaderType==LightMap || _ShaderType==UserColor)
00288                 nTexts=1;
00289         // reset all needed
00290         for(uint i=0;i<nTexts;i++)
00291                 setTexture(i ,NULL);
00292 
00293         // If userColor, use TexEnv caps (we got it, so use it :) ).
00294         if(val== CMaterial::UserColor)
00295         {
00296                 // force normal, to setup TexEnvMode correclty. 
00297                 _ShaderType=CMaterial::Normal;
00298 
00299                 // First stage, interpolate Constant and texture with Alpha of texture.
00300                 texEnvOpRGB(0, InterpolateTexture);
00301                 texEnvArg0RGB(0, Texture, SrcColor);
00302                 texEnvArg1RGB(0, Constant, SrcColor);
00303                 // And just use Alpha Diffuse.
00304                 texEnvOpAlpha(0, Replace);
00305                 texEnvArg0Alpha(0, Previous, SrcAlpha);
00306 
00307                 // Second stage, modulate result with diffuse color.
00308                 texEnvOpRGB(1, Modulate);
00309                 texEnvArg0RGB(1, Previous, SrcColor);
00310                 texEnvArg1RGB(1, Diffuse, SrcColor);
00311                 // And just use Alpha Diffuse.
00312                 texEnvOpAlpha(1, Replace);
00313                 texEnvArg0Alpha(1, Previous, SrcAlpha);
00314         }
00315 
00316         _ShaderType= val;
00317         _Touched|=IDRV_TOUCHED_SHADER;
00318 }

00186 {
00187         _Shininess= shininess;
00188         _Touched|=IDRV_TOUCHED_LIGHTING;
00189 }

00180 {
00181         _Specular= specular;
00182         _Touched|=IDRV_TOUCHED_LIGHTING;
00183 }

00053 {
00054         _SrcBlend=val;
00055         _Touched|=IDRV_TOUCHED_BLENDFUNC;
00056 }

00481 { _StainedGlassWindow = val; }

00506 {
00507         nlassert(_Flags & IDRV_MAT_TEX_ADDR);
00508         nlassert(stage < IDRV_MAT_MAXTEXTURES);
00509         nlassert(mode < TexAddrCount);
00510         _TexAddrMode[stage] = (uint8) mode;     
00511 }

00305 {
00306         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00307         if (generate)
00308                 _Flags|=(IDRV_MAT_GEN_TEX_0<<stage);
00309         else
00310                 _Flags&=~(IDRV_MAT_GEN_TEX_0<<stage);
00311 }

00568 {
00569         if(stage>=IDRV_MAT_MAXTEXTURES)
00570                 return;
00571         _TexCoordGenMode&= ~ (IDRV_MAT_TEX_GEN_MASK << (stage*IDRV_MAT_TEX_GEN_SHIFT));
00572         _TexCoordGenMode|=   ((mode&IDRV_MAT_TEX_GEN_MASK) << (stage*IDRV_MAT_TEX_GEN_SHIFT));
00573 }

00285 {
00286         nlassert(_ShaderType==CMaterial::Normal);
00287         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00288         _TexEnvs[stage].EnvPacked= packed;
00289 }

00323 {
00324         nlassert(n<IDRV_MAT_MAXTEXTURES);
00325 
00326         // User Color material?
00327         if( _ShaderType== CMaterial::UserColor)
00328         {
00329                 // user color. Only texture 0 can be set.
00330                 nlassert( n==0 );
00331 
00332                 // Affect the 2 first textures.
00333                 _Textures[0]=ptex;
00334                 _Textures[1]=ptex;
00335                 _Touched|=IDRV_TOUCHED_TEX[0];
00336                 _Touched|=IDRV_TOUCHED_TEX[1];
00337         }
00338         else if( _ShaderType== CMaterial::LightMap)
00339         {
00340                 // Only texture 0 can be set.
00341                 nlassert( n==0 );
00342                 _Textures[n]=ptex;
00343                 _Touched|=IDRV_TOUCHED_TEX[n];
00344         }
00345         // Normal material?
00346         else
00347         {
00348                 _Textures[n]=ptex;
00349                 _Touched|=IDRV_TOUCHED_TEX[n];
00350         }
00351 }

00322 {
00323         nlassert(_ShaderType==CMaterial::UserColor);
00324         // setup stage 0 constant color (don't use texConstantColor() because of assert).
00325         _TexEnvs[0].ConstantColor= userColor;
00326 }

00370 {
00371         nlassert(isUserTexMatEnabled(stage));
00372         nlassert(_TexUserMat.get() != NULL);
00373         _TexUserMat->TexMat[stage] = m;
00374 }

00113 {
00114         _ZBias=val;
00115         _Touched|=IDRV_TOUCHED_ZBIAS;
00116 }

00100 {
00101         _ZFunction=val;
00102         _Touched|=IDRV_TOUCHED_ZFUNC;
00103 }

00106 {
00107         if (active)     _Flags|=IDRV_MAT_ZWRITE;
00108         else            _Flags&=~IDRV_MAT_ZWRITE;
00109         _Touched|=IDRV_TOUCHED_ZWRITE;
00110 }

00500 {
00501         return( _Flags & IDRV_MAT_TEX_ADDR) != 0;
00502 }

00269 {
00270         nlassert(_ShaderType==CMaterial::Normal);
00271         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00272         _TexEnvs[stage].ConstantColor= color;
00273 }

00248 {
00249         nlassert(_ShaderType==CMaterial::Normal);
00250         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00251         nlassert(oper==SrcAlpha || oper==InvSrcAlpha);
00252         _TexEnvs[stage].Env.SrcArg0Alpha= src;
00253         _TexEnvs[stage].Env.OpArg0Alpha= oper;
00254 }

00222 {
00223         nlassert(_ShaderType==CMaterial::Normal);
00224         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00225         _TexEnvs[stage].Env.SrcArg0RGB= src;
00226         _TexEnvs[stage].Env.OpArg0RGB= oper;
00227 }

00257 {
00258         nlassert(_ShaderType==CMaterial::Normal);
00259         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00260         nlassert(oper==SrcAlpha || oper==InvSrcAlpha);
00261         nlassert(src!=Texture);
00262         _TexEnvs[stage].Env.SrcArg1Alpha= src;
00263         _TexEnvs[stage].Env.OpArg1Alpha= oper;
00264 }

00230 {
00231         nlassert(_ShaderType==CMaterial::Normal);
00232         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00233         nlassert(src!=Texture);
00234         _TexEnvs[stage].Env.SrcArg1RGB= src;
00235         _TexEnvs[stage].Env.OpArg1RGB= oper;
00236 }

00241 {
00242         nlassert(_ShaderType==CMaterial::Normal);
00243         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00244         _TexEnvs[stage].Env.OpAlpha= ope;
00245 }

00215 {
00216         nlassert(_ShaderType==CMaterial::Normal);
00217         nlassert(stage<IDRV_MAT_MAXTEXTURES);
00218         _TexEnvs[stage].Env.OpRGB= ope;
00219 }

00037 {
00038         nlassert(n<IDRV_MAT_MAXTEXTURES);
00039         if (_Textures[n])
00040         {
00041                 return(true);
00042         }
00043         return(false);
00044 }


Public Types
enum	TBlend { one = 0, zero, srcalpha, invsrcalpha, srccolor, invsrccolor, blendConstantColor, blendConstantInvColor, blendConstantAlpha, blendConstantInvAlpha, blendCount }
enum	TShader { Normal = 0, Bump, UserColor, LightMap, Specular, Caustics, PerPixelLighting, PerPixelLightingNoSpec, Cloud, Water, shaderCount }
enum	TTexCoordGenMode { TexCoordGenReflect = 0, TexCoordGenObjectSpace, TexCoordGenEyeSpace, numTexCoordGenMode }
typedef std::vector< CLightMap >	TTexturePtrs
enum	ZFunc { always = 0, never, equal, notequal, less, lessequal, greater, greaterequal, zfuncCount }
Texture Addressing Modes. They are valid only with the normal texture shader.
All modes are not supported everywhere, so you should check for it in the driver. The modes are similar to those introduced with DirectX 8.0 Pixel Shaders and OpenGL TEXTURE_SHADERS_NV
enum	TTexAddressingMode { TextureOff = 0, FetchTexture, PassThrough, CullFragment, OffsetTexture, OffsetTextureScale, DependentARTexture, DependentGBTexture, DP3, DP3Texture2D, DP3CubeMap, DP3ReflectCubeMap, DP3ConstEyeReflectCubeMap, DP3DiffuseCubeMap, DP3DepthReplace, TexAddrCount }
Texture Env Modes.
enum	TTexOperand { SrcColor = 0, InvSrcColor, SrcAlpha, InvSrcAlpha }
enum	TTexOperator { Replace = 0, Modulate, Add, AddSigned, InterpolateTexture, InterpolatePrevious, InterpolateDiffuse, InterpolateConstant, EMBM }
enum	TTexSource { Texture = 0, Previous, Diffuse, Constant }
Public Member Functions
void	clearTouched (uint32 flag)
void	flushTextures (IDriver &driver, uint selectedTexture)
	Flush textures. Force texture generation.
uint32	getFlags () const
const sint &	getRefCount () const
TShader	getShader () const
	get the current material shadertype.
bool	getStainedGlassWindow ()
uint32	getTouched (void) const
void	serial (NLMISC::IStream &f)
void	setShader (TShader val)
void	setStainedGlassWindow (bool val)
Object.
	CMaterial (const CMaterial &mat)
	see operator=.
	CMaterial ()
CMaterial &	operator= (const CMaterial &mat)
	Do not copy DrvInfos, copy all infos and set IDRV_TOUCHED_ALL.
	~CMaterial ()
	dtor.
Texture environnement. Normal shader only.
void	decompUserTexMat (uint stage, float &uTrans, float &vTrans, float &wRot, float &uScale, float &vScale)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	enableUserTexMat (uint stage, bool enabled=true)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
CRGBA	getTexConstantColor (uint stage)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
bool	getTexCoordGen (uint stage) const
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
TTexCoordGenMode	getTexCoordGenMode (uint stage) const
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
uint32	getTexEnvMode (uint stage)
	For push/pop only, get the packed version of the environnment mode.
const NLMISC::CMatrix &	getUserTexMat (uint stage) const
bool	isUserTexMatEnabled (uint stage) const
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	setTexCoordGen (uint stage, bool generate)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	setTexCoordGenMode (uint stage, TTexCoordGenMode mode)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	setTexEnvMode (uint stage, uint32 packed)
	For push/pop only, set the packed version of the environnment mode.
void	setUserTexMat (uint stage, const NLMISC::CMatrix &m)
	Set a new texture matrix for the given stage.
void	texConstantColor (uint stage, CRGBA color)
	Setup the constant color for a stage. Used for the TTexSource:Constant.
void	texEnvArg0Alpha (uint stage, TTexSource src, TTexOperand oper)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	texEnvArg0RGB (uint stage, TTexSource src, TTexOperand oper)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	texEnvArg1Alpha (uint stage, TTexSource src, TTexOperand oper)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	texEnvArg1RGB (uint stage, TTexSource src, TTexOperand oper)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	texEnvOpAlpha (uint stage, TTexOperator ope)
	Decompose a user texture matrix, We assume that this is only a matrix for 2d texture.
void	texEnvOpRGB (uint stage, TTexOperator ope)
Texture Addressing Mode Method
void	enableTexAddrMode (bool enable=true)
TTexAddressingMode	getTexAddressingMode (uint8 stage)
	Get the texture addressing mode for the given stage.
void	setTexAddressingMode (uint8 stage, TTexAddressingMode mode)
bool	texAddrEnabled () const
	test whether texture addressing mode are enabled
Alpha Test
bool	getAlphaTest () const
float	getAlphaTestThreshold () const
void	setAlphaTest (bool active)
void	setAlphaTestThreshold (float thre)
Color/Lighting..
CRGBA	getAmbient () const
CRGBA	getColor (void) const
CRGBA	getDiffuse () const
	return diffuse part. NB: A==opacity.
CRGBA	getEmissive () const
bool	getLightedVertexColor () const
	Get the lighted vertex color flag.
uint8	getOpacity () const
float	getShininess () const
CRGBA	getSpecular () const
bool	isLighted () const
bool	isLightedVertexColor () const
	Return true if this material uses color material as diffuse when lighted, else return false if it uses color vertex.
void	setAmbient (CRGBA ambient=CRGBA(0, 0, 0))
	Set the Ambient part ot material. Usefull only if setLighting(true) has been done.
void	setColor (CRGBA rgba)
	The Color is used only if lighting is disabled. Also, color is replaced by per vertex color (if any).
void	setDiffuse (CRGBA diffuse=CRGBA(0, 0, 0))
	Set the Diffuse part ot material. Usefull only if setLighting(true) has been done. NB: opacity is NOT copied from diffuse.A.
void	setEmissive (CRGBA emissive=CRGBA(0, 0, 0))
	Set the emissive part ot material. Usefull only if setLighting(true) has been done.
void	setLightedVertexColor (bool useLightedVertexColor)
	Set the color material flag. Used when the material is lighted. True to use the diffuse color of the material when lighted, false to use the color vertex.
void	setLighting (bool active, CRGBA emissive=CRGBA(0, 0, 0), CRGBA ambient=CRGBA(0, 0, 0), CRGBA diffuse=CRGBA(0, 0, 0), CRGBA specular=CRGBA(0, 0, 0), float shininess=10)
	Batch setup lighting. Opacity is in diffuse.A.
void	setOpacity (uint8 opa)
	Set the Opacity part ot material. Usefull only if setLighting(true) has been done.
void	setShininess (float shininess)
	Set the shininess part ot material. Usefull only if setLighting(true) has been done.
void	setSpecular (CRGBA specular=CRGBA(0, 0, 0))
	Set the specular part ot material. Usefull only if setLighting(true) has been done.
Blending.
bool	getBlend () const
TBlend	getDstBlend (void) const
TBlend	getSrcBlend (void) const
void	setBlend (bool active)
void	setBlendFunc (TBlend src, TBlend dst)
void	setDstBlend (TBlend val)
void	setSrcBlend (TBlend val)
Double sided.
bool	getDoubleSided () const
void	setDoubleSided (bool active)
LightMap. LightMap shader only.
ITexture *	getLightMap (uint lmapId) const
	Get the ith lightmap. (NULL if none).
void	setLightMap (uint lmapId, ITexture *lmap)
	Set the ith lightmap. undef results if holes in lightmap array.
void	setLightMapColor (uint lmapId, CRGBA color)
	Set the lightmap color (usefull in 8 bits format) (def : White).
void	setLightMapFactor (uint lmapId, CRGBA factor)
	Set the lightmap intensity. (def : White).
void	setLightMapMulx2 (bool val)
	Set the multiply x 2 mode to burn colors (used with lightmaps 8 bits) (def: false).
Texture.
ITexture *	getTexture (uint8 stage) const
void	setTexture (uint8 stage, ITexture *ptex)
bool	texturePresent (uint8 stage) const
Texture UserColor. UserColor shader only.
CRGBA	getUserColor () const
void	setUserColor (CRGBA userColor)
ZBuffer.
float	getZBias (void) const
ZFunc	getZFunc (void) const
bool	getZWrite (void) const
void	setZBias (float val)
void	setZFunc (ZFunc val)
void	setZWrite (bool active)
Tools..
void	initLighted ()
void	initUnlit ()

void	selectTextureSet (uint index)
Data Fields
TTexturePtrs	_LightMaps
bool	_LightMapsMulx2
uint8	_TexAddrMode [IDRV_MAT_MAXTEXTURES]
CTexEnv	_TexEnvs [IDRV_MAT_MAXTEXTURES]
CSmartPtr< ITexture >	_Textures [IDRV_MAT_MAXTEXTURES]
sint	crefs
CPtrInfo *	pinfo
CRefPtr< IShader >	pShader
Static Public Attributes
CPtrInfo	NullPtrInfo
Private Attributes
float	_AlphaTestThreshold
CRGBA	_Ambient
CRGBA	_Color
CRGBA	_Diffuse
TBlend	_DstBlend
CRGBA	_Emissive
uint32	_Flags
TShader	_ShaderType
float	_Shininess
CRGBA	_Specular
TBlend	_SrcBlend
bool	_StainedGlassWindow
uint16	_TexCoordGenMode
std::auto_ptr< CUserTexMat >	_TexUserMat
uint32	_Touched
float	_ZBias
ZFunc	_ZFunction
Friends
struct	CPtrInfo

NL3D::CMaterial Class Reference

Detailed Description

Public Types

Public Member Functions

Data Fields

Static Public Attributes

Private Attributes

Friends

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation