khanat-opennel-code/code/nel/src/3d/material.cpp

629 lines
16 KiB
C++
Raw Normal View History

2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
#include "nel/3d/material.h"
#include "nel/3d/texture.h"
#include "nel/3d/shader.h"
#include "nel/3d/driver.h"
#include "nel/misc/stream.h"
using namespace std;
using namespace NLMISC;
namespace NL3D
{
// ***************************************************************************
CMaterial::CMaterial()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
_Touched= 0;
_Flags= IDRV_MAT_ZWRITE;
// Must init All the flags by default.
_ShaderType= Normal;
_SrcBlend= srcalpha;
_DstBlend= invsrcalpha;
_ZFunction= lessequal;
_ZBias= 0;
_Color.set(255,255,255,255);
_StainedGlassWindow = false;
_AlphaTestThreshold= 0.5f;
_TexCoordGenMode= 0;
_LightMapsMulx2= false;
}
// ***************************************************************************
void CMaterial::initUnlit()
{
setShader(Normal);
setLighting(false);
setColor(CRGBA(255,255,255,255));
for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
setTexture((uint8)i ,NULL);
setZBias(0);
setZFunc(lessequal);
setZWrite(true);
setBlend(false);
setAlphaTestThreshold(0.5f);
}
// ***************************************************************************
void CMaterial::initLighted()
{
initUnlit();
setLighting(true);
}
// ***************************************************************************
CMaterial &CMaterial::operator=(const CMaterial &mat)
{
_ShaderType= mat._ShaderType;
_Flags= mat._Flags;
_SrcBlend= mat._SrcBlend;
_DstBlend= mat._DstBlend;
_ZFunction= mat._ZFunction;
_ZBias= mat._ZBias;
_Color= mat._Color;
_Emissive= mat._Emissive;
_Ambient= mat._Ambient;
_Diffuse= mat._Diffuse;
_Specular= mat._Specular;
_Shininess= mat._Shininess;
_AlphaTestThreshold= mat._AlphaTestThreshold;
_TexCoordGenMode= mat._TexCoordGenMode;
for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
{
_Textures[i]= mat._Textures[i];
_TexEnvs[i]= mat._TexEnvs[i];
_TexAddrMode[i] = mat._TexAddrMode[i];
}
// copy lightmaps.
_LightMaps= mat._LightMaps;
_LightMapsMulx2= mat._LightMapsMulx2;
// copy texture matrix if there.
if (mat._TexUserMat.get())
{
std::auto_ptr<CUserTexMat> texMatClone( new CUserTexMat(*(mat._TexUserMat))); // make cpy
//std::swap(texMatClone, _TexUserMat); // swap with old
_TexUserMat = texMatClone;
}
else
{
_TexUserMat.reset();
}
// Must do not copy drv info.
// All states of material is modified.
_Touched= IDRV_TOUCHED_ALL;
return *this;
}
// ***************************************************************************
CMaterial::~CMaterial()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
// Must kill the drv mirror of this material.
_MatDrvInfo.kill();
}
// ***************************************************************************
void CMaterial::serial(NLMISC::IStream &f)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
/*
Version 9:
- Added support for third operand (for Mad operator)
Version 8:
- Serial _TexCoordGenMode
Version 7:
- Lightmap color and Mulx2
Version 6:
- Texture matrix animation
Version 5:
- AlphaTest threshold
Version 4:
- Texture Addressing modes
Version 3:
- LightMaps.
Version 2:
- Shininess.
Version 1:
- texture environement.
Version 0:
- base version.
*/
sint ver= f.serialVersion(9);
// For the version <=1:
nlassert(IDRV_MAT_MAXTEXTURES==4);
f.serialEnum(_ShaderType);
f.serial(_Flags);
f.serialEnum(_SrcBlend);
f.serialEnum(_DstBlend);
f.serialEnum(_ZFunction);
f.serial(_ZBias);
f.serial(_Color);
f.serial(_Emissive, _Ambient, _Diffuse, _Specular);
if(ver>=2)
{
f.serial(_Shininess);
}
if(ver>=5)
{
f.serial(_AlphaTestThreshold);
}
if(ver>=8)
{
f.serial(_TexCoordGenMode);
}
else
_TexCoordGenMode = 0;
for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
{
// Serial texture descriptor.
_Textures[i].serialPolyPtr(f);
// Read texture environnement, or setup them.
if(ver>=1)
{
_TexEnvs[i].serial(f, ver >= 9 ? 1 : 0);
}
else
{
// Else setup as default behavior, like before...
if(f.isReading())
_TexEnvs[i].setDefault();
}
}
if(ver>=3)
{
if(ver>=7)
{
uint32 n;
if (f.isReading())
{
f.serial(n);
_LightMaps.resize(n);
}
else
{
n = _LightMaps.size();
f.serial(n);
}
for (uint32 i = 0; i < n; ++i)
_LightMaps[i].serial2(f);
f.serial(_LightMapsMulx2);
}
else
{
f.serialCont(_LightMaps);
}
}
if (ver >= 4)
{
if (_Flags & IDRV_MAT_TEX_ADDR)
{
for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
{
f.serial(_TexAddrMode[i]);
}
}
}
if(f.isReading())
{
// Converte Deprecated DEFMAT to std Mat.
if(_Flags & IDRV_MAT_DEFMAT)
{
setEmissive(CRGBA::Black);
setAmbient(CRGBA::White);
setDiffuse(CRGBA::White);
setSpecular(CRGBA::Black);
}
// All states of material are modified.
_Touched= IDRV_TOUCHED_ALL;
if ((_Flags & IDRV_MAT_USER_TEX_MAT_ALL)) // are there user textrue coordinates matrix ?
{
std::auto_ptr<CUserTexMat> newPtr(new CUserTexMat); // create new
//std::swap(_TexUserMat, newPtr); // replace old
_TexUserMat = newPtr;
}
}
if (ver >= 6)
{
for(uint i=0; i < IDRV_MAT_MAXTEXTURES; ++i)
{
if (isUserTexMatEnabled(i))
{
f.serial(_TexUserMat->TexMat[i]);
}
}
}
}
// ***************************************************************************
void CMaterial::setShader(TShader val)
{
// First, reset all textures.
uint nTexts= IDRV_MAT_MAXTEXTURES;
// If user color or lightmap, set only the 1st.
if(_ShaderType==LightMap || _ShaderType==UserColor)
nTexts=1;
// reset all needed
for(uint i=0;i<nTexts;i++)
setTexture(i ,NULL);
// If userColor, use TexEnv caps (we got it, so use it :) ).
if(val== CMaterial::UserColor)
{
// force normal, to setup TexEnvMode correclty.
_ShaderType=CMaterial::Normal;
// First stage, interpolate Constant and texture with Alpha of texture.
texEnvOpRGB(0, InterpolateTexture);
texEnvArg0RGB(0, Texture, SrcColor);
texEnvArg1RGB(0, Constant, SrcColor);
// And just use Alpha Diffuse.
texEnvOpAlpha(0, Replace);
texEnvArg0Alpha(0, Previous, SrcAlpha);
// Second stage, modulate result with diffuse color.
texEnvOpRGB(1, Modulate);
texEnvArg0RGB(1, Previous, SrcColor);
texEnvArg1RGB(1, Diffuse, SrcColor);
// And just use Alpha Diffuse.
texEnvOpAlpha(1, Replace);
texEnvArg0Alpha(1, Previous, SrcAlpha);
}
_ShaderType= val;
_Touched|=IDRV_TOUCHED_SHADER;
}
// ***************************************************************************
void CMaterial::setTexture(uint8 n, ITexture* ptex)
{
nlassert(n<IDRV_MAT_MAXTEXTURES);
// User Color material?
if( _ShaderType== CMaterial::UserColor)
{
// user color. Only texture 0 can be set.
nlassert( n==0 );
// Affect the 2 first textures.
_Textures[0]=ptex;
_Textures[1]=ptex;
_Touched|=IDRV_TOUCHED_TEX[0];
_Touched|=IDRV_TOUCHED_TEX[1];
}
else if( _ShaderType== CMaterial::LightMap)
{
// Only texture 0 can be set.
nlassert( n==0 );
_Textures[n]=ptex;
_Touched|=IDRV_TOUCHED_TEX[n];
}
// Normal material?
else
{
_Textures[n]=ptex;
_Touched|=IDRV_TOUCHED_TEX[n];
}
}
// ***************************************************************************
void CMaterial::flushTextures (IDriver &driver, uint selectedTexture)
{
// For each textures
for (uint tex=0; tex<IDRV_MAT_MAXTEXTURES; tex++)
{
// Texture exist ?
if (_Textures[tex])
{
// Select the good texture
_Textures[tex]->selectTexture (selectedTexture);
// Force setup texture
driver.setupTexture (*_Textures[tex]);
}
}
// If Lightmap material
if(_ShaderType==LightMap)
{
// For each lightmap
for (uint lmap=0; lmap<_LightMaps.size(); lmap++)
{
// Texture exist?
if(_LightMaps[lmap].Texture)
{
// Force setup texture
driver.setupTexture (*_LightMaps[lmap].Texture);
}
}
}
}
// ***************************************************************************
void CMaterial::setLightMap(uint lmapId, ITexture *lmap)
{
nlassert(_ShaderType==CMaterial::LightMap);
if(lmapId>=_LightMaps.size())
_LightMaps.resize(lmapId+1);
_LightMaps[lmapId].Texture= lmap;
_Touched|=IDRV_TOUCHED_LIGHTMAP;
}
// ***************************************************************************
ITexture *CMaterial::getLightMap(uint lmapId) const
{
nlassert(_ShaderType==CMaterial::LightMap);
if(lmapId<_LightMaps.size())
return _LightMaps[lmapId].Texture;
else
return NULL;
}
// ***************************************************************************
void CMaterial::setLightMapFactor(uint lmapId, CRGBA factor)
{
if (_ShaderType==CMaterial::LightMap)
{
if(lmapId>=_LightMaps.size())
_LightMaps.resize(lmapId+1);
_LightMaps[lmapId].Factor= factor;
_Touched|=IDRV_TOUCHED_LIGHTMAP;
}
}
// ***************************************************************************
void CMaterial::setLMCColors(uint lmapId, CRGBA ambColor, CRGBA diffColor)
{
if (_ShaderType==CMaterial::LightMap)
{
if(lmapId>=_LightMaps.size())
_LightMaps.resize(lmapId+1);
_LightMaps[lmapId].LMCAmbient= ambColor;
_LightMaps[lmapId].LMCDiffuse= diffColor;
_Touched|=IDRV_TOUCHED_LIGHTMAP;
}
}
// ***************************************************************************
// DEPRECATED VERSION
void CMaterial::CLightMap::serial(NLMISC::IStream &f)
{
f.serial(Factor);
// Serial texture descriptor.
Texture.serialPolyPtr(f);
}
// ***************************************************************************
void CMaterial::CLightMap::serial2(NLMISC::IStream &f)
{
sint ver= f.serialVersion(1);
f.serial(Factor);
f.serial(LMCDiffuse);
if(ver>=1)
f.serial(LMCAmbient);
// Serial texture descriptor.
Texture.serialPolyPtr(f);
}
// ***************************************************************************
void CMaterial::enableTexAddrMode(bool enable /*= true*/)
{
if (enable)
{
if (!(_Flags & IDRV_MAT_TEX_ADDR))
{
_Flags |= IDRV_MAT_TEX_ADDR;
for (uint32 k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
_TexAddrMode[k] = (uint8) TextureOff;
}
}
}
else
{
_Flags &= ~IDRV_MAT_TEX_ADDR;
}
}
// ***************************************************************************
bool CMaterial::texAddrEnabled() const
{
return( _Flags & IDRV_MAT_TEX_ADDR) != 0;
}
// ***************************************************************************
void CMaterial::setTexAddressingMode(uint8 stage, TTexAddressingMode mode)
{
nlassert(_Flags & IDRV_MAT_TEX_ADDR);
nlassert(stage < IDRV_MAT_MAXTEXTURES);
nlassert(mode < TexAddrCount);
_TexAddrMode[stage] = (uint8) mode;
}
// ***************************************************************************
CMaterial::TTexAddressingMode CMaterial::getTexAddressingMode(uint8 stage)
{
nlassert(_Flags & IDRV_MAT_TEX_ADDR);
nlassert(stage < IDRV_MAT_MAXTEXTURES);
return (TTexAddressingMode) _TexAddrMode[stage];
}
// ***************************************************************************
void CMaterial::decompUserTexMat(uint stage, float &uTrans, float &vTrans, float &wRot, float &uScale, float &vScale)
{
nlassert(stage < IDRV_MAT_MAXTEXTURES);
nlassert(isUserTexMatEnabled(stage)); // must activate animated texture matrix for this stage
CMatrix convMat; // exported v are already inverted (todo: optim this...)
convMat.setRot(CVector::I, -CVector::J, CVector::K);
convMat.setPos(CVector::J);
const NLMISC::CMatrix texMat = convMat * _TexUserMat->TexMat[stage] * convMat;
/// find the rotation around w
NLMISC::CVector i = texMat.getI();
NLMISC::CVector j = texMat.getJ();
uScale = sqrtf(i.x * i.x + j.x * j.x);
vScale = sqrtf(i.y * i.y + j.y * j.y);
//
i.normalize();
//
float angle = acosf(i.x / i.norm());
if (i.y < 0)
{
angle = 2.f * (float) NLMISC::Pi - angle;
}
wRot = angle;
// compute position
CMatrix InvSR;
InvSR.setRot(texMat.getI(), texMat.getJ(), texMat.getK());
InvSR.invert();
CVector half(0.5f, 0.5f, 0.f);
CVector offset = half + InvSR * (texMat.getPos() -half);
uTrans = - offset.x;
vTrans = - offset.y;
}
// ***************************************************************************
void CMaterial::selectTextureSet(uint index)
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
if (_Textures[k] != NULL) _Textures[k]->selectTexture(index);
}
}
// ***************************************************************************
IMaterialDrvInfos::~IMaterialDrvInfos()
{
_Driver->removeMatDrvInfoPtr(_DriverIterator);
}
// ***************************************************************************
uint CMaterial::getNumUsedTextureStages() const
{
for(uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
if (!_Textures[k]) return k;
}
return IDRV_MAT_MAXTEXTURES;
}
// ***************************************************************************
bool CMaterial::isSupportedByDriver(IDriver &drv, bool forceBaseCaps) const
{
uint numTexStages = drv.getNbTextureStages();
// special case for radeon : though 3 stages are supported, do as if there were only 2, because of the texEnvColor feature
// not managed in Direct3D : emulation is provided, but for no more than 2 constants (and if diffuse is not used)
if (numTexStages == 3) numTexStages = 2;
if (forceBaseCaps) numTexStages = std::min(numTexStages, (uint) 2);
switch(getShader())
{
case Normal:
{
if (getNumUsedTextureStages() > numTexStages) return false;
// see if each tex env is supported
for(uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
if (getTexture(k))
{
switch(getTexEnvOpRGB(k))
{
case InterpolateConstant: if (!drv.supportBlendConstantColor()) return false;
case EMBM: if (forceBaseCaps || !drv.supportEMBM() || !drv.isEMBMSupportedAtStage(k)) return false;
case Mad: if (!drv.supportMADOperator()) return false;
default: break;
}
switch(getTexEnvOpAlpha(k))
{
case InterpolateConstant: if (!drv.supportBlendConstantColor()) return false;
case EMBM: if (forceBaseCaps || !drv.supportEMBM() || !drv.isEMBMSupportedAtStage(k)) return false;
case Mad: if (!drv.supportMADOperator()) return false;
default: break;
}
}
}
return true;
}
break;
case Bump: return false; // not impl.
case UserColor: return true;
case LightMap: return true;
case Specular: return true;
case Caustics: return false;
case PerPixelLighting: return drv.supportPerPixelLighting(true);
case PerPixelLightingNoSpec: return drv.supportPerPixelLighting(false);
case Cloud: return true;
case Water: return true;
default:
nlassert(0); // unknown shader, must complete
}
return false;
}
}