Irrlicht Engine

Code: Select all

//! computes the tangents for a mesh buffer. If either parameter is false, that tangent will not
		//! be computed. 
		//! to make sure that the TBN matrix will have 3 mutually orthagonal axes,
		//! we need to recompute normals. It is possible that a solution could be devised
		//! which does not need to recompute normals, but this is easiest
		//! \param sTangent: create with s tangents (tangents)
		//! \param tTangent: create with t tangents (binormals)
	 	void CMeshBuffer::calculateTangents(bool sTangents, bool tTangents)
	 	{
			/* TODO (electron): Clean up this function and figure out what's going on, 
			                       what calculations are necessary We assume CW trianglewinding, which is 
										  rather bad form. The CCW winding code is commented out below
										  but untested*/
			
			
			//first we zero out all normals and tangents
			u32 cnt=vertexBuffer->getVertexCount();
			core::vector3df vecZero(0,0,0);
			for(u32 i = 0;i < cnt;i++)
			{
				vertexBuffer->setNormal(i,vecZero);
				if(sTangents)
				{
					vertexBuffer->setTangentS(i,vecZero);
				}
				if(tTangents)
				{
					vertexBuffer->setTangentT(i,vecZero);
				}
			}
			
			//we loop through all triangles and add
			//the normals and tangents for each triangle a vertex belongs to
			for(u32 i = 0;i < indexBuffer->getIndexCount() - 2;i += 3)
			{
				u32 idx0 = indexBuffer->getIndex32Safe(i);
				u32 idx1 = indexBuffer->getIndex32Safe(i + 1);
				u32 idx2 = indexBuffer->getIndex32Safe(i + 2);
				calculateTangentsForVertex(idx0,idx1,idx2,sTangents,tTangents);
				calculateTangentsForVertex(idx1,idx2,idx0,sTangents,tTangents);
				calculateTangentsForVertex(idx2,idx0,idx1,sTangents,tTangents);	
				//calculateTangentsForVertex(idx2,idx1,idx0,sTangents,tTangents);
				//calculateTangentsForVertex(idx1,idx0,idx2,sTangents,tTangents);
				//calculateTangentsForVertex(idx0,idx2,idx1,sTangents,tTangents);
			}
			//normalize all normals and tangents
			for(u32 i = 0;i < vertexBuffer->getVertexCount();i++)
			{
				core::vector3df vec=vertexBuffer->getNormal(i);
				vec.normalize();
				vertexBuffer->setNormal(i,vec);
				vec=vertexBuffer->getNormal(i);
				if(sTangents)
				{
					vec=vertexBuffer->getTangentS(i);
					vec.normalize();
					vertexBuffer->setTangentS(i,vec);
				}
				if(tTangents)
				{
					vec=vertexBuffer->getTangentT(i);
					vec.normalize();
					vertexBuffer->setTangentT(i,vec);
				}
			}
		}
		
		void CMeshBuffer::calculateTangentsForVertex(u32 idx0,u32 idx1, u32 idx2,bool sTangents, bool tTangents)
		{
			//i know the vertex and index buffer is slow here
			//with different types and data sizes this is the easiest and safest way, but it might
			//might be worthwhile to implement this a faster way
			//Irrlicht calcualtes matrix seperately for each evertex in a triangle
			//but should probably be safe to do it once per triangle. I'm sticking with
			//Irrlicht's way for now though
			core::vector3df vtx1=vertexBuffer->getPosition(idx0);
			core::vector3df vtx2=vertexBuffer->getPosition(idx1);
			core::vector3df vtx3=vertexBuffer->getPosition(idx2);
			core::position2d<f32> t1=vertexBuffer->getTextureCoord(idx0,0);
			core::position2d<f32> t2=vertexBuffer->getTextureCoord(idx1,0);
			core::position2d<f32> t3=vertexBuffer->getTextureCoord(idx2,0);
			//the following code is adapted from code in the 
			//Irrlicht engine by Nikolaus Gebhardt
			//and from code given at http://www.paulsprojects.net/tutorials/simplebump/simplebump.html
			core::vector3df v1 = vtx1 - vtx2;
			core::vector3df v2 = vtx3 - vtx1;
			core::vector3df normal = v2.crossProduct(v1);
			//I believe it would be better (in terms of smoothness) to normalize only at the end of adding in all
			//the normals from the different triangles a vertex is part of
			//but to retain orthagonality with the tangents
			//I believe it is imperative that we normalize here,
			//though its something to look into
			normal.normalize();
			
			
			// binormal (t tangent)
			f32 deltaX1 = t1.X - t2.X;
			f32 deltaX2 = t3.X - t1.X;
			core::vector3df tTangent = (v1 * deltaX2) - (v2 * deltaX1);
			tTangent.normalize();
			
			// tangent (s tangent)
			f32 deltaY1 = t1.Y - t2.Y;
			f32 deltaY2 = t3.Y - t1.Y;
			core::vector3df sTangent = (v1 * deltaY2) - (v2 * deltaY1);
			sTangent.normalize();
			
			// adjust
			core::vector3df txb = sTangent.crossProduct(tTangent);
			if (txb.dotProduct(normal) < 0.0f)
			{
				sTangent *= -1.0f;
				tTangent *= -1.0f;
			}
			
			vertexBuffer->setNormal(idx0,vertexBuffer->getNormal(idx0)+normal);
			if(sTangents)
			{
				vertexBuffer->setTangentS(idx0,vertexBuffer->getTangentS(idx0)+sTangent);
			}
			if(tTangents)
			{
				vertexBuffer->setTangentT(idx0,vertexBuffer->getTangentT(idx0)+tTangent);
			}
		}