Show material.cpp syntax highlighted
/***************************************************************************
material.cpp - description
-------------------
begin : Wed Oct 31 2001
copyright : (C) 2001 by Reality Rift Studios
email : mattias@realityrift.com
***************************************************************************
The contents of this file are subject to the Mozilla Public License Version
1.1 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
for the specific language governing rights and limitations under the
License.
The Original Code is the NeoEngine, material.h
The Initial Developer of the Original Code is Mattias Jansson.
Portions created by Mattias Jansson are Copyright (C) 2001
Reality Rift Studios. All Rights Reserved.
***************************************************************************/
#include "material.h"
#include "texture.h"
#include "render.h"
#include "nemath.h"
#include "timer.h"
#include "logstream.h"
#include "strutil.h"
using namespace std;
namespace NeoEngine
{
void FogMode::SetDepth( float fStart, float fEnd )
{
m_fStart = fStart;
m_fEnd = fEnd;
}
TextureLayer::TextureLayer( const TextureLayer &rkLayer ) :
m_kBlendMode( rkLayer.m_kBlendMode ),
m_pkTexture( rkLayer.m_pkTexture ),
m_uiUVLayer( rkLayer.m_uiUVLayer ),
m_uiUVAddress( rkLayer.m_uiUVAddress ),
m_vpkTexMatrixGen( rkLayer.m_vpkTexMatrixGen.size() ),
m_uiLayerFlags( rkLayer.m_uiLayerFlags ),
m_eTexCoordGen( rkLayer.m_eTexCoordGen )
{
vector< TextureMatrixGen* >::const_iterator ppkGen = rkLayer.m_vpkTexMatrixGen.begin();
vector< TextureMatrixGen* >::const_iterator ppkGenEnd = rkLayer.m_vpkTexMatrixGen.end();
vector< TextureMatrixGen* >::iterator ppkDst = m_vpkTexMatrixGen.begin();
for( ; ppkGen != ppkGenEnd; ++ppkGen, ++ppkDst )
*ppkDst = (*ppkGen)->Duplicate();
}
TextureLayer::~TextureLayer()
{
vector<TextureMatrixGen*>::iterator ppkGen = m_vpkTexMatrixGen.begin();
vector<TextureMatrixGen*>::iterator ppkEnd = m_vpkTexMatrixGen.end();
for( ; ppkGen < ppkEnd; ++ppkGen )
delete (*ppkGen);
}
TextureLayer &TextureLayer::operator =( const TextureLayer &rkLayer )
{
m_kBlendMode = rkLayer.m_kBlendMode;
m_pkTexture = rkLayer.m_pkTexture;
m_uiUVLayer = rkLayer.m_uiUVLayer;
m_uiUVAddress = rkLayer.m_uiUVAddress;
m_uiLayerFlags = rkLayer.m_uiLayerFlags;
m_eTexCoordGen = rkLayer.m_eTexCoordGen;
vector<TextureMatrixGen*>::iterator ppkGen = m_vpkTexMatrixGen.begin();
vector<TextureMatrixGen*>::iterator ppkEnd = m_vpkTexMatrixGen.end();
for( ; ppkGen < ppkEnd; ++ppkGen )
delete (*ppkGen);
vector<TextureMatrixGen*>::const_iterator ppkSrcGen = rkLayer.m_vpkTexMatrixGen.begin();
vector<TextureMatrixGen*>::const_iterator ppkSrcEnd = rkLayer.m_vpkTexMatrixGen.end();
m_vpkTexMatrixGen.resize( rkLayer.m_vpkTexMatrixGen.size() );
ppkGen = m_vpkTexMatrixGen.begin();
for( ; ppkSrcGen < ppkSrcEnd; ++ppkGen, ++ppkSrcGen )
(*ppkGen) = (*ppkSrcGen)->Duplicate();
return( *this );
}
MaterialPass::MaterialPass() :
TextureLayer(),
m_kAmbient( 0.2f, 0.2f, 0.2f, 1.0f ),
m_kDiffuse( 0.8f, 0.8f, 0.8f, 1.0f ),
m_kSpecular( 0.0f, 0.0f, 0.0f, 1.0f ),
m_kEmission( 0.0f, 0.0f, 0.0f, 1.0f ),
m_fShininess( 0.0f ),
m_pkProgramShader( 0 ),
m_uiMaxLights( 1 )
{
}
MaterialPass::MaterialPass( const MaterialPass &rkPass ) :
TextureLayer( rkPass ),
m_kAmbient( rkPass.m_kAmbient ),
m_kDiffuse( rkPass.m_kDiffuse ),
m_kSpecular( rkPass.m_kSpecular ),
m_kEmission( rkPass.m_kEmission ),
m_fShininess( rkPass.m_fShininess ),
m_kZBufferMode( rkPass.m_kZBufferMode ),
m_pkProgramShader( rkPass.m_pkProgramShader ),
m_uiMaxLights( rkPass.m_uiMaxLights )
{
m_vpkTextureLayers.resize( rkPass.m_vpkTextureLayers.size() );
vector< TextureLayer* >::const_iterator ppkLayer = rkPass.m_vpkTextureLayers.begin();
vector< TextureLayer* >::const_iterator ppkLayerEnd = rkPass.m_vpkTextureLayers.end();
vector< TextureLayer* >::iterator ppkDstLayer = m_vpkTextureLayers.begin();
for( ; ppkLayer != ppkLayerEnd; ++ppkLayer, ++ppkDstLayer )
*ppkDstLayer = new TextureLayer( *(*ppkLayer) );
}
MaterialPass::~MaterialPass()
{
vector< TextureLayer* >::iterator ppkLayer = m_vpkTextureLayers.begin();
vector< TextureLayer* >::iterator ppkLayerEnd = m_vpkTextureLayers.end();
for( ; ppkLayer != ppkLayerEnd; ++ppkLayer )
delete( *ppkLayer );
m_pkProgramShader = 0;
}
MaterialPass &MaterialPass::operator =( const MaterialPass &rkPass )
{
m_kAmbient = rkPass.m_kAmbient;
m_kDiffuse = rkPass.m_kDiffuse;
m_kSpecular = rkPass.m_kSpecular;
m_kEmission = rkPass.m_kEmission;
m_fShininess = rkPass.m_fShininess;
m_kZBufferMode = rkPass.m_kZBufferMode;
m_pkProgramShader = rkPass.m_pkProgramShader;
m_uiMaxLights = rkPass.m_uiMaxLights;
*(TextureLayer*)this = *(TextureLayer*)&rkPass;
if( m_vpkTextureLayers.size() <= rkPass.m_vpkTextureLayers.size() )
{
vector< TextureLayer* >::const_iterator ppkLayer = rkPass.m_vpkTextureLayers.begin();
vector< TextureLayer* >::const_iterator ppkLayerEnd = rkPass.m_vpkTextureLayers.end();
vector< TextureLayer* >::iterator ppkDstLayer = m_vpkTextureLayers.begin();
vector< TextureLayer* >::iterator ppkDstLayerEnd = m_vpkTextureLayers.begin();
for( ; ppkDstLayer != ppkDstLayerEnd; ++ppkDstLayer, ++ppkLayer )
*(*ppkDstLayer) = *(*ppkLayer);
for( ; ppkLayer != ppkLayerEnd; ++ppkLayer )
m_vpkTextureLayers.push_back( new TextureLayer( *(*ppkLayer) ) );
}
else
{
vector< TextureLayer* >::const_iterator ppkLayer = rkPass.m_vpkTextureLayers.begin();
vector< TextureLayer* >::const_iterator ppkLayerEnd = rkPass.m_vpkTextureLayers.end();
vector< TextureLayer* >::iterator ppkDstLayer = m_vpkTextureLayers.begin();
vector< TextureLayer* >::iterator ppkDstLayerEnd = m_vpkTextureLayers.begin();
for( ; ppkLayer != ppkLayerEnd; ++ppkDstLayer, ++ppkLayer )
*(*ppkDstLayer) = *(*ppkLayer);
vector< TextureLayer* >::iterator ppkErase = ppkDstLayer;
for( ; ppkDstLayer != ppkDstLayerEnd; ++ppkDstLayer )
delete( *ppkDstLayer );
m_vpkTextureLayers.erase( ppkErase, ppkDstLayerEnd );
}
return( *this );
}
bool MaterialPass::HasAlpha() const
{
if ( TextureLayer::HasAlpha() )
return true;
vector< TextureLayer* >::const_iterator ppkLayer = m_vpkTextureLayers.begin();
vector< TextureLayer* >::const_iterator ppkLayerEnd = m_vpkTextureLayers.end();
for( ; ppkLayer != ppkLayerEnd; ++ppkLayer )
{
if ( ( *ppkLayer )->HasAlpha() )
return true;
}
return false;
}
Material::Material( const HashString &rstrName, MaterialTable *pkTable ) :
RefCounter(),
MaterialPass(),
m_pkTable( pkTable ),
m_strName( rstrName ),
m_bCastShadows( false ),
m_bNoLighting( false )
{
if( m_pkTable )
m_pkTable->Insert( m_strName, this );
}
Material::Material( const Material &rkMaterial ) :
RefCounter(),
MaterialPass( rkMaterial ),
m_pkTable( 0 ),
m_bCastShadows( rkMaterial.m_bCastShadows ),
m_bNoLighting( rkMaterial.m_bNoLighting )
{
m_vpkPasses.resize( rkMaterial.m_vpkPasses.size() );
vector< MaterialPass* >::const_iterator ppkPass = rkMaterial.m_vpkPasses.begin();
vector< MaterialPass* >::const_iterator ppkPassEnd = rkMaterial.m_vpkPasses.end();
vector< MaterialPass* >::iterator ppkDstPass = m_vpkPasses.begin();
for( ; ppkPass != ppkPassEnd; ++ppkPass, ++ppkDstPass )
*ppkDstPass = new MaterialPass( *(*ppkPass) );
}
Material::~Material()
{
vector< MaterialPass* >::iterator ppkPass = m_vpkPasses.begin();
vector< MaterialPass* >::iterator ppkPassEnd = m_vpkPasses.end();
for( ; ppkPass != ppkPassEnd; ++ppkPass )
delete *ppkPass;
if( m_pkTable )
m_pkTable->Delete( m_strName, this );
}
Material &Material::operator = ( const Material &rkMaterial )
{
*(MaterialPass*)this = *(MaterialPass*)&rkMaterial;
if( m_vpkPasses.size() <= rkMaterial.m_vpkPasses.size() )
{
vector< MaterialPass* >::const_iterator ppkPass = rkMaterial.m_vpkPasses.begin();
vector< MaterialPass* >::const_iterator ppkPassEnd = rkMaterial.m_vpkPasses.end();
vector< MaterialPass* >::iterator ppkDstPass = m_vpkPasses.begin();
vector< MaterialPass* >::iterator ppkDstPassEnd = m_vpkPasses.begin();
for( ; ppkDstPass != ppkDstPassEnd; ++ppkDstPass, ++ppkPass )
*(*ppkDstPass) = *(*ppkPass);
for( ; ppkPass != ppkPassEnd; ++ppkPass )
m_vpkPasses.push_back( new MaterialPass( *(*ppkPass) ) );
}
else
{
vector< MaterialPass* >::const_iterator ppkPass = rkMaterial.m_vpkPasses.begin();
vector< MaterialPass* >::const_iterator ppkPassEnd = rkMaterial.m_vpkPasses.end();
vector< MaterialPass* >::iterator ppkDstPass = m_vpkPasses.begin();
vector< MaterialPass* >::iterator ppkDstPassEnd = m_vpkPasses.begin();
for( ; ppkPass != ppkPassEnd; ++ppkDstPass, ++ppkPass )
*(*ppkDstPass) = *(*ppkPass);
vector< MaterialPass* >::iterator ppkErase = ppkDstPass;
for( ; ppkDstPass != ppkDstPassEnd; ++ppkDstPass )
delete( *ppkDstPass );
m_vpkPasses.erase( ppkErase, ppkDstPassEnd );
}
return( *this );
}
void Material::SetName( const HashString &rstrName )
{
if( m_pkTable )
{
m_pkTable->Delete( m_strName, this );
m_pkTable->Insert( rstrName, this );
}
m_strName = rstrName;
}
void Material::SetTable( MaterialTable *pkTable )
{
if( m_pkTable == pkTable )
return;
if( m_pkTable )
m_pkTable->Delete( m_strName, this );
if( ( m_pkTable = pkTable ) )
m_pkTable->Insert( m_strName, this );
}
bool Material::HasAlpha() const
{
if ( MaterialPass::HasAlpha() )
return true;
vector< MaterialPass* >::const_iterator ppkPass = m_vpkPasses.begin();
vector< MaterialPass* >::const_iterator ppkPassEnd = m_vpkPasses.end();
for( ; ppkPass != ppkPassEnd; ++ppkPass )
{
if ( ( *ppkPass )->HasAlpha() )
return true;
}
return false;
}
string BlendMode::GetSrcModeAsString( unsigned int uiMode )
{
switch( uiMode & SRCBITS )
{
case SRC_ONE:
return "one";
case SRC_ZERO:
return "zero";
case SRC_SRCALPHA:
return "srcalpha";
case SRC_ONEMINUSSRCALPHA:
return "oneminussrcalpha";
case SRC_DESTCOLOR:
return "destcolor";
case SRC_ONEMINUSDESTCOLOR:
return "oneminusdestcolor";
case SRC_FACTOR:
return "factor";
case SRC_SRCCOLOR:
return "srccolor";
case SRC_DESTALPHA:
return "destalpha";
case SRC_ONEMINUSDESTALPHA:
return "oneminusdestalpha";
case SRC_ALPHASATURATE:
return "alphasaturate";
case SRC_LERPCOLOR:
return "lerpcolor";
case SRC_LERPALPHA:
return "lerpalpha";
default:
break;
}
return "one";
}
string BlendMode::GetDestModeAsString( unsigned int uiMode )
{
switch( uiMode & DESTBITS )
{
case DEST_ZERO:
return "zero";
case DEST_SRCALPHA:
return "srcalpha";
case DEST_ONEMINUSSRCALPHA:
return "oneminussrcalpha";
case DEST_SRCCOLOR:
return "srccolor";
case DEST_ONEMINUSSRCCOLOR:
return "oneminussrccolor";
case DEST_ONEMINUSFACTOR:
return "oneminusfactor";
case DEST_DESTALPHA:
return "destalpha";
case DEST_ONEMINUSDESTALPHA:
return "oneminusdestalpha";
case DEST_ONE:
return "one";
case DEST_LERPCOLOR:
return "lerpcolor";
case DEST_LERPALPHA:
return "lerpalpha";
default:
break;
}
return "zero";
}
unsigned int BlendMode::GetSrcModeFromString( const std::string &rstrMode )
{
if( rstrMode == "one" )
return BlendMode::SRC_ONE;
else if( rstrMode == "zero" )
return BlendMode::SRC_ZERO;
else if( rstrMode == "srcalpha" )
return BlendMode::SRC_SRCALPHA;
else if( rstrMode == "oneminussrcalpha" )
return BlendMode::SRC_ONEMINUSSRCALPHA;
else if( rstrMode =="destcolor" )
return BlendMode::SRC_DESTCOLOR;
else if( rstrMode == "oneminusdestcolor" )
return BlendMode::SRC_ONEMINUSDESTCOLOR;
else if( rstrMode == "factor" )
return BlendMode::SRC_FACTOR;
else if( rstrMode == "srccolor" )
return BlendMode::SRC_SRCCOLOR;
else if( rstrMode == "destalpha" )
return BlendMode::SRC_DESTALPHA;
else if( rstrMode == "oneminusdestalpha" )
return BlendMode::SRC_ONEMINUSDESTALPHA;
else if( rstrMode == "alphasaturate" )
return BlendMode::SRC_ALPHASATURATE;
else if( rstrMode == "lerpcolor" )
return BlendMode::SRC_LERPCOLOR;
else if( rstrMode == "lerpalpha" )
return BlendMode::SRC_LERPALPHA;
else
{
neolog << LogLevel( WARNING ) << "[BlendMode::GetSrcModeFromString]: Unknown src blend mode name [" << rstrMode << "]" << endl;
return BlendMode::SRC_ONE;
}
}
unsigned int BlendMode::GetDestModeFromString( const std::string &rstrMode )
{
if( rstrMode == "zero" )
return BlendMode::DEST_ZERO;
else if( rstrMode == "srcalpha" )
return BlendMode::DEST_SRCALPHA;
else if( rstrMode == "oneminussrcalpha" )
return BlendMode::DEST_ONEMINUSSRCALPHA;
else if( rstrMode == "srccolor" )
return BlendMode::DEST_SRCCOLOR;
else if( rstrMode == "oneminussrccolor" )
return BlendMode::DEST_ONEMINUSSRCCOLOR;
else if( rstrMode == "oneminusfactor" )
return BlendMode::DEST_ONEMINUSFACTOR;
else if( rstrMode == "one" )
return BlendMode::DEST_ONE;
else if( rstrMode == "destalpha" )
return BlendMode::DEST_DESTALPHA;
else if( rstrMode == "oneminusdestalpha" )
return BlendMode::DEST_ONEMINUSDESTALPHA;
else if( rstrMode == "lerpcolor" )
return BlendMode::DEST_LERPCOLOR;
else if( rstrMode == "lerpalpha" )
return BlendMode::DEST_LERPALPHA;
else
{
neolog << LogLevel( WARNING ) << "[BlendMode::GetDestModeFromString]: Unknown dest blend mode name [" << rstrMode << "]" << endl;
return BlendMode::DEST_ZERO;
}
}
string ZBufferMode::GetTestFuncAsString( unsigned int uiMode )
{
switch( uiMode & FUNCBITS )
{
case LESS:
return "less";
case LEQUAL:
return "lequal";
case EQUAL:
return "equal";
case GEQUAL:
return "gequal";
case GREATER:
return "greater";
case ALWAYSPASS:
return "always";
default:
break;
}
return "UNKNOWN";
}
string ZBufferMode::GetWriteModeAsString( unsigned int uiMode )
{
switch( uiMode & MODEBITS )
{
case ENABLED:
return "enabled";
case DISABLED:
return "disabled";
default:
break;
}
return "enabled";
}
unsigned int ZBufferMode::GetWriteModeFromString( const std::string &rstrMode )
{
if( rstrMode == "enabled" )
return ZBufferMode::ENABLED;
else if( rstrMode == "disabled" )
return ZBufferMode::DISABLED;
else
{
neolog << LogLevel( WARNING ) << "[ZBufferMode::GetWriteModeFromString]: Unknown Z-buffer write mode name [" << rstrMode << "]" << endl;
return ZBufferMode::ENABLED;
}
}
unsigned int ZBufferMode::GetTestFuncFromString( const std::string &rstrFunc )
{
if( rstrFunc == "less" )
return ZBufferMode::LESS;
if( rstrFunc == "lequal" )
return ZBufferMode::LEQUAL;
else if( rstrFunc == "equal" )
return ZBufferMode::EQUAL;
else if( rstrFunc == "gequal" )
return ZBufferMode::GEQUAL;
else if( rstrFunc == "greater" )
return ZBufferMode::GREATER;
else if( rstrFunc == "always" )
return ZBufferMode::ALWAYSPASS;
else
{
neolog << LogLevel( WARNING ) << "[ZBufferMode::GetTestFuncFromString]: Unknown Z-buffer test mode name [" << rstrFunc << "]" << endl;
return ZBufferMode::LEQUAL;
}
}
unsigned int TextureLayer::GetFlagsFromString( const string &rstrIdentifier )
{
unsigned int uiFlags = NOFLAGS;
vector< string > vstrFlags;
Explode( " \t", rstrIdentifier, &vstrFlags );
for( unsigned int uiFlag = 0; uiFlag < vstrFlags.size(); ++uiFlag )
{
if( vstrFlags[ uiFlag ] == "multipass" )
uiFlags |= MULTIPASS;
}
return uiFlags;
}
std::string TextureLayer::GetFlagsAsString( unsigned int uiFlags )
{
string strFlags;
if( uiFlags & MULTIPASS )
strFlags += " multipass";
return Strip( strFlags, " " );
}
unsigned int TextureLayer::GetAddressFromString( const string &rstrIdentifier )
{
unsigned int uiAddress = 0;
vector< string > vstrAddr;
Explode( " \t", rstrIdentifier, &vstrAddr );
for( unsigned int uiFlag = 0; uiFlag < vstrAddr.size(); ++uiFlag )
{
if( vstrAddr[ uiFlag ] == "wrap" )
uiAddress = WRAP;
else if( vstrAddr[ uiFlag ] == "clamp" )
uiAddress = CLAMP;
else if( vstrAddr[ uiFlag ] == "wrapu" )
uiAddress &= 0x11111110;
else if( vstrAddr[ uiFlag ] == "wrapv" )
uiAddress &= 0x11111101;
else if( vstrAddr[ uiFlag ] == "wrapw" )
uiAddress &= 0x11111011;
else if( vstrAddr[ uiFlag ] == "clampu" )
uiAddress |= CLAMP_U;
else if( vstrAddr[ uiFlag ] == "clampv" )
uiAddress |= CLAMP_V;
else if( vstrAddr[ uiFlag ] == "clampw" )
uiAddress |= CLAMP_W;
}
return uiAddress;
}
std::string TextureLayer::GetAddressAsString( unsigned int uiAddress )
{
string strFlags;
if( uiAddress == WRAP )
return "wrap";
else if( uiAddress == CLAMP )
return "clamp";
strFlags += ( uiAddress & CLAMP_U ) ? "clampu" : "wrapu";
strFlags += ( uiAddress & CLAMP_V ) ? " clampv" : " wrapv";
strFlags += ( uiAddress & CLAMP_W ) ? " clampw" : " wrapw";
return strFlags;
}
unsigned int TextureLayer::GetTexCoordGenFromString( const string &rstrIdentifier )
{
if( rstrIdentifier == "reflection" )
return REFLECTION;
else if( rstrIdentifier == "normal" )
return NORMAL;
return NOGEN;
}
std::string TextureLayer::GetTexCoordGenAsString( unsigned int uiTexCoordGen )
{
if( uiTexCoordGen == REFLECTION )
return "reflection";
else if( uiTexCoordGen == NORMAL )
return "normal";
return "nogen";
}
}; // namespace NeoEngine
See more files for this project here