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

478 lines
14 KiB
C++
Raw Normal View History

// 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/animated_material.h"
#include "nel/misc/common.h"
using namespace NLMISC;
namespace NL3D
{
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CMaterialBase::CAnimatedTexture::serial(NLMISC::IStream &f)
{
ITexture *text= NULL;
if(f.isReading())
{
f.serialPolyPtr(text);
Texture= text;
}
else
{
text= Texture;
f.serialPolyPtr(text);
}
}
// ***************************************************************************
CMaterialBase::CMaterialBase()
{
DefaultAmbient.setDefaultValue(CRGBA(64,64,64));
DefaultDiffuse.setDefaultValue(CRGBA(128,128,128));
DefaultSpecular.setDefaultValue(CRGBA(0,0,0));
DefaultShininess.setDefaultValue(10);
DefaultEmissive.setDefaultValue(CRGBA(128,128,128));
DefaultOpacity.setDefaultValue(1);
DefaultTexture.setDefaultValue(0x7FFFFFFF);
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
DefaultTexAnimTracks[k].setDefaultValue();
}
}
// ***************************************************************************
void CMaterialBase::serial(NLMISC::IStream &f)
{
sint ver= f.serialVersion(1);
f.serial(Name);
f.serial(DefaultAmbient, DefaultDiffuse, DefaultSpecular);
f.serial(DefaultShininess, DefaultEmissive, DefaultOpacity, DefaultTexture);
f.serialCont(_AnimatedTextures);
if (ver > 0)
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
f.serial(DefaultTexAnimTracks[k]);
}
}
}
// ***************************************************************************
void CMaterialBase::copyFromMaterial(CMaterial *pMat)
{
DefaultAmbient.setDefaultValue(pMat->getAmbient());
DefaultDiffuse.setDefaultValue(pMat->getDiffuse());
DefaultSpecular.setDefaultValue(pMat->getSpecular());
DefaultShininess.setDefaultValue(pMat->getShininess());
DefaultEmissive.setDefaultValue(pMat->getEmissive());
DefaultOpacity.setDefaultValue(pMat->getDiffuse().A/255.f);
/// get uv value from material
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
if (pMat->isUserTexMatEnabled(k))
{
float uTrans, vTrans, uScale, vScale, wRot;
pMat->decompUserTexMat(k, uTrans, vTrans, wRot, uScale, vScale);
DefaultTexAnimTracks[k].DefaultUTrans.setDefaultValue(uTrans);
DefaultTexAnimTracks[k].DefaultVTrans.setDefaultValue(vTrans);
DefaultTexAnimTracks[k].DefaultUScale.setDefaultValue(uScale);
DefaultTexAnimTracks[k].DefaultVScale.setDefaultValue(vScale);
DefaultTexAnimTracks[k].DefaultWRot.setDefaultValue(wRot);
}
}
}
// ***************************************************************************
void CMaterialBase::setAnimatedTexture(uint32 id, CSmartPtr<ITexture> pText)
{
// add or replace the texture.
_AnimatedTextures[id].Texture= pText;
}
// ***************************************************************************
bool CMaterialBase::validAnimatedTexture(uint32 id)
{
TAnimatedTextureMap::iterator it;
it= _AnimatedTextures.find(id);
return it!=_AnimatedTextures.end();
}
// ***************************************************************************
ITexture* CMaterialBase::getAnimatedTexture(uint32 id)
{
TAnimatedTextureMap::iterator it;
it= _AnimatedTextures.find(id);
if( it!=_AnimatedTextures.end() )
return it->second.Texture;
else
return NULL;
}
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CAnimatedMaterial::CAnimatedMaterial(CMaterialBase *baseMat)
{
nlassert(baseMat);
_MaterialBase= baseMat;
// IAnimatable.
IAnimatable::resize(AnimValueLast);
_Ambient.Value= _MaterialBase->DefaultAmbient.getDefaultValue();
_Diffuse.Value= _MaterialBase->DefaultDiffuse.getDefaultValue();
_Specular.Value= _MaterialBase->DefaultSpecular.getDefaultValue();
_Shininess.Value= _MaterialBase->DefaultShininess.getDefaultValue();
_Emissive.Value= _MaterialBase->DefaultEmissive.getDefaultValue();
_Opacity.Value= _MaterialBase->DefaultOpacity.getDefaultValue();
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
_TexAnimatedMatValues[k].affect(baseMat->DefaultTexAnimTracks[k]);
}
}
// ***************************************************************************
void CAnimatedMaterial::setMaterial(CMaterial *pMat)
{
_Material= pMat;
}
// ***************************************************************************
std::string CAnimatedMaterial::getMaterialName() const
{
nlassert(_MaterialBase);
return _MaterialBase->Name;
}
// ***************************************************************************
void CAnimatedMaterial::update()
{
if(isTouched(OwnerBit) && _Material!=NULL /*&& _Material->isLighted()*/)
{
// well, just update all... :)
// diffuse part.
CRGBA diff= _Diffuse.Value;
sint c= (sint)(_Opacity.Value*255);
clamp(c, 0, 255);
diff.A= c;
// setup material.
if (_Material->isLighted())
{
_Material->setLighting(true, _Emissive.Value, _Ambient.Value, diff, _Specular.Value, _Shininess.Value);
}
else
{
_Material->setColor(diff);
}
// clear flags.
clearFlag(AmbientValue);
clearFlag(DiffuseValue);
clearFlag(SpecularValue);
clearFlag(ShininessValue);
clearFlag(EmissiveValue);
clearFlag(OpacityValue);
// Texture Anim.
if(isTouched(TextureValue))
{
nlassert(_MaterialBase);
uint32 id= _Texture.Value;
if(_MaterialBase->validAnimatedTexture(id))
{
_Material->setTexture(0, _MaterialBase->getAnimatedTexture(id) );
}
clearFlag(TextureValue);
}
// Get texture matrix from animated value to setup the material
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
if (_Material->isUserTexMatEnabled(k))
{
const CTexAnimatedMatValues &texMatAV = _TexAnimatedMatValues[k];
CMatrix convMat; // exported v are already inverted (todo : optim this if needed, this matrix shouldn't be necessary)
convMat.setRot(CVector::I, -CVector::J, CVector::K);
convMat.setPos(CVector::J);
float fCos = cosf(texMatAV._WRot.Value);
float fSin = sinf(texMatAV._WRot.Value);
CMatrix SR;
SR.setRot(CVector(texMatAV._UScale.Value * fCos, texMatAV._VScale.Value * fSin, 0.f),
CVector(- texMatAV._UScale.Value * fSin, texMatAV._VScale.Value * fCos, 0.f),
CVector::K);
CVector half(0.5f, 0.5f, 0.f);
SR.setPos(SR.mulVector(- half - CVector(texMatAV._UTrans.Value, texMatAV._VTrans.Value, 0.f)) + half);
_Material->setUserTexMat(k, convMat * SR * convMat);
}
}
// We are OK!
IAnimatable::clearFlag(OwnerBit);
}
}
// ***************************************************************************
IAnimatedValue* CAnimatedMaterial::getValue (uint valueId)
{
switch(valueId)
{
case AmbientValue: return &_Ambient;
case DiffuseValue: return &_Diffuse;
case SpecularValue: return &_Specular;
case ShininessValue: return &_Shininess;
case EmissiveValue: return &_Emissive;
case OpacityValue: return &_Opacity;
case TextureValue: return &_Texture;
default: // this may be a texture animated value...
if (valueId >= TextureMatValues && valueId < AnimValueLast)
{
const uint baseId = valueId - TextureMatValues;
const uint texNum = baseId / NumTexAnimatedValues; // stage index
const uint argID = baseId % NumTexAnimatedValues; // value for this stage
switch(argID)
{
case 0: return &_TexAnimatedMatValues[texNum]._UTrans;
case 1: return &_TexAnimatedMatValues[texNum]._VTrans;
case 2: return &_TexAnimatedMatValues[texNum]._UScale;
case 3: return &_TexAnimatedMatValues[texNum]._VScale;
case 4: return &_TexAnimatedMatValues[texNum]._WRot;
}
}
break;
};
// shoudl not be here!!
nlstop;
return NULL;
}
// ***************************************************************************
const char *CAnimatedMaterial::getValueName (uint valueId) const
{
switch(valueId)
{
case AmbientValue: return getAmbientValueName();
case DiffuseValue: return getDiffuseValueName();
case SpecularValue: return getSpecularValueName();
case ShininessValue: return getShininessValueName();
case EmissiveValue: return getEmissiveValueName();
case OpacityValue: return getOpacityValueName();
case TextureValue: return getTextureValueName();
default: // this may be a texture animated value...
if (valueId >= TextureMatValues && valueId < AnimValueLast)
{
const uint baseId = valueId - TextureMatValues;
const uint texNum = baseId / NumTexAnimatedValues;
const uint argID = baseId % NumTexAnimatedValues;
switch(argID)
{
case 0: return getTexMatUTransName (texNum);
case 1: return getTexMatVTransName(texNum);
case 2: return getTexMatUScaleName(texNum);
case 3: return getTexMatVScaleName(texNum);
case 4: return getTexMatWRotName(texNum);
}
}
break;
};
// shoudl not be here!!
nlstop;
return "";
}
// ***************************************************************************
ITrack* CAnimatedMaterial::getDefaultTrack (uint valueId)
{
nlassert(_MaterialBase);
switch(valueId)
{
case AmbientValue: return &_MaterialBase->DefaultAmbient;
case DiffuseValue: return &_MaterialBase->DefaultDiffuse;
case SpecularValue: return &_MaterialBase->DefaultSpecular;
case ShininessValue: return &_MaterialBase->DefaultShininess;
case EmissiveValue: return &_MaterialBase->DefaultEmissive;
case OpacityValue: return &_MaterialBase->DefaultOpacity;
case TextureValue: return &_MaterialBase->DefaultTexture;
default: // this may be a texture animated value...
if (valueId >= TextureMatValues && valueId < AnimValueLast)
{
const uint baseId = valueId - TextureMatValues;
const uint texNum = baseId / NumTexAnimatedValues;
const uint argID = baseId % NumTexAnimatedValues;
switch(argID)
{
case 0: return &_MaterialBase->DefaultTexAnimTracks[texNum].DefaultUTrans;
case 1: return &_MaterialBase->DefaultTexAnimTracks[texNum].DefaultVTrans;
case 2: return &_MaterialBase->DefaultTexAnimTracks[texNum].DefaultUTrans;
case 3: return &_MaterialBase->DefaultTexAnimTracks[texNum].DefaultVTrans;
case 4: return &_MaterialBase->DefaultTexAnimTracks[texNum].DefaultWRot;
}
}
break;
};
// shoudl not be here!!
nlstop;
return NULL;
}
// ***************************************************************************
void CAnimatedMaterial::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
{
// For CAnimatedMaterial, channels are detailled (material rendered after clip)!
addValue(chanMixer, AmbientValue, OwnerBit, prefix, true);
addValue(chanMixer, DiffuseValue, OwnerBit, prefix, true);
addValue(chanMixer, SpecularValue, OwnerBit, prefix, true);
addValue(chanMixer, ShininessValue, OwnerBit, prefix, true);
addValue(chanMixer, EmissiveValue, OwnerBit, prefix, true);
addValue(chanMixer, OpacityValue, OwnerBit, prefix, true);
addValue(chanMixer, TextureValue, OwnerBit, prefix, true);
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
for (uint l = 0; l < NumTexAnimatedValues; ++l)
{
addValue(chanMixer, TextureMatValues + l + k * NumTexAnimatedValues, OwnerBit, prefix, true);
}
}
}
// ***************************************************************************
const char *CAnimatedMaterial::getTexMatUTransName(uint stage)
{
static char names[IDRV_MAT_MAXTEXTURES][16];
static bool init = false;
nlassert(stage < IDRV_MAT_MAXTEXTURES);
if (!init) // where name initialized ?
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
sprintf(&names[k][0], "UTrans%d", k);
}
init = true;
}
return names[stage];
}
// ***************************************************************************
const char *CAnimatedMaterial::getTexMatVTransName(uint stage)
{
nlassert(stage < IDRV_MAT_MAXTEXTURES);
static char names[IDRV_MAT_MAXTEXTURES][16];
static bool init = false;
nlassert(stage < IDRV_MAT_MAXTEXTURES);
if (!init) // where name initialized ?
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
sprintf(&names[k][0], "VTrans%d", k);
}
init = true;
}
return names[stage];
}
// ***************************************************************************
const char *CAnimatedMaterial::getTexMatUScaleName(uint stage)
{
static char names[IDRV_MAT_MAXTEXTURES][16];
static bool init = false;
nlassert(stage < IDRV_MAT_MAXTEXTURES);
if (!init) // where name initialized ?
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
sprintf(&names[k][0], "UScale%d", k);
}
init = true;
}
return names[stage];
}
// ***************************************************************************
const char *CAnimatedMaterial::getTexMatVScaleName(uint stage)
{
nlassert(stage < IDRV_MAT_MAXTEXTURES);
static char names[IDRV_MAT_MAXTEXTURES][16];
static bool init = false;
nlassert(stage < IDRV_MAT_MAXTEXTURES);
if (!init) // where name initialized ?
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
sprintf(&names[k][0], "VScale%d", k);
}
init = true;
}
return names[stage];
}
// ***************************************************************************
const char *CAnimatedMaterial::getTexMatWRotName(uint stage)
{
nlassert(stage < IDRV_MAT_MAXTEXTURES);
static char names[IDRV_MAT_MAXTEXTURES][16];
static bool init = false;
nlassert(stage < IDRV_MAT_MAXTEXTURES);
if (!init) // where name initialized ?
{
for (uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
{
sprintf(&names[k][0], "WRot%d", k);
}
init = true;
}
return names[stage];
}
} // NL3D