GUIs Rendered on an object: guiDynamicTexture for TSE

// if we have a gui texture canvas then let
   // it know we want an update on the next frame.
   if( mMaterial->guiTextureCanvas )
   {
      mMaterial->guiTextureCanvas->setDirty();
   }

F32 getArea( const Point3F* verts, S32 count )
{
	// Vector whose length will be area^2.
	Point3F vec( 0, 0, 0 );
	for ( S32 i = 0; i < count; i++ ) {

      S32 j = i ? i - 1 : count - 1;

      // Add cross_product(pnts[j],pnts[i]).
		vec.x += verts[j].y * verts[i].z - verts[j].z * verts[i].y;
		vec.y += verts[j].z * verts[i].x - verts[j].x * verts[i].z;
		vec.z += verts[j].x * verts[i].y - verts[j].y * verts[i].x;
	}
   
	// Find length of vector, return it.
	return mSqrt( vec.x * vec.x + vec.y * vec.y + vec.z * vec.z ) / 2.0f;
}

Point3F getBarrycentricCoord( const Point3F& point, const Point3F* tri )
{
	// If the area of the triangle is zero... return 0.
	const F32 a = getArea( tri, 3 );

	if ( a <= 0.0f )
      return Point3F( 0, 0, 0 );

	Point3F b;
	{
      Point3F temp[3] =
      {
         tri[1],
         tri[2],
         point
      };
		b.x = getArea( temp, 3 ) / a;
	}
	{
      Point3F temp[3] =
      {
         tri[2],
         tri[0],
         point
      };
		b.y = getArea( temp, 3 ) / a;
	}
	{
      Point3F temp[3] =
      {
         tri[0],
         tri[1],
         point
      };
		b.z = getArea( temp, 3 ) / a;
	}

   return b;
}

bool rayTriangleIntersect( const Point3F& orig, const Point3F& dir,
   const Point3F& vert0, const Point3F& vert1, const Point3F& vert2,
   F32 *t, F32 *u, F32 *v )
{
   const F32 EPSILON = __EQUAL_CONST_F;

   /* find vectors for two edges sharing vert0 */
   Point3F edge1( vert1 -  vert0 );
   Point3F edge2( vert2 -  vert0 );

   /* begin calculating determinant - also used to calculate U parameter */
   Point3F pvec( mCross( dir, edge2 ) );

   /* if determinant is near zero, ray lies in plane of triangle */
   F32 det = mDot( edge1, pvec );

   if (det < EPSILON)
      return 0;

   /* calculate distance from vert0 to ray origin */
   Point3F tvec( orig - vert0 );

   /* calculate U parameter and test bounds */
   *u = mDot( tvec, pvec );
   if (*u < 0.0 || *u > det)
      return false;

   /* prepare to test V parameter */
   Point3F qvec( mCross( tvec, edge1 ) );

   /* calculate V parameter and test bounds */
   *v = mDot( dir, qvec );
   if (*v < 0.0 || *u + *v > det)
      return false;

   /* calculate t, scale parameters, ray intersects triangle */
   F32 inv_det = 1.0 / det;
   *t = mDot( edge2, qvec ) * inv_det;
   *u *= inv_det;
   *v *= inv_det;

   return true;
}

/// Returns the area of a polygon.
F32 getArea( const Point3F* verts, S32 count );

/// Returns the barrycentric coordinate for a point on a triangle.
Point3F getBarrycentricCoord( const Point3F& point, const Point3F* tri );

/// Returns the intersection of a ray and a triangle.
bool rayTriangleIntersect( const Point3F& orig, const Point3F& dir, const Point3F& vert0, const Point3F& vert1, const Point3F& vert2, F32 *t, F32 *u, F32 *v );

dSprintf(returnBuffer, 256, "%d %g %g %g %g %g %g",
               ret, rinfo.point.x, rinfo.point.y, rinfo.point.z,
               rinfo.normal.x, rinfo.normal.y, rinfo.normal.z);

dSprintf(returnBuffer, 256, "%d %g %g %g %g %g %g %d",
               ret, rinfo.point.x, rinfo.point.y, rinfo.point.z,
               rinfo.normal.x, rinfo.normal.y, rinfo.normal.z, 
               rinfo.material);

//GuiTextureCanvas Change
      rayInfo->material = 0;

      // Find the material object id for the texture id
      // that TSMesh::castRay() set for us.
      if ( mMaterialList ) 
      {
         MatInstance* matInst = mMaterialList->getMaterialInst( rayInfo->material );
         if ( matInst && matInst->getMaterial() ) 
            rayInfo->material = matInst->getMaterial()->getId();
      }
      //GuiTextureCanvas Change

