/* 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& 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::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& materials) { unsigned int iNum = 0; for (std::vector::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 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 sFilteredOps; unsigned int iNumUntransformed = 0; sFilteredOps.reserve(sOps.size()); { std::vector sWishList; sWishList.reserve(sOps.size()); for (unsigned int iUV = 0; iUV < AI_MAX_NUMBER_OF_TEXTURECOORDS;++iUV) { for (std::vector::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::const_iterator nash = sWishList.begin(); for (;nash != sWishList.end()-iDiff;++nash) { sFilteredOps.push_back(*nash); } } else { for (std::vector::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::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::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(&pcMatIn->sTexDiffuse.iUVSrc,1, AI_MATKEY_UVWSRC_DIFFUSE(0)); if(pcMatIn->sTexSpecular.mMapName.length() > 0) pcHelper->AddProperty(&pcMatIn->sTexSpecular.iUVSrc,1, AI_MATKEY_UVWSRC_SPECULAR(0)); if(pcMatIn->sTexEmissive.mMapName.length() > 0) pcHelper->AddProperty(&pcMatIn->sTexEmissive.iUVSrc,1, AI_MATKEY_UVWSRC_EMISSIVE(0)); if(pcMatIn->sTexBump.mMapName.length() > 0) pcHelper->AddProperty(&pcMatIn->sTexBump.iUVSrc,1, AI_MATKEY_UVWSRC_HEIGHT(0)); if(pcMatIn->sTexShininess.mMapName.length() > 0) pcHelper->AddProperty(&pcMatIn->sTexShininess.iUVSrc,1, AI_MATKEY_UVWSRC_SHININESS(0)); if(pcMatIn->sTexOpacity.mMapName.length() > 0) pcHelper->AddProperty(&pcMatIn->sTexOpacity.iUVSrc,1, AI_MATKEY_UVWSRC_OPACITY(0)); if(pcMatIn->sTexAmbient.mMapName.length() > 0) pcHelper->AddProperty(&pcMatIn->sTexAmbient.iUVSrc,1, AI_MATKEY_UVWSRC_AMBIENT(0)); } };