// 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/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 = (uint32)_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;
}

}