bool TSMesh::castRayTri( S32 frame, const Point3F& start, const Point3F& end, TriRayInfo* rayInfo )
{
   // Loop thru the triangles of the first frame.
   const S32 firstVert = vertsPerFrame * frame;

   F32 hit = F32_MAX;

   Point3F dir( end - start );
   dir.normalizeSafe();

   for ( S32 i=0; i < primitives.size(); i++ )
   {
      const TSDrawPrimitive& draw = primitives[i];

      AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::castRayTri, got non-indexed primitive!" );

      // gonna depend on what kind of primitive it is...
      if ( ( draw.matIndex & TSDrawPrimitive::TypeMask ) == TSDrawPrimitive::Triangles )
      {
         for ( S32 j=0; j < draw.numElements; j+=3 )
         {
            const U32 idx0 = indices[draw.start+j+0] + firstVert;
            const U32 idx1 = indices[draw.start+j+1] + firstVert;
            const U32 idx2 = indices[draw.start+j+2] + firstVert;

            F32 h, u, v;
            if ( MathUtils::rayTriangleIntersect( start, dir, verts[idx2], verts[idx1], 
               verts[idx0], &h, &v, &u ) && h < hit ) 
            {
               hit = h;

               rayInfo->distance = hit;
               rayInfo->point = start + ( dir * hit );
               rayInfo->material = draw.matIndex & TSDrawPrimitive::MaterialMask;

               Point3F temp[3] =
               {
                  verts[idx0],
                  verts[idx1],
                  verts[idx2]
               };
               Point3F bc = MathUtils::getBarrycentricCoord( rayInfo->point, temp );

               rayInfo->uv = Point2F( 
                  (bc.x * tverts[idx0].x) + (bc.y * tverts[idx1].x) + (bc.z * tverts[idx2].x ),
                  (bc.x * tverts[idx0].y) + (bc.y * tverts[idx1].y) + (bc.z * tverts[idx2].y ) );
            }
         }
      }
      else
      {
         AssertFatal( ( draw.matIndex & TSDrawPrimitive::Strip ) == TSDrawPrimitive::Strip, "TSMesh::castRayTri, unexpected primitive type!" );

         U32 idx0 = indices[draw.start + 0] + firstVert;
         U32 idx1;
         U32 idx2 = indices[draw.start + 1] + firstVert;
         U32* nextIdx = &idx1;
         for ( S32 j = 2; j < draw.numElements; j++ )
         {
            *nextIdx = idx2;
            nextIdx = (U32*) ( (dsize_t)nextIdx ^ (dsize_t)&idx0 ^ (dsize_t)&idx1);
            idx2 = indices[draw.start + j] + firstVert;

            F32 h, u, v;
            if ( MathUtils::rayTriangleIntersect( start, dir, verts[idx2], verts[idx1], 
               verts[idx0], &h, &v, &u ) && h < hit )
            {
               hit = h;

               rayInfo->distance = hit;
               rayInfo->point = start + ( dir * hit );
               rayInfo->material = draw.matIndex & TSDrawPrimitive::MaterialMask;

               Point3F temp[3] =
               {
                  verts[idx0],
                  verts[idx1],
                  verts[idx2]
               };
               Point3F bc = MathUtils::getBarrycentricCoord( rayInfo->point, temp );

               rayInfo->uv = Point2F( 
                  (bc.x * tverts[idx0].x) + (bc.y * tverts[idx1].x) + (bc.z * tverts[idx2].x ),
                  (bc.x * tverts[idx0].y) + (bc.y * tverts[idx1].y) + (bc.z * tverts[idx2].y ) );
            }
         }
      }
   }

   return hit < F32_MAX;
}

#define SMALL_FLOAT (1e-12)

