assimp/code/TextureTransform.cpp

/*
Open Asset Import Library (ASSIMP)
----------------------------------------------------------------------

Copyright (c) 2006-2008, ASSIMP Development Team
All rights reserved.

Redistribution and use of this software in source and binary forms, 
with or without modification, are permitted provided that the 
following conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the ASSIMP team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the ASSIMP Development Team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

----------------------------------------------------------------------
*/

/** @file A helper class that processes texture transformations */


#include "AssimpPCH.h"
#include "TextureTransform.h"

namespace Assimp
{

// ------------------------------------------------------------------------------------------------
void TextureTransform::PreProcessUVTransform(
	D3DS::Texture& rcIn)
{
	char szTemp[512];
	int iField;

	if (rcIn.mOffsetU)
	{
		if ((iField = (int)rcIn.mOffsetU))
		{
			if (aiTextureMapMode_Wrap == rcIn.mMapMode)
			{
				float fNew = rcIn.mOffsetU-(float)iField;
				sprintf(szTemp,"[wrap] Found texture coordinate U offset %f. "
					"This can be optimized to %f",rcIn.mOffsetU,fNew);
	
				DefaultLogger::get()->info(szTemp);
				rcIn.mOffsetU = fNew;
			}
			else if (aiTextureMapMode_Mirror == rcIn.mMapMode)
			{
				if (0 != (iField % 2))iField--;
				float fNew = rcIn.mOffsetU-(float)iField;

				sprintf(szTemp,"[mirror] Found texture coordinate U offset %f. "
					"This can be optimized to %f",rcIn.mOffsetU,fNew);

				DefaultLogger::get()->info(szTemp);
				rcIn.mOffsetU = fNew;
			}
			else if (aiTextureMapMode_Clamp == rcIn.mMapMode)
			{
				sprintf(szTemp,"[clamp] Found texture coordinate U offset %f. "
					"This can be clamped to 1.0f",rcIn.mOffsetU);

				DefaultLogger::get()->info(szTemp);
				rcIn.mOffsetU = 1.0f;
			}
		}
	}
	if (rcIn.mOffsetV)
	{
		if ((iField = (int)rcIn.mOffsetV))
		{
			if (aiTextureMapMode_Wrap == rcIn.mMapMode)
			{
				float fNew = rcIn.mOffsetV-(float)iField;
				sprintf(szTemp,"[wrap] Found texture coordinate V offset %f. "
					"This can be optimized to %f",rcIn.mOffsetV,fNew);

				DefaultLogger::get()->info(szTemp);
				rcIn.mOffsetV = fNew;
			}
			else if (aiTextureMapMode_Mirror == rcIn.mMapMode)
			{
				if (0 != (iField % 2))iField--;
				float fNew = rcIn.mOffsetV-(float)iField;

				sprintf(szTemp,"[mirror] Found texture coordinate V offset %f. "
					"This can be optimized to %f",rcIn.mOffsetV,fNew);
				
				DefaultLogger::get()->info(szTemp);
				rcIn.mOffsetV = fNew;
			}
			else if (aiTextureMapMode_Clamp == rcIn.mMapMode)
			{
				sprintf(szTemp,"[clamp] Found texture coordinate U offset %f. "
					"This can be clamped to 1.0f",rcIn.mOffsetV);

				DefaultLogger::get()->info(szTemp);
				rcIn.mOffsetV = 1.0f;
			}
		}
	}
	if (rcIn.mRotation)
	{
		if ((iField = (int)(rcIn.mRotation / 3.141592654f)))
		{
			float fNew = rcIn.mRotation-(float)iField*3.141592654f;

			sprintf(szTemp,"[wrap] Found texture coordinate rotation %f. "
				"This can be optimized to %f",rcIn.mRotation,fNew);
			DefaultLogger::get()->info(szTemp);

			rcIn.mRotation = fNew;
		}
	}
	return;
}
// ------------------------------------------------------------------------------------------------
void TextureTransform::AddToList(std::vector<STransformVecInfo>& rasVec,
	D3DS::Texture* pcTex)
{
	// check whether the texture is existing
	if (0 == pcTex->mMapName.length())return;

	// search for an identical transformation in our list
	for (std::vector<STransformVecInfo>::iterator
		i =  rasVec.begin();
		i != rasVec.end();++i)
	{
		if ((*i).fOffsetU == pcTex->mOffsetU &&
			(*i).fOffsetV == pcTex->mOffsetV && 
			(*i).fScaleU  == pcTex->mScaleU  &&
			(*i).fScaleV  == pcTex->mScaleV  &&
			(*i).fRotation == pcTex->mRotation &&
			(*i).iUVIndex == (unsigned int)pcTex->iUVSrc)
		{
			(*i).pcTextures.push_back(pcTex);
			return;
		}
	}
	// this is a new transformation, so add it to the list
	STransformVecInfo sInfo;
	sInfo.fScaleU = pcTex->mScaleU;
	sInfo.fScaleV = pcTex->mScaleV;
	sInfo.fOffsetU = pcTex->mOffsetU;
	sInfo.fOffsetV = pcTex->mOffsetV;
	sInfo.fRotation = pcTex->mRotation;
	sInfo.iUVIndex = pcTex->iUVSrc;

	// add the texture to the list
	sInfo.pcTextures.push_back(pcTex);

	// and add the transformation itself to the second list
	rasVec.push_back(sInfo);
}
// ------------------------------------------------------------------------------------------------
void TextureTransform::ApplyScaleNOffset(D3DS::Material& material)
{
	unsigned int iCnt = 0;
	D3DS::Texture* pcTexture = NULL;

	// diffuse texture
	if (material.sTexDiffuse.mMapName.length())
	{
		PreProcessUVTransform(material.sTexDiffuse);
		if (HasUVTransform(material.sTexDiffuse))
		{
			material.sTexDiffuse.bPrivate = true;
			pcTexture = &material.sTexDiffuse;
			++iCnt;
		}
	}
	// specular texture
	if (material.sTexSpecular.mMapName.length())
	{
		PreProcessUVTransform(material.sTexSpecular);
		if (HasUVTransform(material.sTexSpecular))
		{
			material.sTexSpecular.bPrivate = true;
			pcTexture = &material.sTexSpecular;
			++iCnt;
		}
	}
	// ambient texture
	if (material.sTexAmbient.mMapName.length())
	{
		PreProcessUVTransform(material.sTexAmbient);
		if (HasUVTransform(material.sTexAmbient))
		{
			material.sTexAmbient.bPrivate = true;
			pcTexture = &material.sTexAmbient;
			++iCnt;
		}
	}
	// emissive texture
	if (material.sTexEmissive.mMapName.length())
	{
		PreProcessUVTransform(material.sTexEmissive);
		if (HasUVTransform(material.sTexEmissive))
		{
			material.sTexEmissive.bPrivate = true;
			pcTexture = &material.sTexEmissive;
			++iCnt;
		}
	}
	// opacity texture
	if (material.sTexOpacity.mMapName.length())
	{
		PreProcessUVTransform(material.sTexOpacity);
		if (HasUVTransform(material.sTexOpacity))
		{
			material.sTexOpacity.bPrivate = true;
			pcTexture = &material.sTexOpacity;
			++iCnt;
		}
	}
	// bump texture
	if (material.sTexBump.mMapName.length())
	{
		PreProcessUVTransform(material.sTexBump);
		if (HasUVTransform(material.sTexBump))
		{
			material.sTexBump.bPrivate = true;
			pcTexture = &material.sTexBump;
			++iCnt;
		}
	}
	// shininess texture
	if (material.sTexShininess.mMapName.length())
	{
		PreProcessUVTransform(material.sTexShininess);
		if (HasUVTransform(material.sTexShininess))
		{
			material.sTexBump.bPrivate = true;
			pcTexture = &material.sTexShininess;
			++iCnt;
		}
	}
	if (0 != iCnt)
	{
		// if only one texture needs scaling/offset operations
		// we can apply them directly to the first texture
		// coordinate sets of all meshes referencing *this* material
		// However, we can't do it  now. We need to wait until
		// everything is sorted by materials.
		if (1 == iCnt && 0 == pcTexture->iUVSrc)
		{
			material.iBakeUVTransform = 1;
			material.pcSingleTexture = pcTexture;
		}
		// we will need to generate a separate new texture channel
		// for each texture. 
		// However, we can't do it  now. We need to wait until
		// everything is sorted by materials.
		else material.iBakeUVTransform = 2;
	}
}
// ------------------------------------------------------------------------------------------------
void TextureTransform::ApplyScaleNOffset(std::vector<D3DS::Material>& materials)
{
	unsigned int iNum = 0;
	for (std::vector<D3DS::Material>::iterator
		i =  materials.begin();
		i != materials.end();++i,++iNum)
	{
		ApplyScaleNOffset(*i);
	}
	return;
}
// ------------------------------------------------------------------------------------------------
void TextureTransform::BakeScaleNOffset(
	aiMesh* pcMesh, D3DS::Material* pcSrc)
{
	// NOTE: we don't use a texture matrix to do the transformation
	// it is more efficient this way ... 

	if (!pcMesh->mTextureCoords[0])return;
	if (0x1 == pcSrc->iBakeUVTransform)
	{
		char szTemp[512];
		int iLen;
#if _MSC_VER >= 1400
		iLen = ::sprintf_s(szTemp,
#else
		iLen = ::sprintf(szTemp,
#endif
			"Transforming existing UV channel. Source UV: %i" 
			" OffsetU: %f" 
			" OffsetV: %f" 
			" ScaleU: %f" 
			" ScaleV: %f" 
			" Rotation (rad): %f",0,
			pcSrc->pcSingleTexture->mOffsetU,
			pcSrc->pcSingleTexture->mOffsetV,
			pcSrc->pcSingleTexture->mScaleU,
			pcSrc->pcSingleTexture->mScaleV,
			pcSrc->pcSingleTexture->mRotation);

		ai_assert(0 < iLen);
		DefaultLogger::get()->info(std::string(szTemp,iLen));

		if (!pcSrc->pcSingleTexture->mRotation)
		{
			for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
			{
				// scaling
				pcMesh->mTextureCoords[0][i].x *= pcSrc->pcSingleTexture->mScaleU;
				pcMesh->mTextureCoords[0][i].y *= pcSrc->pcSingleTexture->mScaleV;

				// offset
				pcMesh->mTextureCoords[0][i].x += pcSrc->pcSingleTexture->mOffsetU;
				pcMesh->mTextureCoords[0][i].y += pcSrc->pcSingleTexture->mOffsetV;
			}
		}
		else
		{
			const float fSin = sinf(pcSrc->pcSingleTexture->mRotation);
			const float fCos = cosf(pcSrc->pcSingleTexture->mRotation);
			for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
			{
				// scaling
				pcMesh->mTextureCoords[0][i].x *= pcSrc->pcSingleTexture->mScaleU;
				pcMesh->mTextureCoords[0][i].y *= pcSrc->pcSingleTexture->mScaleV;

				// rotation
				pcMesh->mTextureCoords[0][i].x *= fCos;
				pcMesh->mTextureCoords[0][i].y *= fSin;

				// offset
				pcMesh->mTextureCoords[0][i].x += pcSrc->pcSingleTexture->mOffsetU;
				pcMesh->mTextureCoords[0][i].y += pcSrc->pcSingleTexture->mOffsetV;
			}
		}
	}
	else if (0x2 == pcSrc->iBakeUVTransform)
	{
		// first save all texture coordinate sets
		aiVector3D* apvOriginalSets[AI_MAX_NUMBER_OF_TEXTURECOORDS];
		for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
		{
			apvOriginalSets[i] = pcMesh->mTextureCoords[i];
		}
		unsigned int iNextEmpty = 0;
		while (pcMesh->mTextureCoords[++iNextEmpty]);

		aiVector3D* apvOutputSets[AI_MAX_NUMBER_OF_TEXTURECOORDS];
		for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
			apvOutputSets[i] = NULL;

		// now we need to find all textures in the material
		// which require scaling/offset operations
		std::vector<STransformVecInfo> sOps;
		sOps.reserve(10);
		TextureTransform::AddToList(sOps,&pcSrc->sTexDiffuse);
		TextureTransform::AddToList(sOps,&pcSrc->sTexSpecular);
		TextureTransform::AddToList(sOps,&pcSrc->sTexEmissive);
		TextureTransform::AddToList(sOps,&pcSrc->sTexOpacity);
		TextureTransform::AddToList(sOps,&pcSrc->sTexBump);
		TextureTransform::AddToList(sOps,&pcSrc->sTexShininess);
		TextureTransform::AddToList(sOps,&pcSrc->sTexAmbient);

		// check the list and find out how many we won't be able
		// to generate.
		std::vector<STransformVecInfo*> sFilteredOps;
		unsigned int iNumUntransformed = 0;
		sFilteredOps.reserve(sOps.size());
		{
			std::vector<STransformVecInfo*> sWishList;
			sWishList.reserve(sOps.size());
			for (unsigned int iUV = 0; iUV < AI_MAX_NUMBER_OF_TEXTURECOORDS;++iUV)
			{
				for (std::vector<STransformVecInfo>::iterator
					i =  sOps.begin();
					i != sOps.end();++i)
				{
					if (iUV != (*i).iUVIndex)continue;
					if ((*i).IsUntransformed())
					{
						sFilteredOps.push_back(&(*i));
					}
					else sWishList.push_back(&(*i));
				}
			}
			// are we able to generate all?
			const int iDiff = AI_MAX_NUMBER_OF_TEXTURECOORDS-(int)
				(sWishList.size()+sFilteredOps.size());

			iNumUntransformed  = (unsigned int)sFilteredOps.size();
			if (0 >= iDiff)
			{
				DefaultLogger::get()->warn("There are too many combinations of different "
					"UV transformation operations to generate an own UV channel for each "
					"(maximum is AI_MAX_NUMBER_OF_TEXTURECOORDS = 4 or 6). "
					"An untransformed UV channel will be used for all remaining transformations");
				
				std::vector<STransformVecInfo*>::const_iterator nash =  sWishList.begin();
				for (;nash != sWishList.end()-iDiff;++nash)
				{
					sFilteredOps.push_back(*nash);
				}
			}
			else
			{
				for (std::vector<STransformVecInfo*>::const_iterator
					nash =  sWishList.begin();
					nash != sWishList.end();++nash)sFilteredOps.push_back(*nash);
			}
		}

		// now fill in all output IV indices
		unsigned int iNum = 0;
		for (std::vector<STransformVecInfo*>::iterator
			bogart =  sFilteredOps.begin();
			bogart != sFilteredOps.end();++bogart,++iNum)
		{
			(**bogart).iUVIndex = iNum;
		}

		iNum = 0;
		for (; iNum < iNumUntransformed; ++iNum)
			pcMesh->mTextureCoords[iNum] = apvOriginalSets[iNum];

		// now generate the texture coordinate sets
		for (std::vector<STransformVecInfo*>::iterator
			i =  sFilteredOps.begin()+iNumUntransformed;
			i != sFilteredOps.end();++i,++iNum)
		{
			const aiVector3D* _pvBase = apvOriginalSets[(**i).iUVIndex];
			aiVector3D* _pvOut = new aiVector3D[pcMesh->mNumVertices];
			pcMesh->mTextureCoords[iNum] = _pvOut;

			char szTemp[512];
			int iLen;
#if _MSC_VER >= 1400
			iLen = ::sprintf_s(szTemp,
#else
			iLen = ::sprintf(szTemp,
#endif
				"Generating additional UV channel. Source UV: %i" 
				" OffsetU: %f" 
				" OffsetV: %f" 
				" ScaleU: %f" 
				" ScaleV: %f" 
				" Rotation (rad): %f",0,
				(**i).fOffsetU,
				(**i).fOffsetV,
				(**i).fScaleU,
				(**i).fScaleV,
				(**i).fRotation);
			ai_assert(0 < iLen);
			DefaultLogger::get()->info(std::string(szTemp,iLen));

			const aiVector3D* pvBase = _pvBase;
			aiVector3D* pvOut = _pvOut;
			if (0.0f == (**i).fRotation)
			{
				for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)
				{
					// scaling
					pvOut->x = pvBase->x * (**i).fScaleU;
					pvOut->y = pvBase->y * (**i).fScaleV;

					// offset
					pvOut->x += (**i).fOffsetU;
					pvOut->y += (**i).fOffsetV;

					pvBase++;
					pvOut++;
				}
			}
			else
			{
				const float fSin = sinf((**i).fRotation);
				const float fCos = cosf((**i).fRotation);
				for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)
				{
					// scaling
					pvOut->x = pvBase->x * (**i).fScaleU;
					pvOut->y = pvBase->y * (**i).fScaleV;

					// rotation
					pvOut->x *= fCos;
					pvOut->y *= fSin;

					// offset
					pvOut->x += (**i).fOffsetU;
					pvOut->y += (**i).fOffsetV;

					pvBase++;
					pvOut++;
				}
			}
		}

		// now check which source texture coordinate sets
		// can be deleted because they're not anymore required
		for (iNum = 0; iNum < AI_MAX_NUMBER_OF_TEXTURECOORDS;++iNum)
		{
			for (unsigned int z = 0; z < iNumUntransformed;++z)
			{
				if (apvOriginalSets[iNum] == pcMesh->mTextureCoords[z])
				{
					apvOriginalSets[iNum] = NULL;
					break;
				}
			}
			if (apvOriginalSets[iNum])delete[] apvOriginalSets[iNum];
		}
	}

	// setup bitflags to indicate which texture coordinate
	// channels are used (this class works for 2d texture coordinates only)

	unsigned int iIndex = 0;
	while (pcMesh->HasTextureCoords(iIndex))pcMesh->mNumUVComponents[iIndex++] = 2;
	return;
}
// ------------------------------------------------------------------------------------------------
void TextureTransform::SetupMatUVSrc (aiMaterial* pcMat, const D3DS::Material* pcMatIn)
{
	ai_assert(NULL != pcMat);
	ai_assert(NULL != pcMatIn);
	
	MaterialHelper* pcHelper = (MaterialHelper*)pcMat;

	if(pcMatIn->sTexDiffuse.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexDiffuse.iUVSrc,1,
			AI_MATKEY_UVWSRC_DIFFUSE(0));

	if(pcMatIn->sTexSpecular.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexSpecular.iUVSrc,1,
			AI_MATKEY_UVWSRC_SPECULAR(0));

	if(pcMatIn->sTexEmissive.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexEmissive.iUVSrc,1,
			AI_MATKEY_UVWSRC_EMISSIVE(0));

	if(pcMatIn->sTexBump.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexBump.iUVSrc,1,
			AI_MATKEY_UVWSRC_HEIGHT(0));

	if(pcMatIn->sTexShininess.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexShininess.iUVSrc,1,
			AI_MATKEY_UVWSRC_SHININESS(0));

	if(pcMatIn->sTexOpacity.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexOpacity.iUVSrc,1,
			AI_MATKEY_UVWSRC_OPACITY(0));

	if(pcMatIn->sTexAmbient.mMapName.length() > 0)
		pcHelper->AddProperty<int>(&pcMatIn->sTexAmbient.iUVSrc,1,
			AI_MATKEY_UVWSRC_AMBIENT(0));
}
};