x1 - x2      x4 � x2
--------  =  --------
y1 � y2     y4 � y2

and 

c1 � c2        c4 � c2
--------   =   --------
y1 � y2        y4 � y2

 

denominator = (v0-v2)(u1-u2) � (v1-v2)(u0-u2)

dp      dx       (x1-x2)(v0-v2) � (x0-x2)(v1-v2)
--- =  ---  =  --------------------------------------
du      du               denominator  


dp      dx       (x1-x2)(u0-u2) � (x0-x2)(u1-u2)
--- =  ---  =  --------------------------------------
dv      dv               -denominator


dq      dy       (y1-y2)(v0-v2) � (y0-y2)(v1-v2)
--- =  ---  =  --------------------------------------
du      du               denominator  


dq      dy       (y1-y2)(u0-u2) � (y0-y2)(u1-u2)
--- =  ---  =  --------------------------------------
dv      dv               -denominator
 

duv.x = uv->x � u0
duv.y = uv->y � v0
 

struct Lumel
{
    D3DXVECTOR3     Position ;       // lumel position in the world.
    D3DXVECTOR3     Normal ;         // lumel normal (used for 
                                     // calculating N.L)
    DWORD           Color ;          // final color.
    BYTE            r, g, b, a;      // the red, green, blue and alpha 
                                     // component.
    int             LegalPosition ;  // is this lumel legal.
    DWORD           polygonIndex ;   // index of the polygon that it 
                                     // belongs to.
} ;
 

struct LMVertex
{
    D3DXVECTOR3  Position ;        // vertex position.
    D3DXVECTOR3  Normal ;          // vertex normal
    DWORD        Color ;           // vertex color.
    D3DXVECTOR2  t0 ;              // diffuse texture co-ordinates.
    D3DXVECTOR2  t1 ;              // light map texture co-ordinates.
} ;
 

struct LMPolygon
{
    LMVertex      *vertices ;           // array of vertices.
    WORD          *indices ;            // array of indices.
    DWORD         VertexCount,          // No. of vertices in the array
                  FaceCount ;           // No. of faces to draw in this
                                        // polygon.

    DWORD         DiffuseTextureIndex ; // the index in to the diffuse
                                        // texture array

    DWORD         LMTextureIndex ;      // the index in to the light-map
                                        // texture array
} ;
 

BuildLumelInfo()
{
    // this function has to be called for each light map texture
    for(0 to lightmap height)
    {
        for(0 to lightmap width)
        {
            w = current width during the iteration (for loop)
            h = current height during the iteration (for loop)

            U = (w+0.5) / width
            V = (h+0.5) / height

            UV.x = U
            UV.y = V

            if (LumelGetWorldPosition(/*UV, this light map texture*/)) SUCCEEDED 
            then
                // Mark this lumel as LEGAL.
            else
            {
                // Mark this lumel as illegal � in the sense that no triangle uses this pixel / lumel.
            }
        }

    }
}


LumelGetWorldPosition( UV, light map texture )
{
    for( number of polygons sharing this light map texture )
    {

        // do the "Bounding Box" lightmap texture co-ordinate rejection // test.
        if( /*UV co-ordinates of the light map do not fall inside the 
            polygon�s MAXIMUM and MINIMUM UV co-ordinates*/ )    
        then
            //try next polygon ;

        // code for the above explanation

        if(uv->x < poly->minUV.x)   continue ;
        if(uv->y < poly->minUV.y)   continue ;
        if(uv->x > poly->maxUV.x)   continue ;
        if(uv->y > poly->maxUV.y)   continue ;

        for( /* number of faces in this polygon */ )
        {
            /*Get the three vertices that make up this face.
            Check if light map UV co-ordinates actually fall inside the polygon�s
            UV co-ordinates. This routine is similar to routines like �PointInPolygon�
            or �PointInTriangle�.

            If YES, then call GetWorldPos to get the actual world position in 3D
            for this given light map UV co-ordinate.
            
            If NO, then this is not a legal pixel, i.e. this pixel does not
            belong to THIS polygon.*/
        }
    }
}


GetWorldPos(UV uv)
{
        // get uv position relative to uv0
        duv.x = uv->x - uv0->x ;
        duv.y = uv->y - uv0->y ;

        // retrieve the components of the two major axis.
        // i.e. here we are converting from 3D triangle to 2D.

        switch(PlaneProjection)
        {
                case PLANE_XZ :
                        // collect X and Z components
                break ;

                case PLANE_XY :
                        // collect X and Y components
                break ;

                case PLANE_YZ :
                        // collect Y and Z components
                break ;
        }

        // Calculate the gradients from the equations derived above. 
        // See Equation 3 above.

        Now calculate gradients.
        i.e. dp/du, dp/dv, dq/du, dq/dv, etc.

        // In the following line, I have used a, b, instead of X, Y or Z. 
        // This is because, depending on the polygon�s plane we
        // choose either XY or YZ or XZ components. Hence, a and b map to 
        // either XY or YZ or XZ components
        pos->a = (a0) + (dpdu * duv.x) + (dpdv * duv.y)
        pos->b = (b0) + (dqdu * duv.x) + (dqdv * duv.y)

        // get the world pos in 3D
        // calculate the remaining single co-ordinate based on the polygon�s 
        // plane.

        switch(PlaneProjection)
        {
                case PLANE_XZ :
                        // We would have got X and Z as the 2D components.
                        // calculate the Y component.
                        y = -(Ax+Cz+D) / B.
                break ;

                case PLANE_XY :
                        // We would have got X and Y as the 2D components.
                        // calculate the Z component.
                        z = -(Ax+By+D) / C.
                break ;

                case PLANE_YZ :
                        // We would have got Y and Z as the 2D components.
                        // calculate the X component.
                        x = -(By+Cz+D) / A.
                break ;
        }
}
 

BuildLumelInfoForAllLightmaps()
{
    // Do initialization here.
 
    for (number of light maps)
    {
        // If memory for Lumels not allocated, then, 
        // Allocate memory to hold the lumel info for this particular
        // light map.
 
        BuildLumelInfo(this_light_map) ;     // Calculates the
                                             // world position for all the lumels.
    }
}