Wrapped decals

void DecalManager::renderWrapDecal()
{
	for(S32 x=0; x<mWrapDecalQueue.size(); x++)
		mWrapDecalQueue[x]->buildWrapDecal();
	
	if (mDefaultSB.isNull())
	{
		GFXStateBlockDesc desc;
		desc.setCullMode(GFXCullNone);
		desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);
		desc.setZEnable(true);
		desc.zFunc = GFXCmpLessEqual;
		desc.zWriteEnable = false;
		desc.setAlphaTest(true, GFXCmpGreater, 0);
		desc.samplersDefined = true;
		desc.samplers[0].textureColorOp = GFXTOPModulate;
		desc.samplers[1].textureColorOp = GFXTOPDisable;
		
		F32 depthbias = -0.00006f;
		F32 slopebias = -0.06f;
		
		desc.zBias = depthbias;
		desc.zSlopeBias = slopebias;
		
		mDefaultSB = GFX->createStateBlock(desc);
		
		desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendOne);
		
		mSelfIlluminatedSB = GFX->createStateBlock(desc);
	}
	
	sgThisIsSelfIlluminated = false;
	
	for(S32 x=0; x<mWrapDecalQueue.size(); x++)
	{
		sgThisIsSelfIlluminated = mWrapDecalQueue[x]->decalData->selfIlluminated;
		if(sgThisIsSelfIlluminated)
		{
			GFX->setStateBlock(mSelfIlluminatedSB);
		}
		else
		{
			GFX->setStateBlock(mDefaultSB);
		}

		GFX->setTexture(0, mWrapDecalQueue[x]->decalData->textureHandle);
		GFX->setVertexBuffer(mWrapDecalQueue[x]->exData->mWrapDecalBuffer);

		GFX->multWorld(mWrapDecalQueue[x]->exData->mTransform);
		
		for (U32 i = 0; i < mWrapDecalQueue[x]->exData->mPartition.size(); i++)
			GFX->drawPrimitive(GFXTriangleFan, mWrapDecalQueue[x]->exData->mPartition[i].vertexStart, (mWrapDecalQueue[x]->exData->mPartition[i].vertexCount - 2));
	}
}

void DecalManager::addWrapDecal(const Point3F& pos,
                            Point3F normal,
                            Point3F impactNormal,
                            DecalData *decalData)
{
   if (smMaxNumDecals == 0)
      return;

   if(mWrapDecalQueue.size() >= smMaxNumDecals)
   {
      findWrapSpace();
   }
   DecalInstance* newDecal = allocateWrapDecalInstance();
   newDecal->decalData = decalData;
   newDecal->allocTime = Platform::getVirtualMilliseconds();
   newDecal->position = pos;
   newDecal->normal = normal;
   newDecal->impactNormal = impactNormal;
   mWrapDecalQueue.push_back(newDecal);
   mWrapQueueDirty = true;
}

void DecalInstance::buildWrapDecal()
{
   DecalExData *nData=new DecalExData;
   exData=nData;
   Point3F vecX, vecY;

   // construct matrix
   Point3F x,y,z;
   y = impactNormal;
   if (mFabs(y.z)>0.001f)
   {
      //mCross(y,Point3F(1,0,0),&z);
      z.set(0,y.z,-y.x);
      z.normalizeSafe();
      mCross(y,z,&x);
      x.normalizeSafe();
   }
   else
   {
      //mCross(y,Point3F(0,0,1),&x);
      x.set(y.y,-y.x,0);
      x.normalizeSafe();
      mCross(x,y,&z);
      z.normalizeSafe();
   }

   F32 ySkew = mFabs(mDot(impactNormal,normal));
   F32 xFactor, yFactor;
   if (ySkew>0)
   {
      xFactor=2*ySkew;
      yFactor=2/ySkew;
   }
   else
   {
      xFactor=2;
      yFactor=2;
   }

   // backup a bit (for the transforms) so that we can see the polys
   Point3F mPosition = Point3F(position.x + (-impactNormal.x * decalData->sizeX*2), 
                              position.y + (-impactNormal.y * decalData->sizeY*2), 
                              position.z + (-impactNormal.z * decalData->sizeX*2));

   MatrixF decalToWorld(true);
   decalToWorld.setColumn(0,x);
   decalToWorld.setColumn(1,y);
   decalToWorld.setColumn(2,z);
   decalToWorld.setColumn(3,mPosition);

   exData->mTransform = decalToWorld;

   MatrixF worldToDecal = decalToWorld;
   worldToDecal.inverse();

   // setup depth sort list
   // expanded allow the image to stretch
   Point3F extent(decalData->sizeX*5,decalData->sizeY*5,decalData->sizeX*5);
   smDepthSortList.clear();
   smDepthSortList.set(worldToDecal,extent);
   smDepthSortList.setInterestNormal(impactNormal);

   // build world space box and sphere around decal
   x *= decalData->sizeX*2;
   y *= decalData->sizeY*2;
   z *= decalData->sizeX*2;
   gDecalBox.maxExtents.set(mFabs(x.x)+mFabs(y.x)+mFabs(z.x),
                     mFabs(x.y)+mFabs(y.y)+mFabs(z.y),
                     mFabs(x.z)+mFabs(y.z)+mFabs(z.z));
   gDecalSphere.radius = gDecalBox.maxExtents.len();
   gDecalSphere.center = position;
   gDecalBox.minExtents  = position - gDecalBox.maxExtents;
   gDecalBox.maxExtents += position;

   // get polys
   gClientContainer.findObjects(smDecalMask,collisionCallback,this);

   // setup partition list
   gDecalPoly[0].set(-decalData->sizeX,0,-decalData->sizeY);
   gDecalPoly[1].set(-decalData->sizeX,0,decalData->sizeY);
   gDecalPoly[2].set(decalData->sizeX,0,decalData->sizeY);
   gDecalPoly[3].set(decalData->sizeX,0,-decalData->sizeY);

   exData->mPartition.clear();
   exData->mPartitionVerts.clear();
   smDepthSortList.depthPartition(gDecalPoly,4,exData->mPartition,exData->mPartitionVerts);

   if (exData->mPartitionVerts.size()>0)
   {
      exData->mWrapDecalBuffer.set(GFX, exData->mPartitionVerts.size(), GFXBufferTypeVolatile);
      exData->mWrapDecalBuffer.lock();
      // now set up tverts
      exData->mPartitionTVerts.setSize(exData->mPartitionVerts.size());
      F32 invSizeX = 1.0f / (decalData->sizeX);
	  F32 invSizeY = 1.0f / (decalData->sizeY);

      for (S32 i=0; i<exData->mPartitionVerts.size(); i++)
      {
         Point3F vert = exData->mPartitionVerts[i];
         exData->mWrapDecalBuffer[i].point.set(vert);
         exData->mWrapDecalBuffer[i].color.set(255, 255, 255, fade * 255.0f);
         exData->mWrapDecalBuffer[i].texCoord.set(0.5f + 0.5f * exData->mPartitionVerts[i].x * invSizeX, 0.5f + 0.5f * exData->mPartitionVerts[i].z * invSizeY);
      };

      exData->mWrapDecalBuffer.unlock();
   }
   smDepthSortList.clear();
}