nevrax.org : docs

00001 
+00007 /* Copyright, 2000 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 
+00028 #include "3d/material.h"
+00029 #include "3d/texture.h"
+00030 #include "3d/shader.h"
+00031 #include "3d/driver.h"
+00032 #include "nel/misc/stream.h"
+00033 
+00034 using namespace std;
+00035 using namespace NLMISC;
+00036 
+00037 namespace NL3D
+00038 {
+00039 
+00040 // ***************************************************************************
+00041 CMaterial::CMaterial()
+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 }
+00055 
+00056 // ***************************************************************************
+00057 void                    CMaterial::initUnlit()
+00058 {
+00059         setShader(Normal);
+00060         setLighting(false);
+00061         setColor(CRGBA(255,255,255,255));
+00062         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
+00063                 setTexture((uint8)i ,NULL);
+00064         setZBias(0);
+00065         setZFunc(lessequal);
+00066         setZWrite(true);
+00067         setBlend(false);
+00068         setAlphaTestThreshold(0.5f);
+00069 }
+00070 
+00071 // ***************************************************************************
+00072 
+00073 void                    CMaterial::initLighted()
+00074 {
+00075         initUnlit();
+00076         setLighting(true);
+00077 }
+00078 
+00079 
+00080 // ***************************************************************************
+00081 CMaterial               &CMaterial::operator=(const CMaterial &mat)
+00082 {
+00083         _ShaderType= mat._ShaderType;
+00084         _Flags= mat._Flags;
+00085         _SrcBlend= mat._SrcBlend;
+00086         _DstBlend= mat._DstBlend;
+00087         _ZFunction= mat._ZFunction;
+00088         _ZBias= mat._ZBias;
+00089         _Color= mat._Color;
+00090         _Emissive= mat._Emissive;
+00091         _Ambient= mat._Ambient;
+00092         _Diffuse= mat._Diffuse;
+00093         _Specular= mat._Specular;
+00094         _Shininess= mat._Shininess;
+00095         _AlphaTestThreshold= mat._AlphaTestThreshold;
+00096 
+00097         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
+00098         {
+00099                 _Textures[i]= mat._Textures[i];
+00100                 _TexEnvs[i]= mat._TexEnvs[i];
+00101                 _TexAddrMode[i] = mat._TexAddrMode[i];
+00102         }
+00103 
+00104         // copy lightmaps.
+00105         _LightMaps= mat._LightMaps;
+00106 
+00107         // copy texture matrix if there.
+00108         if (mat._TexUserMat.get())
+00109         {
+00110                 std::auto_ptr<CUserTexMat> texMatClone( new CUserTexMat(*(mat._TexUserMat))); // make cpy
+00111                 std::swap(texMatClone, _TexUserMat); // swap with old
+00112         }
+00113         else
+00114         {
+00115                 _TexUserMat.reset();    
+00116         }
+00117 
+00118         // Must do not copy drv info.
+00119 
+00120         // All states of material is modified.
+00121         _Touched= IDRV_TOUCHED_ALL;
+00122 
+00123         return *this;
+00124 }
+00125 
+00126 
+00127 // ***************************************************************************
+00128 CMaterial::~CMaterial()
+00129 {
+00130         // Must kill the drv mirror of this material.
+00131         pShader.kill(); 
+00132 }
+00133 
+00134 
+00135 // ***************************************************************************
+00136 void            CMaterial::serial(NLMISC::IStream &f)
+00137 {
+00138         /*
+00139         Version 6:
+00140                 - Texture matrix animation
+00141         Version 5:
+00142                 - AlphaTest threshold
+00143         Version 4:
+00144                 - Texture Addressing modes
+00145         Version 3:
+00146                 - LightMaps.
+00147         Version 2:
+00148                 - Shininess.
+00149         Version 1:
+00150                 - texture environement.
+00151         Version 0:
+00152                 - base version.
+00153         */
+00154 
+00155         sint    ver= f.serialVersion(6);
+00156         // For the version <=1:
+00157         nlassert(IDRV_MAT_MAXTEXTURES==4);
+00158 
+00159         f.serialEnum(_ShaderType);
+00160         f.serial(_Flags);
+00161         f.serialEnum(_SrcBlend);
+00162         f.serialEnum(_DstBlend);
+00163         f.serialEnum(_ZFunction);
+00164         f.serial(_ZBias);
+00165         f.serial(_Color);
+00166         f.serial(_Emissive, _Ambient, _Diffuse, _Specular);
+00167         if(ver>=2)
+00168         {
+00169                 f.serial(_Shininess);
+00170         }
+00171         if(ver>=5)
+00172         {
+00173                 f.serial(_AlphaTestThreshold);
+00174         }
+00175 
+00176 
+00177         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
+00178         {
+00179                 // Serial texture descriptor.
+00180                 ITexture*       text;
+00181                 if(f.isReading())
+00182                 {
+00183                         f.serialPolyPtr(text);
+00184                         _Textures[i]= text;
+00185                 }
+00186                 else
+00187                 {
+00188                         text= _Textures[i];
+00189                         f.serialPolyPtr(text);
+00190                 }
+00191 
+00192                 // Read texture environnement, or setup them.
+00193                 if(ver>=1)
+00194                 {
+00195                         f.serial(_TexEnvs[i]);
+00196                 }
+00197                 else
+00198                 {
+00199                         // Else setup as default behavior, like before...
+00200                         if(f.isReading())
+00201                                 _TexEnvs[i].setDefault();
+00202                 }
+00203         }
+00204 
+00205         if(ver>=3)
+00206         {
+00207                 f.serialCont(_LightMaps);
+00208         }
+00209 
+00210         if (ver >= 4)
+00211         {
+00212                 if (_Flags & IDRV_MAT_TEX_ADDR)
+00213                 {
+00214                         for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
+00215                         {
+00216                                 f.serial(_TexAddrMode[i]);
+00217                         }
+00218                 }
+00219         }
+00220 
+00221         if(f.isReading())
+00222         {
+00223                 // Converte Deprecated DEFMAT to std Mat.
+00224                 if(_Flags & IDRV_MAT_DEFMAT)
+00225                 {
+00226                         setEmissive(CRGBA::Black);
+00227                         setAmbient(CRGBA::White);
+00228                         setDiffuse(CRGBA::White);
+00229                         setSpecular(CRGBA::Black);
+00230                 }
+00231 
+00232                 // All states of material are modified.
+00233                 _Touched= IDRV_TOUCHED_ALL;
+00234 
+00235                 if ((_Flags & IDRV_MAT_USER_TEX_MAT_ALL)) // are there user textrue coordinates matrix ?
+00236                 {
+00237                         std::auto_ptr<CUserTexMat> newPtr(new CUserTexMat); // create new                       
+00238                         std::swap(_TexUserMat, newPtr); // replace old
+00239                 }
+00240         }
+00241 
+00242         if (ver >= 6)
+00243         {
+00244                 for(uint i=0; i < IDRV_MAT_MAXTEXTURES; ++i)
+00245                 {
+00246                         if (isUserTexMatEnabled(i))
+00247                         {                               
+00248                                 f.serial(_TexUserMat->TexMat[i]);                               
+00249                         }                       
+00250                 }
+00251         }
+00252 
+00253 }
+00254 
+00255 
+00256 // ***************************************************************************
+00257 void            CMaterial::setShader(TShader val)
+00258 {
+00259         // First, reset all textures.
+00260         uint    nTexts= IDRV_MAT_MAXTEXTURES;
+00261         // If user color or lightmap, set only the 1st.
+00262         if(_ShaderType==LightMap || _ShaderType==UserColor)
+00263                 nTexts=1;
+00264         // reset all needed
+00265         for(uint i=0;i<nTexts;i++)
+00266                 setTexture(i ,NULL);
+00267 
+00268         // If userColor, use TexEnv caps (we got it, so use it :) ).
+00269         if(val== CMaterial::UserColor)
+00270         {
+00271                 // force normal, to setup TexEnvMode correclty. 
+00272                 _ShaderType=CMaterial::Normal;
+00273 
+00274                 // First stage, interpolate Constant and texture with Alpha of texture.
+00275                 texEnvOpRGB(0, InterpolateTexture);
+00276                 texEnvArg0RGB(0, Texture, SrcColor);
+00277                 texEnvArg1RGB(0, Constant, SrcColor);
+00278                 // And just use Alpha Diffuse.
+00279                 texEnvOpAlpha(0, Replace);
+00280                 texEnvArg0Alpha(0, Previous, SrcAlpha);
+00281 
+00282                 // Second stage, modulate result with diffuse color.
+00283                 texEnvOpRGB(1, Modulate);
+00284                 texEnvArg0RGB(1, Previous, SrcColor);
+00285                 texEnvArg1RGB(1, Diffuse, SrcColor);
+00286                 // And just use Alpha Diffuse.
+00287                 texEnvOpAlpha(1, Replace);
+00288                 texEnvArg0Alpha(1, Previous, SrcAlpha);
+00289         }
+00290 
+00291         _ShaderType= val;
+00292         _Touched|=IDRV_TOUCHED_SHADER;
+00293 }
+00294 
+00295 
+00296 // ***************************************************************************
+00297 void CMaterial::setTexture(uint8 n, ITexture* ptex)
+00298 {
+00299         nlassert(n<IDRV_MAT_MAXTEXTURES);
+00300 
+00301         // User Color material?
+00302         if( _ShaderType== CMaterial::UserColor)
+00303         {
+00304                 // user color. Only texture 0 can be set.
+00305                 nlassert( n==0 );
+00306 
+00307                 // Affect the 2 first textures.
+00308                 _Textures[0]=ptex;
+00309                 _Textures[1]=ptex;
+00310                 _Touched|=IDRV_TOUCHED_TEX[0];
+00311                 _Touched|=IDRV_TOUCHED_TEX[1];
+00312         }
+00313         else if( _ShaderType== CMaterial::LightMap)
+00314         {
+00315                 // Only texture 0 can be set.
+00316                 nlassert( n==0 );
+00317                 _Textures[n]=ptex;
+00318                 _Touched|=IDRV_TOUCHED_TEX[n];
+00319         }
+00320         // Normal material?
+00321         else
+00322         {
+00323                 _Textures[n]=ptex;
+00324                 _Touched|=IDRV_TOUCHED_TEX[n];
+00325         }
+00326 }
+00327 
+00328 
+00329 // ***************************************************************************
+00330 void                    CMaterial::flushTextures (IDriver &driver)
+00331 {
+00332         // For each textures
+00333         for (uint tex=0; tex<IDRV_MAT_MAXTEXTURES; tex++)
+00334         {
+00335                 // Texture exist ?
+00336                 if (_Textures[tex])
+00337                 {
+00338                         // Force setup texture
+00339                         driver.setupTexture (*_Textures[tex]);
+00340                 }
+00341         }
+00342 
+00343         // If Lightmap material
+00344         if(_ShaderType==LightMap)
+00345         {
+00346                 // For each lightmap
+00347                 for (uint lmap=0; lmap<_LightMaps.size(); lmap++)
+00348                 {
+00349                         // Texture exist?
+00350                         if(_LightMaps[lmap].Texture)
+00351                         {
+00352                                 // Force setup texture
+00353                                 driver.setupTexture (*_LightMaps[lmap].Texture);
+00354                         }
+00355                 }
+00356         }
+00357 
+00358 }
+00359 
+00360 
+00361 // ***************************************************************************
+00362 void                                    CMaterial::setLightMap(uint lmapId, ITexture *lmap)
+00363 {
+00364         nlassert(_ShaderType==CMaterial::LightMap);
+00365         if(lmapId>=_LightMaps.size())
+00366                 _LightMaps.resize(lmapId+1);
+00367         _LightMaps[lmapId].Texture= lmap;
+00368 
+00369         _Touched|=IDRV_TOUCHED_LIGHTMAP;
+00370 }
+00371 
+00372 // ***************************************************************************
+00373 ITexture                                *CMaterial::getLightMap(uint lmapId) const
+00374 {
+00375         nlassert(_ShaderType==CMaterial::LightMap);
+00376         if(lmapId<_LightMaps.size())
+00377                 return _LightMaps[lmapId].Texture;
+00378         else
+00379                 return NULL;    
+00380 }
+00381 
+00382 // ***************************************************************************
+00383 void                                    CMaterial::setLightMapFactor(uint lmapId, CRGBA factor)
+00384 {
+00385         if (_ShaderType==CMaterial::LightMap)
+00386         {
+00387                 if(lmapId>=_LightMaps.size())
+00388                         _LightMaps.resize(lmapId+1);
+00389                 _LightMaps[lmapId].Factor= factor;
+00390 
+00391                 _Touched|=IDRV_TOUCHED_LIGHTMAP;
+00392         }
+00393 }
+00394 
+00395 
+00396 // ***************************************************************************
+00397 void                    CMaterial::CLightMap::serial(NLMISC::IStream &f)
+00398 {
+00399         f.serial(Factor);
+00400         // Serial texture descriptor.
+00401         ITexture*       text= NULL;
+00402         if(f.isReading())
+00403         {
+00404                 f.serialPolyPtr(text);
+00405                 Texture= text;
+00406         }
+00407         else
+00408         {
+00409                 text= Texture;
+00410                 f.serialPolyPtr(text);
+00411         }
+00412 }
+00413 
+00414 
+00415 
+00416 // ***************************************************************************
+00417 void                            CMaterial::enableTexAddrMode(bool enable /*= true*/)
+00418 {
+00419         if (enable)
+00420         {
+00421                 if (!(_Flags & IDRV_MAT_TEX_ADDR))
+00422                 {
+00423                         _Flags |= IDRV_MAT_TEX_ADDR;
+00424                         for (uint32 k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
+00425                         {
+00426                                 _TexAddrMode[k] = (uint8) FetchTexture;
+00427                         }                       
+00428                 }               
+00429         }
+00430         else
+00431         {
+00432                 _Flags &= ~IDRV_MAT_TEX_ADDR;                   
+00433         }
+00434 }
+00435 
+00436 // ***************************************************************************
+00437 bool                        CMaterial::texAddrEnabled() const
+00438 {
+00439         return( _Flags & IDRV_MAT_TEX_ADDR) != 0;
+00440 }
+00441 
+00442 // ***************************************************************************
+00443 void                            CMaterial::setTexAddressingMode(uint8 stage, TTexAddressingMode mode)
+00444 {
+00445         nlassert(_Flags & IDRV_MAT_TEX_ADDR);
+00446         nlassert(stage < IDRV_MAT_MAXTEXTURES);
+00447         nlassert(mode < TexAddrCount);
+00448         _TexAddrMode[stage] = (uint8) mode;     
+00449 }
+00450 
+00451 
+00452 // ***************************************************************************
+00453 CMaterial::TTexAddressingMode   CMaterial::getTexAddressingMode(uint8 stage)
+00454 {
+00455         nlassert(_Flags & IDRV_MAT_TEX_ADDR);
+00456         nlassert(stage < IDRV_MAT_MAXTEXTURES);
+00457         return (TTexAddressingMode) _TexAddrMode[stage];
+00458 }
+00459 
+00460 // ***************************************************************************
+00461 void                                    CMaterial::decompUserTexMat(uint stage, float &uTrans, float &vTrans, float &wRot, float &uScale, float &vScale)
+00462 {
+00463         nlassert(stage < IDRV_MAT_MAXTEXTURES);
+00464         nlassert(isUserTexMatEnabled(stage)); // must activate animated texture matrix for this stage
+00465         const NLMISC::CMatrix texMat = _TexUserMat->TexMat[stage];
+00466         uTrans = texMat.getPos().x;
+00467         vTrans = texMat.getPos().y;
+00469         NLMISC::CVector i = texMat.getI();
+00470         NLMISC::CVector j = texMat.getJ();
+00471         float  normI = i.norm();
+00472         float  normJ = i.norm();
+00473         i /= normI;
+00474         j /= normJ;     
+00475         float angle = ::acosf(i.x);
+00476         if (i.y < 0)
+00477         {
+00478                 angle = 2.f * (float) NLMISC::Pi - angle;
+00479         }
+00480         wRot   = angle; 
+00481         uScale = normI;
+00482         vScale = normJ;
+00483 }
+00484 
+00485 // ***************************************************************************
+00486 void            CMaterial::selectTextureSet(uint index)
+00487 {
+00488         for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
+00489         {
+00490                 if (_Textures[k] != NULL) _Textures[k]->selectTexture(index);
+00491         }
+00492 }
+00493 
+00494 }
+00495 
+
material.cpp