//-----------------------------------------------------------------------------
// createTextureSpaceMatrix
//-----------------------------------------------------------------------------
void TSMesh::createTextureSpaceMatrix( MeshVertex *v0, MeshVertex *v1, MeshVertex *v2 )
{
   Point3F edge1, edge2;
   Point3F cp;

   // x, s, t
	edge1.set( v1->point.x - v0->point.x, v1->texCoord.x - v0->texCoord.x, v1->texCoord.y - v0->texCoord.y );
	edge2.set( v2->point.x - v0->point.x, v2->texCoord.x - v0->texCoord.x, v2->texCoord.y - v0->texCoord.y );

   mCross( edge1, edge2, &cp );
   if( fabs(cp.x) > SMALL_FLOAT )
   {
		v0->T.x = -cp.y / cp.x;
		v0->B.x = -cp.z / cp.x;

		v1->T.x = -cp.y / cp.x;
		v1->B.x = -cp.z / cp.x;

		v2->T.x = -cp.y / cp.x;
		v2->B.x = -cp.z / cp.x;
   }

   // y, s, t
	edge1.set( v1->point.y - v0->point.y, v1->texCoord.x - v0->texCoord.x, v1->texCoord.y - v0->texCoord.y );
	edge2.set( v2->point.y - v0->point.y, v2->texCoord.x - v0->texCoord.x, v2->texCoord.y - v0->texCoord.y );

   mCross( edge1, edge2, &cp );
   if( fabs(cp.x) > SMALL_FLOAT )
   {
		v0->T.y = -cp.y / cp.x;
		v0->B.y = -cp.z / cp.x;

		v1->T.y = -cp.y / cp.x;
		v1->B.y = -cp.z / cp.x;

		v2->T.y = -cp.y / cp.x;
		v2->B.y = -cp.z / cp.x;
   }

   // z, s, t
	edge1.set( v1->point.z - v0->point.z, v1->texCoord.x - v0->texCoord.x, v1->texCoord.y - v0->texCoord.y );
	edge2.set( v2->point.z - v0->point.z, v2->texCoord.x - v0->texCoord.x, v2->texCoord.y - v0->texCoord.y );

   mCross( edge1, edge2, &cp );
   if( fabs(cp.x) > SMALL_FLOAT )
   {
		v0->T.z = -cp.y / cp.x;
		v0->B.z = -cp.z / cp.x;

		v1->T.z = -cp.y / cp.x;
		v1->B.z = -cp.z / cp.x;

		v2->T.z = -cp.y / cp.x;
		v2->B.z = -cp.z / cp.x;
   }

   // v0
   v0->T.normalizeSafe();
   v0->B.normalizeSafe();
   mCross( v0->T, v0->B, &v0->N );
   if( mDot( v0->N, v0->normal ) < 0.0 )
   {
      v0->N = -v0->N;
   }

   // v1
   v1->T.normalizeSafe();
   v1->B.normalizeSafe();
   mCross( v1->T, v1->B, &v1->N );
   if( mDot( v1->N, v1->normal ) < 0.0 )
   {
      v1->N = -v1->N;
   }

   // v2
   v2->T.normalizeSafe();
   v2->B.normalizeSafe();
   mCross( v2->T, v2->B, &v2->N );
   if( mDot( v2->N, v2->normal ) < 0.0 )
   {
      v2->N = -v2->N;
   }

}

//-----------------------------------------------------------------------------
// Fills in texture space matrix portion of each vertex - for bumpmapping
//-----------------------------------------------------------------------------
void TSMesh::fillTextureSpaceInfo( MeshVertex *vertArray )
{
   for (S32 i=0; i<primitives.size(); i++)
   {
      TSDrawPrimitive & draw = primitives[i];
      GFXPrimitiveType drawType = getDrawType(draw.matIndex>>30);


      U32 numPrims = 0;
      U32 p1Index = 0;
      U32 p2Index = 0;

      U16 *baseIdx = &indices[draw.start];

      switch( drawType )
      {
         case GFXTriangleList:
         {
            for( U32 j=0; j<draw.numElements; j+=3 )
            {
               createTextureSpaceMatrix( &vertArray[baseIdx[j]], &vertArray[baseIdx[j+1]], &vertArray[baseIdx[j+2]] );
            }
            break;
         }

         case GFXTriangleStrip:
         {
            p1Index = baseIdx[0];
            p2Index = baseIdx[1];
            for( U32 j=2; j<draw.numElements; j++ )
            {
               createTextureSpaceMatrix( &vertArray[p1Index], &vertArray[p2Index], &vertArray[baseIdx[j]] );
               p1Index = p2Index;
               p2Index = baseIdx[j];
            }
            break;
         }
         case GFXTriangleFan:
         {
            p1Index = baseIdx[0];
            p2Index = baseIdx[1];
            for( U32 j=2; j<draw.numElements; j++ )
            {
               createTextureSpaceMatrix( &vertArray[p1Index], &vertArray[p2Index], &vertArray[baseIdx[j]] );
               p2Index = baseIdx[j];
            }
            break;
         }

         default:
            AssertFatal( false, "WTF?!" );
      }

   }

}

new GuiTextureCanvas( MonitorCanvas ) 
{
   guiControl = "optionsDlg";
};

new Material(MonitorMat) 
{
   guiTextureCanvas = "MonitorCanvas";

   baseTex[0] = "$gui"; 
   emissive[0] = true;

   mapTo = "MONITOR";
};